RDSS/core/simulator.py

#!/usr/bin/env python3
"""
事件模拟器核心类
"""

import numpy as np
import logging
from core.encoder import BitFieldEncoder

# 设置日志
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

class SampleSpaceGenerator:
    """样本空间生成器（能量单位：keV）"""
    
    @staticmethod
    def generate_from_distribution(dist_config: dict, size: int) -> np.ndarray:
        """根据配置生成样本（能量单位：keV）"""
        dist_type = dist_config['type']
        params = {k: v for k, v in dist_config.items() if k != 'type'}
        
        if dist_type == 'normal':
            return np.random.normal(params.get('mean', 0), params.get('std', 1), size)
        elif dist_type == 'uniform':
            return np.random.uniform(params.get('low', 0), params.get('high', 1), size)
        elif dist_type == 'exponential':
            # 指数分布：scale是尺度参数，loc是位置参数（延迟/偏移）
            return np.random.exponential(params.get('scale', 1), size) + params.get('loc', 0)
        elif dist_type == 'gamma':
            return np.random.gamma(params.get('shape', 1), params.get('scale', 1), size)
        elif dist_type == 'poisson':
            return np.random.poisson(params.get('lam', 1), size)
        elif dist_type == 'lognormal':
            return np.random.lognormal(params.get('mean', 0), params.get('sigma', 1), size)
        elif dist_type == 'constant':
            return np.full(size, params.get('value', 1000.0))
        else:
            raise ValueError(f"不支持的分布类型: {dist_type}")
    
    def generate_sample_space(self, detector_config: dict) -> np.ndarray:
        """生成样本空间（能量单位：keV）"""
        size = detector_config['sample_space_size']
        
        # 生成能量样本 (keV)
        energies = self.generate_from_distribution(detector_config['energy_distribution'], size)
        energies = np.abs(energies)
        
        # 生成时间戳样本 (us)
        timestamps = self.generate_from_distribution(detector_config['timestamp_distribution'], size)
        timestamps = np.abs(timestamps)
        
        # 组合成二维向量
        sample_space = np.column_stack((energies, timestamps))
        
        logger.info(f"为{detector_config['name']}生成了{size}个样本 (能量单位: keV)")
        return sample_space

class DetectorSampler:
    """探测器采样器"""
    
    def __init__(self, sample_space: np.ndarray, allow_replacement: bool = True):
        self.sample_space = sample_space
        self.size = len(sample_space)
        self.allow_replacement = allow_replacement
    
    def sample(self, num_samples: int) -> np.ndarray:
        """从样本空间抽样"""
        if num_samples <= 0:
            return np.array([])
        
        if self.allow_replacement:
            indices = np.random.choice(self.size, num_samples, replace=True)
        else:
            if num_samples > self.size:
                logger.warning(f"请求样本数({num_samples})超过样本空间大小({self.size})")
                num_samples = self.size
            indices = np.random.choice(self.size, num_samples, replace=False)
        
        return self.sample_space[indices].copy()

