#!/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