class EventSimulatorV4:
    """事件模拟器 V4（支持三种事件生成模式）"""
    
    def __init__(self, config: dict, pre_generated_sample_spaces: dict = None):
        self.config = config
        self.sample_generator = SampleSpaceGenerator()
        self.encoder = BitFieldEncoder()
        
        # 获取事件生成模式
        self.event_generation_mode = config['simulation'].get('event_generation_mode', 'random')
        logger.info(f"使用事件生成模式: {self.event_generation_mode}")
        
        # 获取能量转换参数
        energy_conversion = config['simulation'].get('energy_conversion', {})
        self.energy_K = energy_conversion.get('K', 1.0)
        self.energy_B = energy_conversion.get('B', 0.0)
        logger.info(f"能量转换参数: K={self.energy_K}, B={self.energy_B} (mV = keV * K + B)")
        
        # 初始化探测器配置（所有模式都需要）
        self.detectors = self._initialize_detectors()
        
        # 对于随机模式，需要样本空间和采样器
        if self.event_generation_mode == 'random':
            # 使用预生成的样本空间（如果提供），否则生成新的
            if pre_generated_sample_spaces:
                logger.info("使用预生成的样本空间")
                self.sample_spaces = pre_generated_sample_spaces
            else:
                logger.info("生成新的样本空间")
                self.sample_spaces = self._generate_sample_spaces()
            
            self.samplers = {}
            for name, sample_space in self.sample_spaces.items():
                allow_replacement = self.detectors[name]['allow_replacement']
                self.samplers[name] = DetectorSampler(sample_space, allow_replacement)
        else:
            # 固定模式和脉冲模式不需要样本空间
            self.sample_spaces = {}
            self.samplers = {}
        
        # 加载固定事件配置
        self.fixed_events_config = config.get('fixed_events', {})
        
        # 加载脉冲信号配置
        self.pulse_signals_config = config.get('pulse_signals', {})
    
    def _initialize_detectors(self) -> dict:
        """初始化探测器配置"""
        detectors = {}
        
        for det_name, det_config in self.config['detectors'].items():
            detectors[det_name] = det_config
        
        return detectors
    
    def _generate_sample_spaces(self) -> dict:
        """为所有探测器生成样本空间（仅随机模式使用）"""
        sample_spaces = {}
        
        for name, detector_config in self.detectors.items():
            sample_spaces[name] = self.sample_generator.generate_sample_space(detector_config)
        
        return sample_spaces
    
    def generate_event_random(self, event_id: int) -> list:
        """
        随机模式：生成一个随机事件
        
        返回:
            事件信号列表
        """
        sampling_config = self.config['simulation']['sampling']
        require_signal = sampling_config.get('require_signal', True)
        
        # 为每个探测器随机确定信号数量
        num_signals = {
            name: np.random.randint(
                sampling_config['min_signals_per_detector'],
                sampling_config['max_signals_per_detector'] + 1
            )
            for name in self.detectors.keys()
        }
        
        # 从每个探测器抽样
        detector_signals = {}
        for name, sampler in self.samplers.items():
            samples = sampler.sample(num_signals[name])
            
            if len(samples) > 0:
                sorted_indices = np.argsort(samples[:, 1])
                detector_signals[name] = samples[sorted_indices]
            else:
                detector_signals[name] = np.array([])
        
        # 合并所有探测器信号并编码为64位整数
        encoded_events = self._merge_and_encode_signals(detector_signals, require_signal)
        
        # 获取最大时间戳用于事件结束标记
        max_timestamp = 0
        if encoded_events:
            for encoded in encoded_events:
                decoded = self.encoder.decode(encoded)
                if decoded['timestamp'] > max_timestamp:
                    max_timestamp = decoded['timestamp']
        
        # 设置最后一个信号的事件结束标志位
        if encoded_events:
            encoded_events[-1] = self.encoder.set_event_end_flag(encoded_events[-1])
        else:
            # 如果没有信号，创建一个结束标记信号
            end_signal = self.encoder.encode(max_timestamp, [0, 0, 0], event_end=True)
            encoded_events.append(end_signal)
        
        return encoded_events
    
    def generate_event_fixed(self, event_id: int) -> list:
        """
        固定模式：生成一个固定模式的事件
        
        返回:
            事件信号列表
        """
        config = self.fixed_events_config
        
        # 获取配置参数
        num_signals = config.get('num_signals_per_event', 5)
        energy_levels = config.get('energy_levels', {})
        timestamps = config.get('timestamps', [])
        repeat_pattern = config.get('repeat_pattern', True)
        
        # 准备能量数据
        det1_energies = energy_levels.get('detector1', [1000] * num_signals)
        det2_energies = energy_levels.get('detector2', [800] * num_signals)
        det3_energies = energy_levels.get('detector3', [500] * num_signals)
        
        # 准备时间戳
        if repeat_pattern and len(timestamps) > 0:
            # 重复时间戳模式
            timestamps_cycle = timestamps * ((num_signals // len(timestamps)) + 1)
            timestamps_used = timestamps_cycle[:num_signals]
        else:
            # 使用递增时间戳
            if len(timestamps) >= num_signals:
                timestamps_used = timestamps[:num_signals]
            else:
                base_timestamp = 10
                interval = 50
                timestamps_used = [base_timestamp + i * interval for i in range(num_signals)]
        
        # 确保数组长度一致
        det1_energies = self._ensure_length(det1_energies, num_signals, 1000)
        det2_energies = self._ensure_length(det2_energies, num_signals, 800)
        det3_energies = self._ensure_length(det3_energies, num_signals, 500)
        
        # 编码信号
        encoded_signals = []
        for i in range(num_signals):
            timestamp = timestamps_used[i]
            energies = [det1_energies[i], det2_energies[i], det3_energies[i]]
            
            try:
                encoded = self.encoder.encode(timestamp, energies, event_end=False)
                encoded_signals.append(encoded)
            except Exception as e:
                logger.warning(f"固定模式编码信号时出错: {e}")
                # 创建一个默认信号
                default_signal = self.encoder.encode(timestamp, [0, 0, 0], event_end=False)
                encoded_signals.append(default_signal)
        
        # 设置最后一个信号的事件结束标志位
        if encoded_signals:
            encoded_signals[-1] = self.encoder.set_event_end_flag(encoded_signals[-1])
        
        logger.info(f"固定模式生成事件 {event_id+1}: {num_signals}个信号")
        return encoded_signals
    
    def generate_event_pulse(self, event_id: int) -> list:
        """
        脉冲模式：生成一个脉冲信号事件
        
        返回:
            事件信号列表
        """
        config = self.pulse_signals_config
        
        # 获取配置参数
        pulse_count = config.get('pulse_count', 10)
        pulse_interval = config.get('pulse_interval', 100)
        pulse_width = config.get('pulse_width', 5)
        energy_levels = config.get('energy_levels', {})
        jitter = config.get('jitter', 10.0)
        energy_noise = config.get('energy_noise', 100.0)
        
        # 获取各探测器基础能量
        det1_energy = energy_levels.get('detector1', 1500)
        det2_energy = energy_levels.get('detector2', 1200)
        det3_energy = energy_levels.get('detector3', 900)
        
        # 生成脉冲信号
        encoded_signals = []
        
        for pulse_idx in range(pulse_count):
            # 计算脉冲起始时间
            base_time = pulse_idx * pulse_interval
            
            # 生成脉冲内的多个信号
            for sub_idx in range(pulse_width):
                # 添加时间抖动
                time_jitter = np.random.uniform(-jitter, jitter) if jitter > 0 else 0
                timestamp = base_time + sub_idx * (pulse_interval / pulse_width) + time_jitter
                timestamp = max(0, timestamp)
                
                # 添加能量噪声
                det1_noisy = det1_energy + np.random.uniform(-energy_noise, energy_noise) if energy_noise > 0 else det1_energy
                det2_noisy = det2_energy + np.random.uniform(-energy_noise, energy_noise) if energy_noise > 0 else det2_energy
                det3_noisy = det3_energy + np.random.uniform(-energy_noise, energy_noise) if energy_noise > 0 else det3_energy
                
                # 确保能量非负
                det1_noisy = max(0, det1_noisy)
                det2_noisy = max(0, det2_noisy)
                det3_noisy = max(0, det3_noisy)
                
                energies = [det1_noisy, det2_noisy, det3_noisy]
                
                try:
                    encoded = self.encoder.encode(int(timestamp), energies, event_end=False)
                    encoded_signals.append(encoded)
                except Exception as e:
                    logger.warning(f"脉冲模式编码信号时出错: {e}")
                    # 创建一个默认信号
                    default_signal = self.encoder.encode(int(timestamp), [0, 0, 0], event_end=False)
                    encoded_signals.append(default_signal)
        
        # 设置最后一个信号的事件结束标志位
        if encoded_signals:
            encoded_signals[-1] = self.encoder.set_event_end_flag(encoded_signals[-1])
        
        logger.info(f"脉冲模式生成事件 {event_id+1}: {len(encoded_signals)}个信号")
        return encoded_signals
    
    def _ensure_length(self, array: list, target_length: int, default_value: float) -> list:
        """确保数组达到目标长度，不足时用默认值填充"""
        if len(array) >= target_length:
            return array[:target_length]
        else:
            return array + [default_value] * (target_length - len(array))
    
    def _merge_and_encode_signals(self, detector_signals: dict, require_signal: bool = True) -> list:
        """
        合并探测器信号并编码为64位整数
        
        参数:
            detector_signals: 各探测器的信号数组
            require_signal: 是否只输出有信号的探测器
            
        返回:
            编码后的64位整数列表
        """
        time_signal_map = {}
        
        for det_idx, det_name in enumerate(['detector1', 'detector2', 'detector3']):
            signals = detector_signals.get(det_name, np.array([]))
            
            for signal in signals:
                if len(signal) == 2:
                    energy_kev = signal[0]
                    timestamp_us = signal[1]
                    
                    try:
                        # 能量转换: mV = keV * K + B，结果取整
                        energy_mv = int(round(energy_kev * self.energy_K + self.energy_B))
                        
                        # 确保能量非负
                        if energy_mv < 0:
                            energy_mv = 0
                        
                        # 检查溢出
                        if energy_mv > ((1 << 14) - 1):
                            logger.warning(f"能量溢出，放弃信号: {energy_mv}mV (原始: {energy_kev}keV)")
                            continue
                        
                        if timestamp_us > ((1 << 18) - 1):
                            logger.warning(f"时间戳溢出，放弃信号: {timestamp_us}us")
                            continue
                        
                        # 添加到时间映射
                        timestamp_int = int(round(timestamp_us))
                        if timestamp_int not in time_signal_map:
                            time_signal_map[timestamp_int] = {
                                'timestamp': timestamp_int,
                                'energies': [0, 0, 0],
                                'has_signal': [False, False, False]
                            }
                        
                        time_signal_map[timestamp_int]['energies'][det_idx] = energy_mv
                        time_signal_map[timestamp_int]['has_signal'][det_idx] = True
                        
                    except Exception as e:
                        logger.warning(f"编码信号时出错，放弃: {e}")
                        continue
        
        sorted_timestamps = sorted(time_signal_map.keys())
        
        encoded_events = []
        
        for timestamp in sorted_timestamps:
            data = time_signal_map[timestamp]
            energies = data['energies']
            has_signal = data['has_signal']
            
            if require_signal and not any(has_signal):
                continue
            
            try:
                encoded = self.encoder.encode(timestamp, energies, event_end=False)
                encoded_events.append(encoded)
            except Exception as e:
                logger.warning(f"编码时间点{timestamp}信号时出错，放弃: {e}")
                continue
        
        return encoded_events
    
    def generate_event(self, event_id: int) -> list:
        """
        根据当前模式生成一个事件
        
        返回:
            事件信号列表
        """
        if self.event_generation_mode == 'random':
            return self.generate_event_random(event_id)
        elif self.event_generation_mode == 'fixed':
            return self.generate_event_fixed(event_id)
        elif self.event_generation_mode == 'pulse':
            return self.generate_event_pulse(event_id)
        else:
            logger.warning(f"未知的事件生成模式: {self.event_generation_mode}，使用随机模式")
            return self.generate_event_random(event_id)
    
    def simulate_events(self, num_events: int = None) -> list:
        """
        模拟多个事件，根据配置的模式生成
        
        参数:
            num_events: 事件数量（覆盖配置）
            
        返回:
            所有事件的列表
        """
        if num_events is None:
            num_events = self.config['simulation']['num_events']
        
        all_events = []
        
        print(f"开始模拟事件...")
        print(f"  模式: {self.event_generation_mode}")
        print(f"  数量: {num_events}个事件")
        
        for i in range(num_events):
            if self.event_generation_mode == 'random':
                event = self.generate_event_random(i)
                valid_signals = sum(1 for sig in event if sig != 0)
                logger.info(f"已生成随机事件 {i + 1}/{num_events} - 有效信号: {valid_signals}")
            elif self.event_generation_mode == 'fixed':
                event = self.generate_event_fixed(i)
                logger.info(f"已生成固定事件 {i + 1}/{num_events} - 信号数: {len(event)}")
            elif self.event_generation_mode == 'pulse':
                event = self.generate_event_pulse(i)
                logger.info(f"已生成脉冲事件 {i + 1}/{num_events} - 信号数: {len(event)}")
            else:
                event = self.generate_event_random(i)
                valid_signals = sum(1 for sig in event if sig != 0)
                logger.info(f"已生成事件 {i + 1}/{num_events} - 有效信号: {valid_signals}")
            
            all_events.append(event)
        
        # 汇总统计信息
        total_signals = sum(len(event) for event in all_events)
        total_valid = sum(sum(1 for sig in event if sig != 0) for event in all_events)
        
        print(f"\n模拟完成!")
        print(f"  总事件数: {len(all_events)}")
        print(f"  总信号数: {total_signals}")
        print(f"  有效信号数: {total_valid}")
        print(f"  平均每事件信号数: {total_signals/len(all_events):.1f}")
        
        return all_events

class TimeSeriesGenerator:
    """时间序列生成器 - 根据工作模式和同步脉冲配置生成时间序列"""
    
    def __init__(self, work_mode: str, sync_pulses: list, sample_spaces: dict, 
                 samplers: dict, detectors: dict = None, energy_K: float = 1.0, energy_B: float = 0.0,
                 sync_pulse_signals: dict = None):
        """
        初始化时间序列生成器
        
        参数:
            work_mode: 工作模式 ("CO", "Sigma", "Combo")
            sync_pulses: 同步脉冲配置列表，每个元素为 {"count": int, "period": int}
            sample_spaces: 各探测器的样本空间
            samplers: 各探测器的采样器
            detectors: 各探测器的配置（包含每探测器信号数）
            energy_K: 能量转换系数K
            energy_B: 能量转换系数B
            sync_pulse_signals: 每个同步脉冲的探测器信号数配置
                格式: {"pulse1": {"detector1": {"min": 1, "max": 10}, ...}, ...}
        """
        self.work_mode = work_mode
        self.sync_pulses = sync_pulses
        self.sample_spaces = sample_spaces
        self.samplers = samplers
        self.detectors = detectors or {}
        self.energy_K = energy_K
        self.energy_B = energy_B
        self.sync_pulse_signals = sync_pulse_signals or {}
        self.encoder = BitFieldEncoder()
        
        logger.info(f"时间序列生成器初始化 - 工作模式: {work_mode}")
        for i, pulse in enumerate(sync_pulses):
            logger.info(f"  同步脉冲{i+1}: 个数={pulse['count']}, 周期={pulse['period']} (10ns)")
    
    def generate_time_series(self) -> dict:
        """
        生成时间序列
        
        返回:
            包含各探测器时间序列的字典
            {
                "detector1": [(timestamp, energy), ...],
                "detector2": [(timestamp, energy), ...],
                "detector3": [(timestamp, energy), ...],
                "total_duration": 总时长(10ns)
            }
        """
        time_series = {
            "detector1": [],
            "detector2": [],
            "detector3": [],
            "total_duration": 0
        }
        
        if self.work_mode == "CO":
            time_series = self._generate_co_mode()
        elif self.work_mode == "Sigma":
            time_series = self._generate_sigma_mode()
        elif self.work_mode == "Combo":
            time_series = self._generate_combo_mode()
        else:
            logger.warning(f"未知的工作模式: {self.work_mode}，使用CO模式")
            time_series = self._generate_co_mode()
        
        total_signals = sum(len(time_series[det]) for det in ["detector1", "detector2", "detector3"])
        logger.info(f"时间序列生成完成 - 总时长: {time_series['total_duration']} (10ns), 总信号数: {total_signals}")
        
        return time_series
    
    def _generate_co_mode(self) -> dict:
        """生成CO模式时间序列"""
        time_series = {
            "detector1": [],
            "detector2": [],
            "detector3": [],
            "total_duration": 0
        }
        
        pulse1_count = self.sync_pulses[0]["count"]
        pulse1_period = self.sync_pulses[0]["period"]
        pulse2_count = self.sync_pulses[1]["count"]
        pulse2_period = self.sync_pulses[1]["period"]
        pulse3_count = self.sync_pulses[2]["count"]
        pulse3_period = self.sync_pulses[2]["period"]
        pulse4_count = self.sync_pulses[3]["count"]
        pulse4_period = self.sync_pulses[3]["period"]
        
        # 计算总时长：串行计算所有脉冲序列的总时间
        total_duration = (
            pulse1_count * pulse1_period +
            pulse2_count * pulse2_period +
            pulse3_count * pulse3_period +
            pulse4_count * pulse4_period
        )
        time_series["total_duration"] = total_duration
        
        # 获取同步脉冲信号数配置
        def get_signal_count(pulse_key, det_name, default_min=1, default_max=10):
            """获取指定同步脉冲和探测器的信号数配置"""
            if pulse_key in self.sync_pulse_signals:
                if det_name in self.sync_pulse_signals[pulse_key]:
                    config = self.sync_pulse_signals[pulse_key][det_name]
                    min_val = config.get("min", default_min)
                    max_val = config.get("max", default_max)
                    return np.random.randint(min_val, max_val + 1)
            return np.random.randint(default_min, default_max + 1)
        
        # 对每个同步脉冲触发采样
        # 同步脉冲1
        for pulse_idx in range(pulse1_count):
            # 计算脉冲时间位置（10ns单位）
            pulse_start_time = pulse_idx * pulse1_period
            # 同步脉冲1的时间窗口：0-160微秒
            max_time_us = 160
            
            # 用于记录当前同步脉冲内每个探测器已使用的时间戳（单个探测器内去重）
            det_timestamps = {
                "detector1": set(),
                "detector2": set(),
                "detector3": set()
            }
            
            for det_name in ["detector1", "detector2", "detector3"]:
                if det_name in self.samplers:
                    # 在最小和最大信号数之间随机抽取（使用同步脉冲1的配置）
                    num_signals = get_signal_count("pulse1", det_name)
                    sampler = self.samplers[det_name]
                    sample_space = self.sample_spaces[det_name]
                    
                    if len(sample_space) > 0:
                        # 循环抽样，确保在同一个同步脉冲内，同一个探测器的时间戳不重复
                        signals_collected = 0
                        max_attempts = num_signals * 10  # 最多尝试次数
                        attempts = 0
                        
                        while signals_collected < num_signals and attempts < max_attempts:
                            # 从样本空间中抽取一个样本
                            sample = sampler.sample(1)[0]
                            energy_kev = sample[0]
                            sample_time_us = sample[1]
                            
                            # 检查时间戳是否在同步脉冲时间窗口内
                            if sample_time_us <= max_time_us:
                                # 转换为10ns单位，确保为整数
                                sample_time_10ns = int(sample_time_us * 100)  # us -> 10ns
                                timestamp_10ns = pulse_start_time + sample_time_10ns
                                
                                # 检查该时间戳是否已经被当前探测器在当前同步脉冲内使用（单个探测器内去重）
                                if timestamp_10ns not in det_timestamps[det_name]:
                                    # 能量转换并确保非负
                                    energy_mv = int(energy_kev * self.energy_K + self.energy_B)
                                    energy_mv = max(0, energy_mv)
                                    time_series[det_name].append((timestamp_10ns, energy_mv))
                                    det_timestamps[det_name].add(timestamp_10ns)
                                    signals_collected += 1
                                else:
                                    logger.debug(f"重复时间戳: 探测器={det_name}, 时间戳={timestamp_10ns}, 能量={energy_kev}keV")
                            
                            attempts += 1

        # 同步脉冲2
        for pulse_idx in range(pulse2_count):
            # 计算脉冲时间位置（10ns单位）
            # 同步脉冲2的起始时间是同步脉冲1的结束时间
            pulse_start_time = pulse1_count * pulse1_period + pulse_idx * pulse2_period
            # 同步脉冲2的时间窗口：0-1000微秒
            max_time_us = 1000
            
            # 用于记录当前同步脉冲内每个探测器已使用的时间戳（单个探测器内去重）
            det_timestamps = {
                "detector1": set(),
                "detector2": set(),
                "detector3": set()
            }
            
            for det_name in ["detector1", "detector2", "detector3"]:
                if det_name in self.samplers:
                    # 在最小和最大信号数之间随机抽取（使用同步脉冲2的配置）
                    num_signals = get_signal_count("pulse2", det_name)
                    sampler = self.samplers[det_name]
                    sample_space = self.sample_spaces[det_name]
                    
                    if len(sample_space) > 0:
                        # 循环抽样，确保在同一个同步脉冲内，同一个探测器的时间戳不重复
                        signals_collected = 0
                        max_attempts = num_signals * 10  # 最多尝试次数
                        attempts = 0
                        
                        while signals_collected < num_signals and attempts < max_attempts:
                            # 从样本空间中抽取一个样本
                            sample = sampler.sample(1)[0]
                            energy_kev = sample[0]
                            sample_time_us = sample[1]
                            
                            # 检查时间戳是否在同步脉冲时间窗口内
                            if sample_time_us <= max_time_us:
                                # 转换为10ns单位，确保为整数
                                sample_time_10ns = int(sample_time_us * 100)  # us -> 10ns
                                timestamp_10ns = pulse_start_time + sample_time_10ns
                                
                                # 检查该时间戳是否已经被当前探测器在当前同步脉冲内使用（单个探测器内去重）
                                if timestamp_10ns not in det_timestamps[det_name]:
                                    # 能量转换并确保非负
                                    energy_mv = int(energy_kev * self.energy_K + self.energy_B)
                                    energy_mv = max(0, energy_mv)
                                    time_series[det_name].append((timestamp_10ns, energy_mv))
                                    det_timestamps[det_name].add(timestamp_10ns)
                                    signals_collected += 1
                            
                            attempts += 1

        # 同步脉冲3
        for pulse_idx in range(pulse3_count):
            # 计算脉冲时间位置（10ns单位）
            # 同步脉冲3的起始时间是同步脉冲2的结束时间
            pulse_start_time = pulse1_count * pulse1_period + pulse2_count * pulse2_period + pulse_idx * pulse3_period
            # 同步脉冲3的时间窗口：0-4000微秒
            max_time_us = 4000
            
            # 用于记录当前同步脉冲内每个探测器已使用的时间戳（单个探测器内去重）
            det_timestamps = {
                "detector1": set(),
                "detector2": set(),
                "detector3": set()
            }
            
            for det_name in ["detector1", "detector2", "detector3"]:
                if det_name in self.samplers:
                    # 在最小和最大信号数之间随机抽取（使用同步脉冲3的配置）
                    num_signals = get_signal_count("pulse3", det_name)
                    sampler = self.samplers[det_name]
                    sample_space = self.sample_spaces[det_name]
                    
                    if len(sample_space) > 0:
                        # 循环抽样，确保在同一个同步脉冲内，同一个探测器的时间戳不重复
                        signals_collected = 0
                        max_attempts = num_signals * 10  # 最多尝试次数
                        attempts = 0
                        
                        while signals_collected < num_signals and attempts < max_attempts:
                            # 从样本空间中抽取一个样本
                            sample = sampler.sample(1)[0]
                            energy_kev = sample[0]
                            sample_time_us = sample[1]
                            
                            # 检查时间戳是否在同步脉冲时间窗口内
                            if sample_time_us <= max_time_us:
                                # 转换为10ns单位，确保为整数
                                sample_time_10ns = int(sample_time_us * 100)  # us -> 10ns
                                timestamp_10ns = pulse_start_time + sample_time_10ns
                                
                                # 检查该时间戳是否已经被当前探测器在当前同步脉冲内使用（单个探测器内去重）
                                if timestamp_10ns not in det_timestamps[det_name]:
                                    # 能量转换并确保非负
                                    energy_mv = int(energy_kev * self.energy_K + self.energy_B)
                                    energy_mv = max(0, energy_mv)
                                    time_series[det_name].append((timestamp_10ns, energy_mv))
                                    det_timestamps[det_name].add(timestamp_10ns)
                                    signals_collected += 1
                            
                            attempts += 1
        
        # 对每个探测器的信号按时间戳排序
        for det_name in ["detector1", "detector2", "detector3"]:
            time_series[det_name].sort(key=lambda x: x[0])
        
        return time_series
    
    def _generate_sigma_mode(self) -> dict:
        """生成Sigma模式时间序列"""
        time_series = {
            "detector1": [],
            "detector2": [],
            "detector3": [],
            "total_duration": 0
        }
        
        pulse1_count = self.sync_pulses[0]["count"]
        pulse1_period = self.sync_pulses[0]["period"]
        
        total_duration = pulse1_count * pulse1_period
        time_series["total_duration"] = total_duration
        
        # 对每个同步脉冲触发采样
        for pulse_idx in range(pulse1_count):
            # 计算脉冲时间位置（10ns单位）
            pulse_start_time = pulse_idx * pulse1_period
            
            # 用于记录当前同步脉冲内每个探测器已使用的时间戳（单个探测器内去重）
            det_timestamps = {
                "detector1": set(),
                "detector2": set(),
                "detector3": set()
            }
            
            for det_name in ["detector1", "detector2", "detector3"]:
                if det_name in self.samplers:
                    sampler = self.samplers[det_name]
                    sample_space = self.sample_spaces[det_name]
                    
                    if len(sample_space) > 0:
                        # 循环抽样，确保在同一个同步脉冲内，同一个探测器的时间戳不重复
                        num_samples = np.random.randint(1, 4)
                        signals_collected = 0
                        max_attempts = num_samples * 10  # 最多尝试次数
                        attempts = 0
                        
                        while signals_collected < num_samples and attempts < max_attempts:
                            # 从样本空间中抽取一个样本
                            sample = sampler.sample(1)[0]
                            energy_kev = sample[0]
                            sample_time_us = sample[1]
                            
                            # 计算最终时间戳：脉冲时间 + 样本时间（使用10ns单位整数运算避免浮点精度问题）
                            sample_time_10ns = int(sample_time_us * 100)  # us -> 10ns
                            timestamp_10ns = pulse_start_time + sample_time_10ns
                            
                            # 检查该时间戳是否已经被当前探测器在当前同步脉冲内使用（单个探测器内去重）
                            if timestamp_10ns not in det_timestamps[det_name]:
                                # 能量转换并确保非负
                                energy_mv = int(energy_kev * self.energy_K + self.energy_B)
                                energy_mv = max(0, energy_mv)
                                time_series[det_name].append((timestamp_10ns, energy_mv))
                                det_timestamps[det_name].add(timestamp_10ns)
                                signals_collected += 1
                            else:
                                logger.debug(f"重复时间戳: 探测器={det_name}, 脉冲={pulse_idx}, 时间戳={timestamp_10ns}, 样本时间={sample_time_us}us")
                            
                            attempts += 1
        
        return time_series
    
    def _generate_combo_mode(self) -> dict:
        """生成Combo模式时间序列"""
        time_series = {
            "detector1": [],
            "detector2": [],
            "detector3": [],
            "total_duration": 0
        }
        
        pulse1_count = self.sync_pulses[0]["count"]
        pulse1_period = self.sync_pulses[0]["period"]
        pulse2_count = self.sync_pulses[1]["count"]
        pulse2_period = self.sync_pulses[1]["period"]
        pulse3_count = self.sync_pulses[2]["count"]
        pulse3_period = self.sync_pulses[2]["period"]
        
        # 计算总时长：取最长的脉冲序列结束时间
        total_duration = max(
            pulse1_count * pulse1_period,
            pulse2_count * pulse2_period,
            pulse3_count * pulse3_period
        )
        time_series["total_duration"] = total_duration
        
        # 对每个同步脉冲触发采样
        # 同步脉冲1
        for pulse_idx in range(pulse1_count):
            # 计算脉冲时间位置（10ns单位）
            pulse_start_time = pulse_idx * pulse1_period
            
            # 用于记录当前同步脉冲内每个探测器已使用的时间戳（单个探测器内去重）
            det_timestamps = {
                "detector1": set(),
                "detector2": set(),
                "detector3": set()
            }
            
            for det_name in ["detector1", "detector2", "detector3"]:
                if det_name in self.samplers:
                    sampler = self.samplers[det_name]
                    sample_space = self.sample_spaces[det_name]
                    
                    if len(sample_space) > 0:
                        # 循环抽样，确保在同一个同步脉冲内，同一个探测器的时间戳不重复
                        num_samples = np.random.randint(1, 4)
                        signals_collected = 0
                        max_attempts = num_samples * 10  # 最多尝试次数
                        attempts = 0
                        
                        while signals_collected < num_samples and attempts < max_attempts:
                            # 从样本空间中抽取一个样本
                            sample = sampler.sample(1)[0]
                            energy_kev = sample[0]
                            sample_time_us = sample[1]
                            
                            # 计算最终时间戳：脉冲时间 + 样本时间（使用10ns单位整数运算避免浮点精度问题）
                            sample_time_10ns = int(sample_time_us * 100)  # us -> 10ns
                            timestamp_10ns = pulse_start_time + sample_time_10ns
                            
                            # 检查该时间戳是否已经被当前探测器在当前同步脉冲内使用（单个探测器内去重）
                            if timestamp_10ns not in det_timestamps[det_name]:
                                # 能量转换并确保非负
                                energy_mv = int(energy_kev * self.energy_K + self.energy_B)
                                energy_mv = max(0, energy_mv)
                                time_series[det_name].append((timestamp_10ns, energy_mv))
                                det_timestamps[det_name].add(timestamp_10ns)
                                signals_collected += 1
                            
                            attempts += 1

        # 同步脉冲3
        for pulse_idx in range(pulse3_count):
            # 计算脉冲时间位置（10ns单位）
            pulse_start_time = pulse_idx * pulse3_period
            # 转换为微秒单位
            pulse_start_time_us = pulse_start_time / 100  # 10ns = 0.01us
            
            # 用于记录当前同步脉冲内每个探测器已使用的时间戳（单个探测器内去重）
            det_timestamps = {
                "detector1": set(),
                "detector2": set(),
                "detector3": set()
            }
            
            for det_name in ["detector1", "detector2", "detector3"]:
                if det_name in self.samplers:
                    sampler = self.samplers[det_name]
                    sample_space = self.sample_spaces[det_name]
                    
                    if len(sample_space) > 0:
                        # 循环抽样，确保在同一个同步脉冲内，同一个探测器的时间戳不重复
                        num_samples = np.random.randint(1, 4)
                        signals_collected = 0
                        max_attempts = num_samples * 10  # 最多尝试次数
                        attempts = 0
                        
                        while signals_collected < num_samples and attempts < max_attempts:
                            # 从样本空间中抽取一个样本
                            sample = sampler.sample(1)[0]
                            energy_kev = sample[0]
                            sample_time_us = sample[1]
                            
                            # 计算最终时间戳：脉冲时间 + 样本时间（使用10ns单位整数运算避免浮点精度问题）
                            sample_time_10ns = int(sample_time_us * 100)  # us -> 10ns
                            timestamp_10ns = pulse_start_time + sample_time_10ns
                            
                            # 检查该时间戳是否已经被当前探测器在当前同步脉冲内使用（单个探测器内去重）
                            if timestamp_10ns not in det_timestamps[det_name]:
                                # 能量转换并确保非负
                                energy_mv = int(energy_kev * self.energy_K + self.energy_B)
                                energy_mv = max(0, energy_mv)
                                time_series[det_name].append((timestamp_10ns, energy_mv))
                                det_timestamps[det_name].add(timestamp_10ns)
                                signals_collected += 1
                            
                            attempts += 1
        
        return time_series
    
    def encode_time_series(self, time_series: dict) -> list:
        """
        将时间序列编码为64位整数列表
        
        参数:
            time_series: 时间序列字典
            
        返回:
            编码后的64位整数列表
        """
        # 计算同步脉冲时间点
        sync_pulse_times = []
        current_time = 0
        for pulse_config in self.sync_pulses:
            count = pulse_config["count"]
            period = pulse_config["period"]
            for i in range(count):
                sync_pulse_times.append(current_time)
                current_time += period
        
        logger.info(f"同步脉冲时间点: {len(sync_pulse_times)}个")
        
        # 为每个同步脉冲创建一个事件
        event_signals = []
        
        # 标记已分配的信号
        assigned_timestamps = set()
        
        for pulse_idx, pulse_time in enumerate(sync_pulse_times):
            # 找到该脉冲时间窗口内的信号
            # 时间范围：从当前脉冲时间到下一个脉冲时间
            next_pulse_time = sync_pulse_times[pulse_idx + 1] if pulse_idx + 1 < len(sync_pulse_times) else None
            
            # 按相对时间戳分组信号（合并相同时间戳的信号）
            relative_time_signal_map = {}
            
            # 收集当前脉冲时间窗口内的信号
            for det_idx, det_name in enumerate(['detector1', 'detector2', 'detector3']):
                signals = time_series.get(det_name, [])
                for signal in signals:
                    if len(signal) == 2:
                        timestamp = signal[0]
                        energy = signal[1]
                        
                        # 检查信号是否在当前脉冲时间窗口内且未被分配
                        if timestamp >= pulse_time and timestamp not in assigned_timestamps:
                            if next_pulse_time is None or timestamp < next_pulse_time:
                                # 计算相对时间戳（相对于同步脉冲时间）
                                relative_timestamp = timestamp - pulse_time
                                # 转换为微秒单位（编码器期望的单位）
                                relative_timestamp_us = relative_timestamp // 100  # 10ns -> us，使用整数除法避免浮点精度问题
                                
                                # 按相对时间戳分组，确保同一事件内同一探测器的时间戳不重复
                                if relative_timestamp_us not in relative_time_signal_map:
                                    relative_time_signal_map[relative_timestamp_us] = [0, 0, 0]
                                
                                # 如果该探测器在这个相对时间戳上已经有信号，使用第一个信号（去重）
                                if relative_time_signal_map[relative_timestamp_us][det_idx] == 0:
                                    relative_time_signal_map[relative_timestamp_us][det_idx] = energy
                                else:
                                    logger.debug(f"重复相对时间戳: 事件={pulse_idx}, 时间戳={relative_timestamp_us}us, 探测器={det_name}, 旧能量={relative_time_signal_map[relative_timestamp_us][det_idx]}, 新能量={energy}")
            
            # 统计合并后的信号
            merged_count = 0
            for timestamp, energies in relative_time_signal_map.items():
                active_dets = sum(1 for e in energies if e > 0)
                if active_dets > 1:
                    merged_count += 1
                    logger.debug(f"事件 {pulse_idx} - 时间戳 {timestamp}us 合并了 {active_dets} 个探测器的信号: {energies}")
            
            # 按相对时间戳排序
            sorted_relative_timestamps = sorted(relative_time_signal_map.keys())
            
            pulse_signals = []
            
            for relative_timestamp_us in sorted_relative_timestamps:
                energies = relative_time_signal_map[relative_timestamp_us]
                try:
                    encoded = self.encoder.encode(relative_timestamp_us, energies, event_end=False)
                    pulse_signals.append(encoded)
                except Exception as e:
                    logger.warning(f"编码信号时出错: {e}")
                    default_signal = self.encoder.encode(relative_timestamp_us, [0, 0, 0], event_end=False)
                    pulse_signals.append(default_signal)
            
            # 标记当前脉冲时间窗口内的信号为已分配
            for det_idx, det_name in enumerate(['detector1', 'detector2', 'detector3']):
                signals = time_series.get(det_name, [])
                for signal in signals:
                    if len(signal) == 2:
                        timestamp = signal[0]
                        if timestamp >= pulse_time and timestamp not in assigned_timestamps:
                            if next_pulse_time is None or timestamp < next_pulse_time:
                                assigned_timestamps.add(timestamp)
            
            # 如果有信号，设置最后一个信号为事件结束
            if pulse_signals:
                # 设置最后一个信号的事件结束标志
                original_val = pulse_signals[-1]
                pulse_signals[-1] = self.encoder.set_event_end_flag(pulse_signals[-1])
                logger.debug(f"事件 {pulse_idx}: 设置event_end, 原始值={hex(original_val)}, 新值={hex(pulse_signals[-1])}")
                event_signals.extend(pulse_signals)
        
        logger.info(f"时间序列编码完成 - 编码信号数: {len(event_signals)}, 事件数: {len(sync_pulse_times)}")
        return event_signals
    
    def _merge_and_encode_signals(self, detector_signals: dict, require_signal: bool = True) -> list:
        """
        合并探测器信号并编码为64位整数
        
        参数:
            detector_signals: 各探测器的信号数组
            require_signal: 是否只输出有信号的探测器
            
        返回:
            编码后的64位整数列表
        """
        time_signal_map = {}
        
        for det_idx, det_name in enumerate(['detector1', 'detector2', 'detector3']):
            signals = detector_signals.get(det_name, [])
            
            for signal in signals:
                if len(signal) == 2:
                    # 注意：这里的信号来自sampler.sample()，时间戳是微秒单位
                    energy_kev = signal[0]
                    timestamp_us = signal[1]
                    
                    try:
                        # 能量转换: mV = keV * K + B，结果取整
                        energy_mv = int(round(energy_kev * self.energy_K + self.energy_B))
                        
                        # 确保能量非负
                        if energy_mv < 0:
                            energy_mv = 0
                        
                        # 检查溢出
                        if energy_mv > ((1 << 14) - 1):
                            logger.warning(f"能量溢出，放弃信号: {energy_mv}mV (原始: {energy_kev}keV)")
                            continue
                        
                        if timestamp_us > ((1 << 18) - 1):
                            logger.warning(f"时间戳溢出，放弃信号: {timestamp_us}us")
                            continue
                        
                        # 使用微秒单位的时间戳作为键
                        timestamp_int = int(round(timestamp_us))
                        if timestamp_int not in time_signal_map:
                            time_signal_map[timestamp_int] = [0, 0, 0]
                        
                        # 只保留第一个信号（去重）
                        if time_signal_map[timestamp_int][det_idx] == 0:
                            time_signal_map[timestamp_int][det_idx] = energy_mv
                        else:
                            logger.debug(f"重复时间戳: 时间戳={timestamp_int}us, 探测器={det_name}, 旧能量={time_signal_map[timestamp_int][det_idx]}, 新能量={energy_mv}")
                    except Exception as e:
                        logger.warning(f"编码信号时出错，放弃: {e}")
                        continue
        
        encoded_signals = []
        sorted_timestamps = sorted(time_signal_map.keys())
        
        for timestamp in sorted_timestamps:
            energies = time_signal_map[timestamp]
            
            if require_signal:
                if all(e == 0 for e in energies):
                    continue
            
            try:
                # 直接使用微秒单位的时间戳（编码器期望的单位）
                encoded = self.encoder.encode(timestamp, energies, event_end=False)
                encoded_signals.append(encoded)
            except Exception as e:
                logger.warning(f"编码时间序列信号时出错: {e}")
                default_signal = self.encoder.encode(timestamp, [0, 0, 0], event_end=False)
                encoded_signals.append(default_signal)
        
        return encoded_signals