1411 lines
70 KiB
Python
1411 lines
70 KiB
Python
#!/usr/bin/env python3
|
||
"""
|
||
主配置选项卡
|
||
"""
|
||
|
||
import customtkinter as ctk
|
||
from tkinter import filedialog
|
||
|
||
class MainConfigTab(ctk.CTkFrame):
|
||
def __init__(self, parent):
|
||
super().__init__(parent)
|
||
|
||
# 配置网格布局
|
||
self.grid_columnconfigure(0, weight=1)
|
||
self.grid_rowconfigure(0, weight=0)
|
||
self.grid_rowconfigure(1, weight=0)
|
||
self.grid_rowconfigure(2, weight=0)
|
||
|
||
# 基本设置框架
|
||
self.basic_frame = ctk.CTkFrame(self)
|
||
self.basic_frame.grid(row=0, column=0, sticky="nsew", pady=(0, 10))
|
||
self.basic_frame.grid_columnconfigure(0, weight=1)
|
||
|
||
# 标题
|
||
ctk.CTkLabel(
|
||
self.basic_frame,
|
||
text="基本设置",
|
||
font=ctk.CTkFont(size=14, weight="bold")
|
||
).grid(row=0, column=0, sticky="w", padx=10, pady=10)
|
||
|
||
# 事件数量
|
||
self.num_events_var = ctk.StringVar(value="8")
|
||
self.num_events_var.trace_add('write', self._on_config_change)
|
||
ctk.CTkLabel(self.basic_frame, text="序列数量:").grid(row=1, column=0, sticky="w", padx=20, pady=5)
|
||
self.num_events_entry = ctk.CTkEntry(
|
||
self.basic_frame,
|
||
textvariable=self.num_events_var,
|
||
width=100
|
||
)
|
||
self.num_events_entry.grid(row=1, column=0, sticky="w", padx=100, pady=5)
|
||
# 添加输入验证
|
||
self.num_events_entry.configure(validate="key", validatecommand=(self.num_events_entry.register(self._validate_integer), '%P'))
|
||
|
||
# 事件生成模式
|
||
ctk.CTkLabel(self.basic_frame, text="事件生成模式:").grid(row=2, column=0, sticky="w", padx=20, pady=5)
|
||
self.generation_mode_var = ctk.StringVar(value="random")
|
||
self.generation_mode_var.trace_add('write', self._on_config_change)
|
||
mode_frame = ctk.CTkFrame(self.basic_frame)
|
||
mode_frame.grid(row=2, column=0, sticky="w", padx=100, pady=5)
|
||
|
||
ctk.CTkRadioButton(
|
||
mode_frame,
|
||
text="随机模式",
|
||
variable=self.generation_mode_var,
|
||
value="random"
|
||
).pack(side="left", padx=10)
|
||
ctk.CTkRadioButton(
|
||
mode_frame,
|
||
text="固定模式",
|
||
variable=self.generation_mode_var,
|
||
value="fixed"
|
||
).pack(side="left", padx=10)
|
||
ctk.CTkRadioButton(
|
||
mode_frame,
|
||
text="脉冲模式",
|
||
variable=self.generation_mode_var,
|
||
value="pulse"
|
||
).pack(side="left", padx=10)
|
||
|
||
# 打包模式
|
||
ctk.CTkLabel(self.basic_frame, text="打包模式:").grid(row=3, column=0, sticky="w", padx=20, pady=5)
|
||
self.packing_mode_var = ctk.StringVar(value="separate")
|
||
self.packing_mode_var.trace_add('write', self._on_config_change)
|
||
pack_frame = ctk.CTkFrame(self.basic_frame)
|
||
pack_frame.grid(row=3, column=0, sticky="w", padx=100, pady=5)
|
||
|
||
ctk.CTkRadioButton(
|
||
pack_frame,
|
||
text="单独打包(每事件一包)",
|
||
variable=self.packing_mode_var,
|
||
value="separate"
|
||
).pack(side="left", padx=10)
|
||
ctk.CTkRadioButton(
|
||
pack_frame,
|
||
text="整体打包(拼接分包)",
|
||
variable=self.packing_mode_var,
|
||
value="combined"
|
||
).pack(side="left", padx=10)
|
||
|
||
# 输出格式
|
||
ctk.CTkLabel(self.basic_frame, text="输出格式:").grid(row=4, column=0, sticky="w", padx=20, pady=5)
|
||
self.output_format_var = ctk.StringVar(value="all")
|
||
format_frame = ctk.CTkFrame(self.basic_frame)
|
||
format_frame.grid(row=4, column=0, sticky="w", padx=100, pady=5)
|
||
|
||
self.bin_var = ctk.BooleanVar(value=True)
|
||
self.txt_var = ctk.BooleanVar(value=True)
|
||
self.debug_var = ctk.BooleanVar(value=False)
|
||
|
||
ctk.CTkCheckBox(
|
||
format_frame,
|
||
text="二进制(.bin)",
|
||
variable=self.bin_var
|
||
).pack(side="left", padx=10)
|
||
ctk.CTkCheckBox(
|
||
format_frame,
|
||
text="文本",
|
||
variable=self.txt_var
|
||
).pack(side="left", padx=10)
|
||
ctk.CTkCheckBox(
|
||
format_frame,
|
||
text="调试文本",
|
||
variable=self.debug_var
|
||
).pack(side="left", padx=10)
|
||
|
||
# 输出文件名
|
||
ctk.CTkLabel(self.basic_frame, text="输出文件名:").grid(row=5, column=0, sticky="w", padx=20, pady=5)
|
||
self.output_file_var = ctk.StringVar(value="detector_random_separate_8events")
|
||
self._user_modified = False # 标记用户是否手动修改过文件名
|
||
file_frame = ctk.CTkFrame(self.basic_frame)
|
||
file_frame.grid(row=5, column=0, sticky="w", padx=100, pady=5)
|
||
file_frame.grid_columnconfigure(0, weight=1)
|
||
|
||
self.output_entry = ctk.CTkEntry(
|
||
file_frame,
|
||
textvariable=self.output_file_var,
|
||
width=300
|
||
)
|
||
self.output_entry.grid(row=0, column=0, padx=5, pady=5, sticky="w")
|
||
self.output_file_var.trace_add('write', self._on_output_file_changed)
|
||
ctk.CTkButton(
|
||
file_frame,
|
||
text="浏览...",
|
||
width=80,
|
||
command=self.browse_output_file
|
||
).grid(row=0, column=1, padx=5, pady=5, sticky="w")
|
||
|
||
# 能量转换参数
|
||
energy_conversion_frame = ctk.CTkFrame(self.basic_frame)
|
||
energy_conversion_frame.grid(row=6, column=0, sticky="w", padx=20, pady=5)
|
||
|
||
ctk.CTkLabel(energy_conversion_frame, text="能量转换: mV = keV × K + B").pack(side="left", padx=10, pady=5)
|
||
|
||
ctk.CTkLabel(energy_conversion_frame, text="K:").pack(side="left", padx=10, pady=5)
|
||
self.energy_K_var = ctk.StringVar(value="1.0")
|
||
self.energy_K_var.trace_add('write', self._on_config_change)
|
||
energy_K_entry = ctk.CTkEntry(
|
||
energy_conversion_frame,
|
||
textvariable=self.energy_K_var,
|
||
width=80
|
||
)
|
||
energy_K_entry.pack(side="left", padx=5, pady=5)
|
||
energy_K_entry.configure(validate="key", validatecommand=(energy_K_entry.register(self._validate_float), '%P'))
|
||
|
||
ctk.CTkLabel(energy_conversion_frame, text="B:").pack(side="left", padx=10, pady=5)
|
||
self.energy_B_var = ctk.StringVar(value="0.0")
|
||
self.energy_B_var.trace_add('write', self._on_config_change)
|
||
energy_B_entry = ctk.CTkEntry(
|
||
energy_conversion_frame,
|
||
textvariable=self.energy_B_var,
|
||
width=80
|
||
)
|
||
energy_B_entry.pack(side="left", padx=5, pady=5)
|
||
energy_B_entry.configure(validate="key", validatecommand=(energy_B_entry.register(self._validate_float), '%P'))
|
||
|
||
|
||
|
||
# 工作模式和同步脉冲配置框架
|
||
self.timing_frame = ctk.CTkFrame(self)
|
||
self.timing_frame.grid(row=1, column=0, sticky="nsew", pady=(0, 10))
|
||
self.timing_frame.grid_columnconfigure(0, weight=1)
|
||
|
||
# 标题
|
||
ctk.CTkLabel(
|
||
self.timing_frame,
|
||
text="工作模式与同步脉冲配置",
|
||
font=ctk.CTkFont(size=14, weight="bold")
|
||
).grid(row=0, column=0, sticky="w", padx=10, pady=10)
|
||
|
||
# 工作模式选择
|
||
mode_select_frame = ctk.CTkFrame(self.timing_frame)
|
||
mode_select_frame.grid(row=1, column=0, sticky="nsew", padx=20, pady=5)
|
||
|
||
ctk.CTkLabel(mode_select_frame, text="工作模式:").pack(side="left", padx=10, pady=5)
|
||
self.work_mode_var = ctk.StringVar(value="CO")
|
||
ctk.CTkOptionMenu(
|
||
mode_select_frame,
|
||
values=["CO", "Sigma", "Combo"],
|
||
variable=self.work_mode_var,
|
||
width=120
|
||
).pack(side="left", padx=10, pady=5)
|
||
|
||
# 绑定工作模式变化，更新同步脉冲默认值
|
||
self.work_mode_var.trace_add('write', self._on_work_mode_change)
|
||
|
||
# 信号类型选择
|
||
ctk.CTkLabel(mode_select_frame, text="信号类型:").pack(side="left", padx=(30, 10), pady=5)
|
||
self.signal_type_var = ctk.StringVar(value="电压信号(0x70)")
|
||
ctk.CTkOptionMenu(
|
||
mode_select_frame,
|
||
values=["电压信号(0x70)", "电流信号(0x07)"],
|
||
variable=self.signal_type_var,
|
||
width=150
|
||
).pack(side="left", padx=10, pady=5)
|
||
|
||
# 同步脉冲配置框架
|
||
sync_pulse_frame = ctk.CTkFrame(self.timing_frame)
|
||
sync_pulse_frame.grid(row=2, column=0, sticky="nsew", padx=20, pady=10)
|
||
sync_pulse_frame.grid_columnconfigure(0, weight=1)
|
||
sync_pulse_frame.grid_columnconfigure(1, weight=1)
|
||
sync_pulse_frame.grid_columnconfigure(2, weight=1)
|
||
sync_pulse_frame.grid_columnconfigure(3, weight=1)
|
||
|
||
# 同步脉冲1
|
||
ctk.CTkLabel(sync_pulse_frame, text="同步脉冲1 个数:").grid(row=0, column=0, sticky="w", padx=10, pady=5)
|
||
self.sync_pulse1_count_var = ctk.StringVar(value="475")
|
||
pulse1_count_entry = ctk.CTkEntry(sync_pulse_frame, textvariable=self.sync_pulse1_count_var, width=80)
|
||
pulse1_count_entry.grid(row=0, column=1, sticky="w", padx=5, pady=5)
|
||
pulse1_count_entry.configure(validate="key", validatecommand=(pulse1_count_entry.register(self._validate_integer), '%P'))
|
||
|
||
ctk.CTkLabel(sync_pulse_frame, text="周期(10ns):").grid(row=0, column=2, sticky="w", padx=10, pady=5)
|
||
self.sync_pulse1_period_var = ctk.StringVar(value="16000")
|
||
pulse1_period_entry = ctk.CTkEntry(sync_pulse_frame, textvariable=self.sync_pulse1_period_var, width=80)
|
||
pulse1_period_entry.grid(row=0, column=3, sticky="w", padx=5, pady=5)
|
||
pulse1_period_entry.configure(validate="key", validatecommand=(pulse1_period_entry.register(self._validate_integer), '%P'))
|
||
|
||
# 同步脉冲1探测器信号数配置
|
||
pulse1_signal_frame = ctk.CTkFrame(sync_pulse_frame)
|
||
pulse1_signal_frame.grid(row=1, column=0, columnspan=4, sticky="w", padx=20, pady=5)
|
||
|
||
ctk.CTkLabel(pulse1_signal_frame, text=" 探测器1").pack(side="left", padx=5, pady=5)
|
||
self.pulse1_det1_min_var = ctk.StringVar(value="1")
|
||
ctk.CTkEntry(pulse1_signal_frame, textvariable=self.pulse1_det1_min_var, width=40).pack(side="left", padx=2, pady=5)
|
||
ctk.CTkLabel(pulse1_signal_frame, text="-").pack(side="left", padx=2, pady=5)
|
||
self.pulse1_det1_max_var = ctk.StringVar(value="10")
|
||
ctk.CTkEntry(pulse1_signal_frame, textvariable=self.pulse1_det1_max_var, width=40).pack(side="left", padx=2, pady=5)
|
||
|
||
ctk.CTkLabel(pulse1_signal_frame, text="探测器2").pack(side="left", padx=(15, 5), pady=5)
|
||
self.pulse1_det2_min_var = ctk.StringVar(value="1")
|
||
ctk.CTkEntry(pulse1_signal_frame, textvariable=self.pulse1_det2_min_var, width=40).pack(side="left", padx=2, pady=5)
|
||
ctk.CTkLabel(pulse1_signal_frame, text="-").pack(side="left", padx=2, pady=5)
|
||
self.pulse1_det2_max_var = ctk.StringVar(value="10")
|
||
ctk.CTkEntry(pulse1_signal_frame, textvariable=self.pulse1_det2_max_var, width=40).pack(side="left", padx=2, pady=5)
|
||
|
||
ctk.CTkLabel(pulse1_signal_frame, text="探测器3").pack(side="left", padx=(15, 5), pady=5)
|
||
self.pulse1_det3_min_var = ctk.StringVar(value="1")
|
||
ctk.CTkEntry(pulse1_signal_frame, textvariable=self.pulse1_det3_min_var, width=40).pack(side="left", padx=2, pady=5)
|
||
ctk.CTkLabel(pulse1_signal_frame, text="-").pack(side="left", padx=2, pady=5)
|
||
self.pulse1_det3_max_var = ctk.StringVar(value="10")
|
||
ctk.CTkEntry(pulse1_signal_frame, textvariable=self.pulse1_det3_max_var, width=40).pack(side="left", padx=2, pady=5)
|
||
|
||
# 同步脉冲2
|
||
ctk.CTkLabel(sync_pulse_frame, text="同步脉冲2 个数:").grid(row=2, column=0, sticky="w", padx=10, pady=5)
|
||
self.sync_pulse2_count_var = ctk.StringVar(value="20")
|
||
pulse2_count_entry = ctk.CTkEntry(sync_pulse_frame, textvariable=self.sync_pulse2_count_var, width=80)
|
||
pulse2_count_entry.grid(row=2, column=1, sticky="w", padx=5, pady=5)
|
||
pulse2_count_entry.configure(validate="key", validatecommand=(pulse2_count_entry.register(self._validate_integer), '%P'))
|
||
|
||
ctk.CTkLabel(sync_pulse_frame, text="周期(10ns):").grid(row=2, column=2, sticky="w", padx=10, pady=5)
|
||
self.sync_pulse2_period_var = ctk.StringVar(value="100000")
|
||
pulse2_period_entry = ctk.CTkEntry(sync_pulse_frame, textvariable=self.sync_pulse2_period_var, width=80)
|
||
pulse2_period_entry.grid(row=2, column=3, sticky="w", padx=5, pady=5)
|
||
pulse2_period_entry.configure(validate="key", validatecommand=(pulse2_period_entry.register(self._validate_integer), '%P'))
|
||
|
||
# 同步脉冲2探测器信号数配置
|
||
pulse2_signal_frame = ctk.CTkFrame(sync_pulse_frame)
|
||
pulse2_signal_frame.grid(row=3, column=0, columnspan=4, sticky="w", padx=20, pady=5)
|
||
|
||
ctk.CTkLabel(pulse2_signal_frame, text=" 探测器1").pack(side="left", padx=5, pady=5)
|
||
self.pulse2_det1_min_var = ctk.StringVar(value="1")
|
||
ctk.CTkEntry(pulse2_signal_frame, textvariable=self.pulse2_det1_min_var, width=40).pack(side="left", padx=2, pady=5)
|
||
ctk.CTkLabel(pulse2_signal_frame, text="-").pack(side="left", padx=2, pady=5)
|
||
self.pulse2_det1_max_var = ctk.StringVar(value="10")
|
||
ctk.CTkEntry(pulse2_signal_frame, textvariable=self.pulse2_det1_max_var, width=40).pack(side="left", padx=2, pady=5)
|
||
|
||
ctk.CTkLabel(pulse2_signal_frame, text="探测器2").pack(side="left", padx=(15, 5), pady=5)
|
||
self.pulse2_det2_min_var = ctk.StringVar(value="1")
|
||
ctk.CTkEntry(pulse2_signal_frame, textvariable=self.pulse2_det2_min_var, width=40).pack(side="left", padx=2, pady=5)
|
||
ctk.CTkLabel(pulse2_signal_frame, text="-").pack(side="left", padx=2, pady=5)
|
||
self.pulse2_det2_max_var = ctk.StringVar(value="10")
|
||
ctk.CTkEntry(pulse2_signal_frame, textvariable=self.pulse2_det2_max_var, width=40).pack(side="left", padx=2, pady=5)
|
||
|
||
ctk.CTkLabel(pulse2_signal_frame, text="探测器3").pack(side="left", padx=(15, 5), pady=5)
|
||
self.pulse2_det3_min_var = ctk.StringVar(value="1")
|
||
ctk.CTkEntry(pulse2_signal_frame, textvariable=self.pulse2_det3_min_var, width=40).pack(side="left", padx=2, pady=5)
|
||
ctk.CTkLabel(pulse2_signal_frame, text="-").pack(side="left", padx=2, pady=5)
|
||
self.pulse2_det3_max_var = ctk.StringVar(value="10")
|
||
ctk.CTkEntry(pulse2_signal_frame, textvariable=self.pulse2_det3_max_var, width=40).pack(side="left", padx=2, pady=5)
|
||
|
||
# 同步脉冲3
|
||
ctk.CTkLabel(sync_pulse_frame, text="同步脉冲3 个数:").grid(row=4, column=0, sticky="w", padx=10, pady=5)
|
||
self.sync_pulse3_count_var = ctk.StringVar(value="1")
|
||
pulse3_count_entry = ctk.CTkEntry(sync_pulse_frame, textvariable=self.sync_pulse3_count_var, width=80)
|
||
pulse3_count_entry.grid(row=4, column=1, sticky="w", padx=5, pady=5)
|
||
pulse3_count_entry.configure(validate="key", validatecommand=(pulse3_count_entry.register(self._validate_integer), '%P'))
|
||
|
||
ctk.CTkLabel(sync_pulse_frame, text="周期(10ns):").grid(row=4, column=2, sticky="w", padx=10, pady=5)
|
||
self.sync_pulse3_period_var = ctk.StringVar(value="400000")
|
||
pulse3_period_entry = ctk.CTkEntry(sync_pulse_frame, textvariable=self.sync_pulse3_period_var, width=80)
|
||
pulse3_period_entry.grid(row=4, column=3, sticky="w", padx=5, pady=5)
|
||
pulse3_period_entry.configure(validate="key", validatecommand=(pulse3_period_entry.register(self._validate_integer), '%P'))
|
||
|
||
# 同步脉冲3探测器信号数配置
|
||
pulse3_signal_frame = ctk.CTkFrame(sync_pulse_frame)
|
||
pulse3_signal_frame.grid(row=5, column=0, columnspan=4, sticky="w", padx=20, pady=5)
|
||
|
||
ctk.CTkLabel(pulse3_signal_frame, text=" 探测器1").pack(side="left", padx=5, pady=5)
|
||
self.pulse3_det1_min_var = ctk.StringVar(value="1")
|
||
ctk.CTkEntry(pulse3_signal_frame, textvariable=self.pulse3_det1_min_var, width=40).pack(side="left", padx=2, pady=5)
|
||
ctk.CTkLabel(pulse3_signal_frame, text="-").pack(side="left", padx=2, pady=5)
|
||
self.pulse3_det1_max_var = ctk.StringVar(value="10")
|
||
ctk.CTkEntry(pulse3_signal_frame, textvariable=self.pulse3_det1_max_var, width=40).pack(side="left", padx=2, pady=5)
|
||
|
||
ctk.CTkLabel(pulse3_signal_frame, text="探测器2").pack(side="left", padx=(15, 5), pady=5)
|
||
self.pulse3_det2_min_var = ctk.StringVar(value="1")
|
||
ctk.CTkEntry(pulse3_signal_frame, textvariable=self.pulse3_det2_min_var, width=40).pack(side="left", padx=2, pady=5)
|
||
ctk.CTkLabel(pulse3_signal_frame, text="-").pack(side="left", padx=2, pady=5)
|
||
self.pulse3_det2_max_var = ctk.StringVar(value="10")
|
||
ctk.CTkEntry(pulse3_signal_frame, textvariable=self.pulse3_det2_max_var, width=40).pack(side="left", padx=2, pady=5)
|
||
|
||
ctk.CTkLabel(pulse3_signal_frame, text="探测器3").pack(side="left", padx=(15, 5), pady=5)
|
||
self.pulse3_det3_min_var = ctk.StringVar(value="1")
|
||
ctk.CTkEntry(pulse3_signal_frame, textvariable=self.pulse3_det3_min_var, width=40).pack(side="left", padx=2, pady=5)
|
||
ctk.CTkLabel(pulse3_signal_frame, text="-").pack(side="left", padx=2, pady=5)
|
||
self.pulse3_det3_max_var = ctk.StringVar(value="10")
|
||
ctk.CTkEntry(pulse3_signal_frame, textvariable=self.pulse3_det3_max_var, width=40).pack(side="left", padx=2, pady=5)
|
||
|
||
# 同步脉冲4
|
||
ctk.CTkLabel(sync_pulse_frame, text="同步脉冲4 个数:").grid(row=6, column=0, sticky="w", padx=10, pady=5)
|
||
self.sync_pulse4_count_var = ctk.StringVar(value="0")
|
||
pulse4_count_entry = ctk.CTkEntry(sync_pulse_frame, textvariable=self.sync_pulse4_count_var, width=80)
|
||
pulse4_count_entry.grid(row=6, column=1, sticky="w", padx=5, pady=5)
|
||
pulse4_count_entry.configure(validate="key", validatecommand=(pulse4_count_entry.register(self._validate_integer), '%P'))
|
||
|
||
ctk.CTkLabel(sync_pulse_frame, text="周期(10ns):").grid(row=6, column=2, sticky="w", padx=10, pady=5)
|
||
self.sync_pulse4_period_var = ctk.StringVar(value="0")
|
||
pulse4_period_entry = ctk.CTkEntry(sync_pulse_frame, textvariable=self.sync_pulse4_period_var, width=80)
|
||
pulse4_period_entry.grid(row=6, column=3, sticky="w", padx=5, pady=5)
|
||
pulse4_period_entry.configure(validate="key", validatecommand=(pulse4_period_entry.register(self._validate_integer), '%P'))
|
||
|
||
# 同步脉冲4探测器信号数配置
|
||
pulse4_signal_frame = ctk.CTkFrame(sync_pulse_frame)
|
||
pulse4_signal_frame.grid(row=7, column=0, columnspan=4, sticky="w", padx=20, pady=5)
|
||
|
||
ctk.CTkLabel(pulse4_signal_frame, text=" 探测器1").pack(side="left", padx=5, pady=5)
|
||
self.pulse4_det1_min_var = ctk.StringVar(value="1")
|
||
ctk.CTkEntry(pulse4_signal_frame, textvariable=self.pulse4_det1_min_var, width=40).pack(side="left", padx=2, pady=5)
|
||
ctk.CTkLabel(pulse4_signal_frame, text="-").pack(side="left", padx=2, pady=5)
|
||
self.pulse4_det1_max_var = ctk.StringVar(value="10")
|
||
ctk.CTkEntry(pulse4_signal_frame, textvariable=self.pulse4_det1_max_var, width=40).pack(side="left", padx=2, pady=5)
|
||
|
||
ctk.CTkLabel(pulse4_signal_frame, text="探测器2").pack(side="left", padx=(15, 5), pady=5)
|
||
self.pulse4_det2_min_var = ctk.StringVar(value="1")
|
||
ctk.CTkEntry(pulse4_signal_frame, textvariable=self.pulse4_det2_min_var, width=40).pack(side="left", padx=2, pady=5)
|
||
ctk.CTkLabel(pulse4_signal_frame, text="-").pack(side="left", padx=2, pady=5)
|
||
self.pulse4_det2_max_var = ctk.StringVar(value="10")
|
||
ctk.CTkEntry(pulse4_signal_frame, textvariable=self.pulse4_det2_max_var, width=40).pack(side="left", padx=2, pady=5)
|
||
|
||
ctk.CTkLabel(pulse4_signal_frame, text="探测器3").pack(side="left", padx=(15, 5), pady=5)
|
||
self.pulse4_det3_min_var = ctk.StringVar(value="1")
|
||
ctk.CTkEntry(pulse4_signal_frame, textvariable=self.pulse4_det3_min_var, width=40).pack(side="left", padx=2, pady=5)
|
||
ctk.CTkLabel(pulse4_signal_frame, text="-").pack(side="left", padx=2, pady=5)
|
||
self.pulse4_det3_max_var = ctk.StringVar(value="10")
|
||
ctk.CTkEntry(pulse4_signal_frame, textvariable=self.pulse4_det3_max_var, width=40).pack(side="left", padx=2, pady=5)
|
||
|
||
# 探测器设置框架
|
||
self.detector_frame = ctk.CTkFrame(self)
|
||
self.detector_frame.grid(row=2, column=0, sticky="nsew", pady=(0, 10))
|
||
self.detector_frame.grid_columnconfigure(0, weight=1)
|
||
|
||
# 标题
|
||
ctk.CTkLabel(
|
||
self.detector_frame,
|
||
text="探测器设置",
|
||
font=ctk.CTkFont(size=14, weight="bold")
|
||
).grid(row=0, column=0, sticky="w", padx=10, pady=10)
|
||
|
||
# 探测器选择器
|
||
detector_select_frame = ctk.CTkFrame(self.detector_frame)
|
||
detector_select_frame.grid(row=1, column=0, sticky="nsew", pady=(0, 10))
|
||
|
||
self.detector_var = ctk.StringVar(value="detector1")
|
||
# 保存当前探测器名称，用于在切换时保存配置
|
||
self.current_detector = "detector1"
|
||
|
||
ctk.CTkRadioButton(
|
||
detector_select_frame,
|
||
text="探测器1",
|
||
variable=self.detector_var,
|
||
value="detector1",
|
||
command=lambda: self.on_detector_change("detector1")
|
||
).pack(side="left", padx=20, pady=10)
|
||
ctk.CTkRadioButton(
|
||
detector_select_frame,
|
||
text="探测器2",
|
||
variable=self.detector_var,
|
||
value="detector2",
|
||
command=lambda: self.on_detector_change("detector2")
|
||
).pack(side="left", padx=20, pady=10)
|
||
ctk.CTkRadioButton(
|
||
detector_select_frame,
|
||
text="探测器3",
|
||
variable=self.detector_var,
|
||
value="detector3",
|
||
command=lambda: self.on_detector_change("detector3")
|
||
).pack(side="left", padx=20, pady=10)
|
||
|
||
# 探测器配置框架
|
||
self.config_frame = ctk.CTkFrame(self.detector_frame)
|
||
self.config_frame.grid(row=2, column=0, sticky="nsew")
|
||
|
||
# 配置探测器1的默认值
|
||
self.detector_configs = {
|
||
"detector1": {
|
||
"sample_space_size": 5000,
|
||
"allow_replacement": True,
|
||
"energy_distribution": {
|
||
"type": "normal",
|
||
"mean": 1000.0,
|
||
"std": 200.0
|
||
},
|
||
"timestamp_distribution": {
|
||
"type": "exponential",
|
||
"scale": 50.0,
|
||
"loc": 0.0
|
||
}
|
||
},
|
||
"detector2": {
|
||
"sample_space_size": 4000,
|
||
"allow_replacement": True,
|
||
"energy_distribution": {
|
||
"type": "normal",
|
||
"mean": 800.0,
|
||
"std": 150.0
|
||
},
|
||
"timestamp_distribution": {
|
||
"type": "uniform",
|
||
"low": 0.0,
|
||
"high": 200.0
|
||
}
|
||
},
|
||
"detector3": {
|
||
"sample_space_size": 6000,
|
||
"allow_replacement": True,
|
||
"energy_distribution": {
|
||
"type": "gamma",
|
||
"shape": 2.0,
|
||
"scale": 500.0
|
||
},
|
||
"timestamp_distribution": {
|
||
"type": "normal",
|
||
"mean": 100.0,
|
||
"std": 30.0
|
||
}
|
||
}
|
||
}
|
||
|
||
# 初始化分布参数变量
|
||
self.sample_space_var = ctk.StringVar(value="5000")
|
||
self.sample_space_var.trace_add('write', self._on_config_change)
|
||
self.allow_replacement_var = ctk.BooleanVar(value=True)
|
||
self.allow_replacement_var.trace_add('write', self._on_config_change)
|
||
self.energy_dist_type_var = ctk.StringVar(value="normal")
|
||
self.energy_dist_type_var.trace_add('write', self._on_config_change)
|
||
self.timestamp_dist_type_var = ctk.StringVar(value="exponential")
|
||
self.timestamp_dist_type_var.trace_add('write', self._on_config_change)
|
||
|
||
# 能量分布参数变量
|
||
self.energy_mean_var = ctk.StringVar(value="1000.0")
|
||
self.energy_mean_var.trace_add('write', self._on_config_change)
|
||
self.energy_std_var = ctk.StringVar(value="200.0")
|
||
self.energy_std_var.trace_add('write', self._on_config_change)
|
||
self.energy_low_var = ctk.StringVar(value="0.0")
|
||
self.energy_low_var.trace_add('write', self._on_config_change)
|
||
self.energy_high_var = ctk.StringVar(value="2000.0")
|
||
self.energy_high_var.trace_add('write', self._on_config_change)
|
||
self.energy_scale_var = ctk.StringVar(value="50.0")
|
||
self.energy_scale_var.trace_add('write', self._on_config_change)
|
||
self.energy_shape_var = ctk.StringVar(value="2.0")
|
||
self.energy_shape_var.trace_add('write', self._on_config_change)
|
||
self.energy_lam_var = ctk.StringVar(value="1000.0")
|
||
self.energy_lam_var.trace_add('write', self._on_config_change)
|
||
self.energy_sigma_var = ctk.StringVar(value="0.5")
|
||
self.energy_sigma_var.trace_add('write', self._on_config_change)
|
||
self.energy_loc_var = ctk.StringVar(value="0.0")
|
||
self.energy_loc_var.trace_add('write', self._on_config_change)
|
||
self.energy_constant_var = ctk.StringVar(value="1000.0")
|
||
self.energy_constant_var.trace_add('write', self._on_config_change)
|
||
|
||
# 时间戳分布参数变量
|
||
self.timestamp_mean_var = ctk.StringVar(value="100.0")
|
||
self.timestamp_mean_var.trace_add('write', self._on_config_change)
|
||
self.timestamp_std_var = ctk.StringVar(value="30.0")
|
||
self.timestamp_std_var.trace_add('write', self._on_config_change)
|
||
self.timestamp_low_var = ctk.StringVar(value="0.0")
|
||
self.timestamp_low_var.trace_add('write', self._on_config_change)
|
||
self.timestamp_high_var = ctk.StringVar(value="200.0")
|
||
self.timestamp_high_var.trace_add('write', self._on_config_change)
|
||
self.timestamp_scale_var = ctk.StringVar(value="50.0")
|
||
self.timestamp_scale_var.trace_add('write', self._on_config_change)
|
||
self.timestamp_shape_var = ctk.StringVar(value="2.0")
|
||
self.timestamp_shape_var.trace_add('write', self._on_config_change)
|
||
self.timestamp_lam_var = ctk.StringVar(value="100.0")
|
||
self.timestamp_lam_var.trace_add('write', self._on_config_change)
|
||
self.timestamp_sigma_var = ctk.StringVar(value="0.5")
|
||
self.timestamp_sigma_var.trace_add('write', self._on_config_change)
|
||
self.timestamp_loc_var = ctk.StringVar(value="0.0")
|
||
self.timestamp_loc_var.trace_add('write', self._on_config_change)
|
||
|
||
# 显示当前探测器配置
|
||
self.update_config_display()
|
||
|
||
def _on_config_change(self, *args):
|
||
"""配置变化时自动更新输出文件名（仅当用户未手动修改时）"""
|
||
# 防止递归调用
|
||
if hasattr(self, '_updating_config') and self._updating_config:
|
||
return
|
||
|
||
try:
|
||
if not self._user_modified:
|
||
# 设置更新标志
|
||
self._updating_config = True
|
||
|
||
# 保存当前探测器的配置（只保存当前探测器，不影响其他探测器）
|
||
self.save_detector_config()
|
||
|
||
generation_mode = self.generation_mode_var.get()
|
||
packing_mode = self.packing_mode_var.get()
|
||
|
||
# 安全获取序列数量，处理非数字输入
|
||
try:
|
||
num_events = int(self.num_events_var.get())
|
||
except Exception:
|
||
num_events = 8 # 默认值
|
||
|
||
# 生成文件名编码
|
||
mode_code = {'random': 'R', 'fixed': 'F', 'pulse': 'P'}[generation_mode]
|
||
pack_code = {'combined': 'C', 'separate': 'S'}[packing_mode]
|
||
|
||
# 获取探测器配置
|
||
detector_configs = {}
|
||
for i in range(1, 4):
|
||
det_key = f'detector{i}'
|
||
if det_key in self.detector_configs:
|
||
detector_configs[det_key] = self.detector_configs[det_key]
|
||
|
||
# 编码探测器样本空间设置
|
||
detector_codes = []
|
||
for i in range(1, 4):
|
||
det_key = f'detector{i}'
|
||
if det_key in detector_configs:
|
||
det_config = detector_configs[det_key]
|
||
|
||
# 样本空间大小（简化表示）
|
||
sample_size = det_config.get('sample_space_size', 5000)
|
||
if sample_size >= 1000000:
|
||
size_code = f"{sample_size//1000000}M"
|
||
elif sample_size >= 1000:
|
||
size_code = f"{sample_size//1000}K"
|
||
else:
|
||
size_code = str(sample_size)
|
||
|
||
# 能量分布编码
|
||
energy_dist = det_config.get('energy_distribution', {})
|
||
energy_type = energy_dist.get('type', 'normal')
|
||
energy_code = {'normal': 'N', 'exponential': 'E', 'gamma': 'G', 'uniform': 'U'}[energy_type]
|
||
|
||
# 时间戳分布编码
|
||
time_dist = det_config.get('timestamp_distribution', {})
|
||
time_type = time_dist.get('type', 'exponential')
|
||
time_code = {'normal': 'N', 'exponential': 'E', 'gamma': 'G', 'uniform': 'U'}[time_type]
|
||
|
||
detector_codes.append(f"D{i}{size_code}{energy_code}{time_code}")
|
||
|
||
detector_str = '_'.join(detector_codes)
|
||
|
||
# 生成文件名: {模式}{打包}_{事件数}_{探测器编码}
|
||
output_filename = f"{mode_code}{pack_code}_{num_events}ev_{detector_str}"
|
||
|
||
# 检查控件是否还存在
|
||
if hasattr(self, 'output_file_var'):
|
||
try:
|
||
self.output_file_var.set(output_filename)
|
||
except:
|
||
pass
|
||
|
||
# 清除更新标志
|
||
self._updating_config = False
|
||
except Exception as e:
|
||
# 确保清除更新标志
|
||
self._updating_config = False
|
||
pass
|
||
|
||
def _validate_integer(self, value):
|
||
"""验证整数输入"""
|
||
if value == "":
|
||
return True
|
||
try:
|
||
int(value)
|
||
return True
|
||
except ValueError:
|
||
return False
|
||
|
||
def _validate_float(self, value):
|
||
"""验证浮点数输入"""
|
||
if value == "":
|
||
return True
|
||
try:
|
||
float(value)
|
||
return True
|
||
except ValueError:
|
||
return False
|
||
|
||
def _on_output_file_focus_in(self, event):
|
||
"""当输出文件名文本框获得焦点时，保存当前值"""
|
||
# 保存当前值，用于在`_on_output_file_changed`中检查是否真的被修改了
|
||
if hasattr(self, 'output_file_var'):
|
||
self._last_output_file_value = self.output_file_var.get()
|
||
|
||
def _on_output_file_changed(self, *args):
|
||
"""当输出文件名被手动修改时"""
|
||
# 检查是否真的被修改了
|
||
if hasattr(self, '_last_output_file_value') and hasattr(self, 'output_file_var'):
|
||
if self.output_file_var.get() != self._last_output_file_value:
|
||
self._user_modified = True
|
||
|
||
def _on_work_mode_change(self, *args):
|
||
"""工作模式变化时更新同步脉冲默认值"""
|
||
mode = self.work_mode_var.get()
|
||
if mode == "CO":
|
||
self.sync_pulse1_count_var.set("475")
|
||
self.sync_pulse1_period_var.set("16000")
|
||
self.sync_pulse2_count_var.set("0")
|
||
self.sync_pulse2_period_var.set("0")
|
||
self.sync_pulse3_count_var.set("0")
|
||
self.sync_pulse3_period_var.set("0")
|
||
self.sync_pulse4_count_var.set("0")
|
||
self.sync_pulse4_period_var.set("0")
|
||
elif mode == "Sigma":
|
||
self.sync_pulse1_count_var.set("57")
|
||
self.sync_pulse1_period_var.set("88000")
|
||
self.sync_pulse2_count_var.set("0")
|
||
self.sync_pulse2_period_var.set("0")
|
||
self.sync_pulse3_count_var.set("0")
|
||
self.sync_pulse3_period_var.set("0")
|
||
self.sync_pulse4_count_var.set("0")
|
||
self.sync_pulse4_period_var.set("0")
|
||
elif mode == "Combo":
|
||
self.sync_pulse1_count_var.set("475")
|
||
self.sync_pulse1_period_var.set("16000")
|
||
self.sync_pulse2_count_var.set("20")
|
||
self.sync_pulse2_period_var.set("100000")
|
||
self.sync_pulse3_count_var.set("4")
|
||
self.sync_pulse3_period_var.set("1000000")
|
||
self.sync_pulse4_count_var.set("0")
|
||
self.sync_pulse4_period_var.set("0")
|
||
|
||
def browse_output_file(self):
|
||
"""浏览输出文件路径"""
|
||
filename = filedialog.asksaveasfilename(
|
||
defaultextension=".bin",
|
||
filetypes=[("Binary files", "*.bin"), ("All files", "*.*")]
|
||
)
|
||
if filename:
|
||
import os
|
||
self.output_file_var.set(os.path.splitext(filename)[0])
|
||
|
||
def on_detector_change(self, new_detector):
|
||
"""探测器切换时的回调"""
|
||
# 保存当前探测器的配置（使用self.current_detector，即切换前的探测器）
|
||
self.save_detector_config_for_detector(self.current_detector)
|
||
# 更新当前探测器名称
|
||
self.current_detector = new_detector
|
||
# 更新配置显示
|
||
self.update_config_display()
|
||
|
||
def update_config_display(self):
|
||
"""更新配置显示"""
|
||
# 设置更新标志，防止在更新配置显示时触发_on_config_change
|
||
self._updating_config = True
|
||
|
||
# 清空现有内容
|
||
for widget in self.config_frame.winfo_children():
|
||
widget.destroy()
|
||
|
||
detector = self.detector_var.get()
|
||
config = self.detector_configs[detector]
|
||
|
||
# 样本空间设置（横向排列）
|
||
sample_frame = ctk.CTkFrame(self.config_frame)
|
||
sample_frame.grid(row=0, column=0, columnspan=2, sticky="w", padx=20, pady=10)
|
||
|
||
ctk.CTkLabel(sample_frame, text="样本空间大小:").pack(side="left", padx=10, pady=5)
|
||
self.sample_space_var.set(str(config["sample_space_size"]))
|
||
sample_space_entry = ctk.CTkEntry(
|
||
sample_frame,
|
||
textvariable=self.sample_space_var,
|
||
width=100
|
||
)
|
||
sample_space_entry.pack(side="left", padx=5, pady=5)
|
||
sample_space_entry.configure(validate="key", validatecommand=(sample_space_entry.register(self._validate_integer), '%P'))
|
||
|
||
self.allow_replacement_var.set(config["allow_replacement"])
|
||
ctk.CTkCheckBox(
|
||
sample_frame,
|
||
text="允许重复抽样",
|
||
variable=self.allow_replacement_var
|
||
).pack(side="left", padx=20, pady=5)
|
||
|
||
|
||
# 分布类型（同一行）
|
||
energy_type_frame = ctk.CTkFrame(self.config_frame)
|
||
energy_type_frame.grid(row=3, column=0, columnspan=2, sticky="w", padx=20, pady=5)
|
||
|
||
ctk.CTkLabel(energy_type_frame, text="能量(keV)分布类型:").pack(side="left", padx=10, pady=5)
|
||
self.energy_dist_type_var.set(config["energy_distribution"]["type"])
|
||
ctk.CTkOptionMenu(
|
||
energy_type_frame,
|
||
values=["normal", "uniform", "exponential", "gamma", "poisson", "lognormal", "constant"],
|
||
variable=self.energy_dist_type_var,
|
||
command=self.on_energy_dist_type_change
|
||
).pack(side="left", padx=10, pady=5)
|
||
|
||
# 分布参数（根据类型动态显示）
|
||
self.energy_params_frame = ctk.CTkFrame(self.config_frame)
|
||
self.energy_params_frame.grid(row=4, column=0, columnspan=2, sticky="w", padx=40, pady=5)
|
||
self.update_energy_params()
|
||
|
||
|
||
# 分布类型（同一行）
|
||
timestamp_type_frame = ctk.CTkFrame(self.config_frame)
|
||
timestamp_type_frame.grid(row=7, column=0, columnspan=2, sticky="w", padx=20, pady=5)
|
||
|
||
ctk.CTkLabel(timestamp_type_frame, text="时间戳(us)分布类型:").pack(side="left", padx=10, pady=5)
|
||
self.timestamp_dist_type_var.set(config["timestamp_distribution"]["type"])
|
||
ctk.CTkOptionMenu(
|
||
timestamp_type_frame,
|
||
values=["normal", "uniform", "exponential", "gamma", "poisson", "lognormal"],
|
||
variable=self.timestamp_dist_type_var,
|
||
command=self.on_timestamp_dist_type_change
|
||
).pack(side="left", padx=10, pady=5)
|
||
|
||
# 分布参数（根据类型动态显示）
|
||
self.timestamp_params_frame = ctk.CTkFrame(self.config_frame)
|
||
self.timestamp_params_frame.grid(row=8, column=0, columnspan=2, sticky="w", padx=40, pady=5)
|
||
self.update_timestamp_params()
|
||
|
||
# 清除更新标志
|
||
self._updating_config = False
|
||
|
||
def on_energy_dist_type_change(self, value):
|
||
"""能量分布类型变化时的回调"""
|
||
self.update_energy_params()
|
||
|
||
def on_timestamp_dist_type_change(self, value):
|
||
"""时间戳分布类型变化时的回调"""
|
||
self.update_timestamp_params()
|
||
|
||
def update_energy_params(self):
|
||
"""更新能量分布参数"""
|
||
# 清空现有内容
|
||
for widget in self.energy_params_frame.winfo_children():
|
||
widget.destroy()
|
||
|
||
dist_type = self.energy_dist_type_var.get()
|
||
config = self.detector_configs[self.detector_var.get()]["energy_distribution"]
|
||
|
||
if dist_type == "normal":
|
||
# 均值和标准差
|
||
ctk.CTkLabel(self.energy_params_frame, text="均值:").pack(side="left", padx=10, pady=5)
|
||
self.energy_mean_var.set(str(config.get("mean", 1000.0)))
|
||
energy_mean_entry = ctk.CTkEntry(
|
||
self.energy_params_frame,
|
||
textvariable=self.energy_mean_var,
|
||
width=100
|
||
)
|
||
energy_mean_entry.pack(side="left", padx=5, pady=5)
|
||
energy_mean_entry.configure(validate="key", validatecommand=(energy_mean_entry.register(self._validate_float), '%P'))
|
||
|
||
ctk.CTkLabel(self.energy_params_frame, text="标准差:").pack(side="left", padx=10, pady=5)
|
||
self.energy_std_var.set(str(config.get("std", 200.0)))
|
||
energy_std_entry = ctk.CTkEntry(
|
||
self.energy_params_frame,
|
||
textvariable=self.energy_std_var,
|
||
width=100
|
||
)
|
||
energy_std_entry.pack(side="left", padx=5, pady=5)
|
||
energy_std_entry.configure(validate="key", validatecommand=(energy_std_entry.register(self._validate_float), '%P'))
|
||
|
||
elif dist_type == "uniform":
|
||
# 最小值和最大值
|
||
ctk.CTkLabel(self.energy_params_frame, text="最小值:").pack(side="left", padx=10, pady=5)
|
||
self.energy_low_var.set(str(config.get("low", 0.0)))
|
||
energy_low_entry = ctk.CTkEntry(
|
||
self.energy_params_frame,
|
||
textvariable=self.energy_low_var,
|
||
width=100
|
||
)
|
||
energy_low_entry.pack(side="left", padx=5, pady=5)
|
||
energy_low_entry.configure(validate="key", validatecommand=(energy_low_entry.register(self._validate_float), '%P'))
|
||
|
||
ctk.CTkLabel(self.energy_params_frame, text="最大值:").pack(side="left", padx=10, pady=5)
|
||
self.energy_high_var.set(str(config.get("high", 2000.0)))
|
||
energy_high_entry = ctk.CTkEntry(
|
||
self.energy_params_frame,
|
||
textvariable=self.energy_high_var,
|
||
width=100
|
||
)
|
||
energy_high_entry.pack(side="left", padx=5, pady=5)
|
||
energy_high_entry.configure(validate="key", validatecommand=(energy_high_entry.register(self._validate_float), '%P'))
|
||
|
||
elif dist_type == "exponential":
|
||
# 尺度参数
|
||
ctk.CTkLabel(self.energy_params_frame, text="尺度参数:").pack(side="left", padx=10, pady=5)
|
||
self.energy_scale_var.set(str(config.get("scale", 50.0)))
|
||
energy_scale_entry = ctk.CTkEntry(
|
||
self.energy_params_frame,
|
||
textvariable=self.energy_scale_var,
|
||
width=100
|
||
)
|
||
energy_scale_entry.pack(side="left", padx=5, pady=5)
|
||
energy_scale_entry.configure(validate="key", validatecommand=(energy_scale_entry.register(self._validate_float), '%P'))
|
||
|
||
# 位置参数（延迟/偏移）
|
||
ctk.CTkLabel(self.energy_params_frame, text="延迟/偏移:").pack(side="left", padx=10, pady=5)
|
||
self.energy_loc_var.set(str(config.get("loc", 0.0)))
|
||
energy_loc_entry = ctk.CTkEntry(
|
||
self.energy_params_frame,
|
||
textvariable=self.energy_loc_var,
|
||
width=100
|
||
)
|
||
energy_loc_entry.pack(side="left", padx=5, pady=5)
|
||
energy_loc_entry.configure(validate="key", validatecommand=(energy_loc_entry.register(self._validate_float), '%P'))
|
||
|
||
elif dist_type == "gamma":
|
||
# 尺度参数
|
||
ctk.CTkLabel(self.energy_params_frame, text="尺度参数:").pack(side="left", padx=10, pady=5)
|
||
self.energy_scale_var.set(str(config.get("scale", 50.0)))
|
||
energy_scale_entry = ctk.CTkEntry(
|
||
self.energy_params_frame,
|
||
textvariable=self.energy_scale_var,
|
||
width=100
|
||
)
|
||
energy_scale_entry.pack(side="left", padx=5, pady=5)
|
||
energy_scale_entry.configure(validate="key", validatecommand=(energy_scale_entry.register(self._validate_float), '%P'))
|
||
|
||
# 形状参数
|
||
ctk.CTkLabel(self.energy_params_frame, text="形状参数:").pack(side="left", padx=10, pady=5)
|
||
self.energy_shape_var.set(str(config.get("shape", 2.0)))
|
||
energy_shape_entry = ctk.CTkEntry(
|
||
self.energy_params_frame,
|
||
textvariable=self.energy_shape_var,
|
||
width=100
|
||
)
|
||
energy_shape_entry.pack(side="left", padx=5, pady=5)
|
||
energy_shape_entry.configure(validate="key", validatecommand=(energy_shape_entry.register(self._validate_float), '%P'))
|
||
|
||
elif dist_type == "poisson":
|
||
# lambda参数
|
||
ctk.CTkLabel(self.energy_params_frame, text="lambda:").pack(side="left", padx=10, pady=5)
|
||
self.energy_lam_var.set(str(config.get("lam", 1000.0)))
|
||
energy_lam_entry = ctk.CTkEntry(
|
||
self.energy_params_frame,
|
||
textvariable=self.energy_lam_var,
|
||
width=100
|
||
)
|
||
energy_lam_entry.pack(side="left", padx=5, pady=5)
|
||
energy_lam_entry.configure(validate="key", validatecommand=(energy_lam_entry.register(self._validate_float), '%P'))
|
||
|
||
elif dist_type == "lognormal":
|
||
# 均值和sigma
|
||
ctk.CTkLabel(self.energy_params_frame, text="均值:").pack(side="left", padx=10, pady=5)
|
||
self.energy_mean_var.set(str(config.get("mean", 6.0)))
|
||
energy_mean_entry = ctk.CTkEntry(
|
||
self.energy_params_frame,
|
||
textvariable=self.energy_mean_var,
|
||
width=100
|
||
)
|
||
energy_mean_entry.pack(side="left", padx=5, pady=5)
|
||
energy_mean_entry.configure(validate="key", validatecommand=(energy_mean_entry.register(self._validate_float), '%P'))
|
||
|
||
ctk.CTkLabel(self.energy_params_frame, text="sigma:").pack(side="left", padx=10, pady=5)
|
||
self.energy_sigma_var.set(str(config.get("sigma", 0.5)))
|
||
energy_sigma_entry = ctk.CTkEntry(
|
||
self.energy_params_frame,
|
||
textvariable=self.energy_sigma_var,
|
||
width=100
|
||
)
|
||
energy_sigma_entry.pack(side="left", padx=5, pady=5)
|
||
energy_sigma_entry.configure(validate="key", validatecommand=(energy_sigma_entry.register(self._validate_float), '%P'))
|
||
|
||
elif dist_type == "constant":
|
||
# 常量值
|
||
ctk.CTkLabel(self.energy_params_frame, text="常量值:").pack(side="left", padx=10, pady=5)
|
||
self.energy_constant_var.set(str(config.get("value", 1000.0)))
|
||
energy_constant_entry = ctk.CTkEntry(
|
||
self.energy_params_frame,
|
||
textvariable=self.energy_constant_var,
|
||
width=100
|
||
)
|
||
energy_constant_entry.pack(side="left", padx=5, pady=5)
|
||
energy_constant_entry.configure(validate="key", validatecommand=(energy_constant_entry.register(self._validate_float), '%P'))
|
||
|
||
def update_timestamp_params(self):
|
||
"""更新时间戳分布参数"""
|
||
# 清空现有内容
|
||
for widget in self.timestamp_params_frame.winfo_children():
|
||
widget.destroy()
|
||
|
||
dist_type = self.timestamp_dist_type_var.get()
|
||
config = self.detector_configs[self.detector_var.get()]["timestamp_distribution"]
|
||
|
||
if dist_type == "normal":
|
||
# 均值和标准差
|
||
ctk.CTkLabel(self.timestamp_params_frame, text="均值:").pack(side="left", padx=10, pady=5)
|
||
self.timestamp_mean_var.set(config.get("mean", 100.0))
|
||
ctk.CTkEntry(
|
||
self.timestamp_params_frame,
|
||
textvariable=self.timestamp_mean_var,
|
||
width=100
|
||
).pack(side="left", padx=5, pady=5)
|
||
|
||
ctk.CTkLabel(self.timestamp_params_frame, text="标准差:").pack(side="left", padx=10, pady=5)
|
||
self.timestamp_std_var.set(config.get("std", 30.0))
|
||
ctk.CTkEntry(
|
||
self.timestamp_params_frame,
|
||
textvariable=self.timestamp_std_var,
|
||
width=100
|
||
).pack(side="left", padx=5, pady=5)
|
||
|
||
elif dist_type == "uniform":
|
||
# 最小值和最大值
|
||
ctk.CTkLabel(self.timestamp_params_frame, text="最小值:").pack(side="left", padx=10, pady=5)
|
||
self.timestamp_low_var.set(config.get("low", 0.0))
|
||
ctk.CTkEntry(
|
||
self.timestamp_params_frame,
|
||
textvariable=self.timestamp_low_var,
|
||
width=100
|
||
).pack(side="left", padx=5, pady=5)
|
||
|
||
ctk.CTkLabel(self.timestamp_params_frame, text="最大值:").pack(side="left", padx=10, pady=5)
|
||
self.timestamp_high_var.set(config.get("high", 200.0))
|
||
ctk.CTkEntry(
|
||
self.timestamp_params_frame,
|
||
textvariable=self.timestamp_high_var,
|
||
width=100
|
||
).pack(side="left", padx=5, pady=5)
|
||
|
||
elif dist_type == "exponential":
|
||
# 尺度参数
|
||
ctk.CTkLabel(self.timestamp_params_frame, text="尺度参数:").pack(side="left", padx=10, pady=5)
|
||
self.timestamp_scale_var.set(config.get("scale", 50.0))
|
||
ctk.CTkEntry(
|
||
self.timestamp_params_frame,
|
||
textvariable=self.timestamp_scale_var,
|
||
width=100
|
||
).pack(side="left", padx=5, pady=5)
|
||
|
||
# 位置参数（延迟/偏移）
|
||
ctk.CTkLabel(self.timestamp_params_frame, text="延迟/偏移:").pack(side="left", padx=10, pady=5)
|
||
self.timestamp_loc_var.set(config.get("loc", 0.0))
|
||
ctk.CTkEntry(
|
||
self.timestamp_params_frame,
|
||
textvariable=self.timestamp_loc_var,
|
||
width=100
|
||
).pack(side="left", padx=5, pady=5)
|
||
|
||
elif dist_type == "gamma":
|
||
# 尺度参数
|
||
ctk.CTkLabel(self.timestamp_params_frame, text="尺度参数:").pack(side="left", padx=10, pady=5)
|
||
self.timestamp_scale_var.set(config.get("scale", 50.0))
|
||
ctk.CTkEntry(
|
||
self.timestamp_params_frame,
|
||
textvariable=self.timestamp_scale_var,
|
||
width=100
|
||
).pack(side="left", padx=5, pady=5)
|
||
|
||
# 形状参数
|
||
ctk.CTkLabel(self.timestamp_params_frame, text="形状参数:").pack(side="left", padx=10, pady=5)
|
||
self.timestamp_shape_var.set(config.get("shape", 2.0))
|
||
ctk.CTkEntry(
|
||
self.timestamp_params_frame,
|
||
textvariable=self.timestamp_shape_var,
|
||
width=100
|
||
).pack(side="left", padx=5, pady=5)
|
||
|
||
elif dist_type == "poisson":
|
||
# lambda参数
|
||
ctk.CTkLabel(self.timestamp_params_frame, text="lambda:").pack(side="left", padx=10, pady=5)
|
||
self.timestamp_lam_var.set(config.get("lam", 100.0))
|
||
ctk.CTkEntry(
|
||
self.timestamp_params_frame,
|
||
textvariable=self.timestamp_lam_var,
|
||
width=100
|
||
).pack(side="left", padx=5, pady=5)
|
||
|
||
elif dist_type == "lognormal":
|
||
# 均值和sigma
|
||
ctk.CTkLabel(self.timestamp_params_frame, text="均值:").pack(side="left", padx=10, pady=5)
|
||
self.timestamp_mean_var.set(config.get("mean", 4.0))
|
||
ctk.CTkEntry(
|
||
self.timestamp_params_frame,
|
||
textvariable=self.timestamp_mean_var,
|
||
width=100
|
||
).pack(side="left", padx=5, pady=5)
|
||
|
||
ctk.CTkLabel(self.timestamp_params_frame, text="sigma:").pack(side="left", padx=10, pady=5)
|
||
self.timestamp_sigma_var.set(config.get("sigma", 0.5))
|
||
ctk.CTkEntry(
|
||
self.timestamp_params_frame,
|
||
textvariable=self.timestamp_sigma_var,
|
||
width=100
|
||
).pack(side="left", padx=5, pady=5)
|
||
|
||
def save_detector_config(self):
|
||
"""保存探测器配置"""
|
||
detector = self.detector_var.get()
|
||
self.save_detector_config_for_detector(detector)
|
||
|
||
def save_detector_config_for_detector(self, detector):
|
||
"""保存指定探测器的配置"""
|
||
if detector not in self.detector_configs:
|
||
print(f"警告：探测器 {detector} 不存在")
|
||
return
|
||
|
||
# 更新样本空间大小和替换设置
|
||
try:
|
||
self.detector_configs[detector]["sample_space_size"] = int(self.sample_space_var.get())
|
||
except Exception:
|
||
self.detector_configs[detector]["sample_space_size"] = 5000 # 默认值
|
||
|
||
self.detector_configs[detector]["allow_replacement"] = self.allow_replacement_var.get()
|
||
|
||
# 更新能量分布 - 先清除旧参数，再设置新参数
|
||
dist_type = self.energy_dist_type_var.get()
|
||
# 保留type，清除其他所有参数
|
||
old_config = self.detector_configs[detector]["energy_distribution"]
|
||
self.detector_configs[detector]["energy_distribution"] = {"type": dist_type}
|
||
|
||
if dist_type == "normal":
|
||
try:
|
||
self.detector_configs[detector]["energy_distribution"]["mean"] = float(self.energy_mean_var.get())
|
||
except Exception:
|
||
self.detector_configs[detector]["energy_distribution"]["mean"] = 1000.0
|
||
try:
|
||
self.detector_configs[detector]["energy_distribution"]["std"] = float(self.energy_std_var.get())
|
||
except Exception:
|
||
self.detector_configs[detector]["energy_distribution"]["std"] = 200.0
|
||
elif dist_type == "uniform":
|
||
try:
|
||
self.detector_configs[detector]["energy_distribution"]["low"] = float(self.energy_low_var.get())
|
||
except Exception:
|
||
self.detector_configs[detector]["energy_distribution"]["low"] = 0.0
|
||
try:
|
||
self.detector_configs[detector]["energy_distribution"]["high"] = float(self.energy_high_var.get())
|
||
except Exception:
|
||
self.detector_configs[detector]["energy_distribution"]["high"] = 2000.0
|
||
elif dist_type == "exponential":
|
||
try:
|
||
self.detector_configs[detector]["energy_distribution"]["scale"] = float(self.energy_scale_var.get())
|
||
except Exception:
|
||
self.detector_configs[detector]["energy_distribution"]["scale"] = 50.0
|
||
try:
|
||
self.detector_configs[detector]["energy_distribution"]["loc"] = float(self.energy_loc_var.get())
|
||
except Exception:
|
||
self.detector_configs[detector]["energy_distribution"]["loc"] = 0.0
|
||
elif dist_type == "gamma":
|
||
try:
|
||
self.detector_configs[detector]["energy_distribution"]["shape"] = float(self.energy_shape_var.get())
|
||
except Exception:
|
||
self.detector_configs[detector]["energy_distribution"]["shape"] = 2.0
|
||
try:
|
||
self.detector_configs[detector]["energy_distribution"]["scale"] = float(self.energy_scale_var.get())
|
||
except Exception:
|
||
self.detector_configs[detector]["energy_distribution"]["scale"] = 50.0
|
||
elif dist_type == "poisson":
|
||
try:
|
||
self.detector_configs[detector]["energy_distribution"]["lam"] = float(self.energy_lam_var.get())
|
||
except Exception:
|
||
self.detector_configs[detector]["energy_distribution"]["lam"] = 1000.0
|
||
elif dist_type == "lognormal":
|
||
try:
|
||
self.detector_configs[detector]["energy_distribution"]["mean"] = float(self.energy_mean_var.get())
|
||
except Exception:
|
||
self.detector_configs[detector]["energy_distribution"]["mean"] = 6.0
|
||
try:
|
||
self.detector_configs[detector]["energy_distribution"]["sigma"] = float(self.energy_sigma_var.get())
|
||
except Exception:
|
||
self.detector_configs[detector]["energy_distribution"]["sigma"] = 0.5
|
||
|
||
elif dist_type == "constant":
|
||
try:
|
||
self.detector_configs[detector]["energy_distribution"]["value"] = float(self.energy_constant_var.get())
|
||
except Exception:
|
||
self.detector_configs[detector]["energy_distribution"]["value"] = 1000.0
|
||
|
||
# 更新时间戳分布 - 先清除旧参数，再设置新参数
|
||
dist_type = self.timestamp_dist_type_var.get()
|
||
# 保留type，清除其他所有参数
|
||
self.detector_configs[detector]["timestamp_distribution"] = {"type": dist_type}
|
||
|
||
if dist_type == "normal":
|
||
try:
|
||
self.detector_configs[detector]["timestamp_distribution"]["mean"] = float(self.timestamp_mean_var.get())
|
||
except Exception:
|
||
self.detector_configs[detector]["timestamp_distribution"]["mean"] = 100.0
|
||
try:
|
||
self.detector_configs[detector]["timestamp_distribution"]["std"] = float(self.timestamp_std_var.get())
|
||
except Exception:
|
||
self.detector_configs[detector]["timestamp_distribution"]["std"] = 30.0
|
||
elif dist_type == "uniform":
|
||
try:
|
||
self.detector_configs[detector]["timestamp_distribution"]["low"] = float(self.timestamp_low_var.get())
|
||
except Exception:
|
||
self.detector_configs[detector]["timestamp_distribution"]["low"] = 0.0
|
||
try:
|
||
self.detector_configs[detector]["timestamp_distribution"]["high"] = float(self.timestamp_high_var.get())
|
||
except Exception:
|
||
self.detector_configs[detector]["timestamp_distribution"]["high"] = 200.0
|
||
elif dist_type == "exponential":
|
||
try:
|
||
self.detector_configs[detector]["timestamp_distribution"]["scale"] = float(self.timestamp_scale_var.get())
|
||
except Exception:
|
||
self.detector_configs[detector]["timestamp_distribution"]["scale"] = 50.0
|
||
try:
|
||
self.detector_configs[detector]["timestamp_distribution"]["loc"] = float(self.timestamp_loc_var.get())
|
||
except Exception:
|
||
self.detector_configs[detector]["timestamp_distribution"]["loc"] = 0.0
|
||
elif dist_type == "gamma":
|
||
try:
|
||
self.detector_configs[detector]["timestamp_distribution"]["shape"] = float(self.timestamp_shape_var.get())
|
||
except Exception:
|
||
self.detector_configs[detector]["timestamp_distribution"]["shape"] = 2.0
|
||
try:
|
||
self.detector_configs[detector]["timestamp_distribution"]["scale"] = float(self.timestamp_scale_var.get())
|
||
except Exception:
|
||
self.detector_configs[detector]["timestamp_distribution"]["scale"] = 50.0
|
||
elif dist_type == "poisson":
|
||
try:
|
||
self.detector_configs[detector]["timestamp_distribution"]["lam"] = float(self.timestamp_lam_var.get())
|
||
except Exception:
|
||
self.detector_configs[detector]["timestamp_distribution"]["lam"] = 100.0
|
||
elif dist_type == "lognormal":
|
||
try:
|
||
self.detector_configs[detector]["timestamp_distribution"]["mean"] = float(self.timestamp_mean_var.get())
|
||
except Exception:
|
||
self.detector_configs[detector]["timestamp_distribution"]["mean"] = 4.0
|
||
try:
|
||
self.detector_configs[detector]["timestamp_distribution"]["sigma"] = float(self.timestamp_sigma_var.get())
|
||
except Exception:
|
||
self.detector_configs[detector]["timestamp_distribution"]["sigma"] = 0.5
|
||
|
||
def get_config(self):
|
||
"""获取配置"""
|
||
# 保存当前探测器的配置
|
||
self.save_detector_config()
|
||
|
||
# 解析信号类型
|
||
signal_type_str = self.signal_type_var.get()
|
||
if "0x70" in signal_type_str:
|
||
signal_type = 0x0070
|
||
else:
|
||
signal_type = 0x0007
|
||
|
||
# 构建基本配置
|
||
config = {
|
||
"num_events": int(self.num_events_var.get()) if self.num_events_var.get().strip() else 1,
|
||
"event_generation_mode": self.generation_mode_var.get(),
|
||
"packing_mode": self.packing_mode_var.get(),
|
||
"output_format": self._get_output_format(),
|
||
"output_file": self.output_file_var.get(),
|
||
"energy_conversion": {
|
||
"K": float(self.energy_K_var.get()) if self.energy_K_var.get().strip() else 1.0,
|
||
"B": float(self.energy_B_var.get()) if self.energy_B_var.get().strip() else 0.0
|
||
},
|
||
"work_mode": self.work_mode_var.get(),
|
||
"signal_type": signal_type,
|
||
"sync_pulses": [
|
||
{
|
||
"count": int(self.sync_pulse1_count_var.get()) if self.sync_pulse1_count_var.get().strip() else 0,
|
||
"period": int(self.sync_pulse1_period_var.get()) if self.sync_pulse1_period_var.get().strip() else 0
|
||
},
|
||
{
|
||
"count": int(self.sync_pulse2_count_var.get()) if self.sync_pulse2_count_var.get().strip() else 0,
|
||
"period": int(self.sync_pulse2_period_var.get()) if self.sync_pulse2_period_var.get().strip() else 0
|
||
},
|
||
{
|
||
"count": int(self.sync_pulse3_count_var.get()) if self.sync_pulse3_count_var.get().strip() else 0,
|
||
"period": int(self.sync_pulse3_period_var.get()) if self.sync_pulse3_period_var.get().strip() else 0
|
||
},
|
||
{
|
||
"count": int(self.sync_pulse4_count_var.get()) if self.sync_pulse4_count_var.get().strip() else 0,
|
||
"period": int(self.sync_pulse4_period_var.get()) if self.sync_pulse4_period_var.get().strip() else 0
|
||
}
|
||
]
|
||
}
|
||
|
||
# 添加同步脉冲探测器信号数配置
|
||
def safe_int(var, default):
|
||
try:
|
||
return int(var.get()) if var.get().strip() else default
|
||
except ValueError:
|
||
return default
|
||
|
||
config["sync_pulse_signals"] = {
|
||
"pulse1": {
|
||
"detector1": {"min": safe_int(self.pulse1_det1_min_var, 1), "max": safe_int(self.pulse1_det1_max_var, 10)},
|
||
"detector2": {"min": safe_int(self.pulse1_det2_min_var, 1), "max": safe_int(self.pulse1_det2_max_var, 10)},
|
||
"detector3": {"min": safe_int(self.pulse1_det3_min_var, 1), "max": safe_int(self.pulse1_det3_max_var, 10)}
|
||
},
|
||
"pulse2": {
|
||
"detector1": {"min": safe_int(self.pulse2_det1_min_var, 1), "max": safe_int(self.pulse2_det1_max_var, 10)},
|
||
"detector2": {"min": safe_int(self.pulse2_det2_min_var, 1), "max": safe_int(self.pulse2_det2_max_var, 10)},
|
||
"detector3": {"min": safe_int(self.pulse2_det3_min_var, 1), "max": safe_int(self.pulse2_det3_max_var, 10)}
|
||
},
|
||
"pulse3": {
|
||
"detector1": {"min": safe_int(self.pulse3_det1_min_var, 1), "max": safe_int(self.pulse3_det1_max_var, 10)},
|
||
"detector2": {"min": safe_int(self.pulse3_det2_min_var, 1), "max": safe_int(self.pulse3_det2_max_var, 10)},
|
||
"detector3": {"min": safe_int(self.pulse3_det3_min_var, 1), "max": safe_int(self.pulse3_det3_max_var, 10)}
|
||
},
|
||
"pulse4": {
|
||
"detector1": {"min": safe_int(self.pulse4_det1_min_var, 1), "max": safe_int(self.pulse4_det1_max_var, 10)},
|
||
"detector2": {"min": safe_int(self.pulse4_det2_min_var, 1), "max": safe_int(self.pulse4_det2_max_var, 10)},
|
||
"detector3": {"min": safe_int(self.pulse4_det3_min_var, 1), "max": safe_int(self.pulse4_det3_max_var, 10)}
|
||
}
|
||
}
|
||
|
||
# 确保每个探测器配置都包含name键
|
||
for detector_name, detector_config in self.detector_configs.items():
|
||
detector_config['name'] = detector_name
|
||
|
||
return config, self.detector_configs
|
||
|
||
def set_config(self, config, detector_configs=None):
|
||
"""设置配置"""
|
||
# 设置基本配置
|
||
if "num_events" in config:
|
||
self.num_events_var.set(config["num_events"])
|
||
if "event_generation_mode" in config:
|
||
self.generation_mode_var.set(config["event_generation_mode"])
|
||
if "packing_mode" in config:
|
||
self.packing_mode_var.set(config["packing_mode"])
|
||
if "output_format" in config:
|
||
self._set_output_format(config["output_format"])
|
||
if "output_file" in config:
|
||
self.output_file_var.set(config["output_file"])
|
||
|
||
# 设置能量转换参数
|
||
if "energy_conversion" in config:
|
||
energy_conv = config["energy_conversion"]
|
||
if "K" in energy_conv:
|
||
self.energy_K_var.set(energy_conv["K"])
|
||
if "B" in energy_conv:
|
||
self.energy_B_var.set(energy_conv["B"])
|
||
|
||
# 设置同步脉冲探测器信号数配置
|
||
if "sync_pulse_signals" in config:
|
||
sync_signals = config["sync_pulse_signals"]
|
||
# Pulse 1
|
||
if "pulse1" in sync_signals:
|
||
p1 = sync_signals["pulse1"]
|
||
if "detector1" in p1:
|
||
self.pulse1_det1_min_var.set(str(p1["detector1"].get("min", 1)))
|
||
self.pulse1_det1_max_var.set(str(p1["detector1"].get("max", 10)))
|
||
if "detector2" in p1:
|
||
self.pulse1_det2_min_var.set(str(p1["detector2"].get("min", 1)))
|
||
self.pulse1_det2_max_var.set(str(p1["detector2"].get("max", 10)))
|
||
if "detector3" in p1:
|
||
self.pulse1_det3_min_var.set(str(p1["detector3"].get("min", 1)))
|
||
self.pulse1_det3_max_var.set(str(p1["detector3"].get("max", 10)))
|
||
# Pulse 2
|
||
if "pulse2" in sync_signals:
|
||
p2 = sync_signals["pulse2"]
|
||
if "detector1" in p2:
|
||
self.pulse2_det1_min_var.set(str(p2["detector1"].get("min", 1)))
|
||
self.pulse2_det1_max_var.set(str(p2["detector1"].get("max", 10)))
|
||
if "detector2" in p2:
|
||
self.pulse2_det2_min_var.set(str(p2["detector2"].get("min", 1)))
|
||
self.pulse2_det2_max_var.set(str(p2["detector2"].get("max", 10)))
|
||
if "detector3" in p2:
|
||
self.pulse2_det3_min_var.set(str(p2["detector3"].get("min", 1)))
|
||
self.pulse2_det3_max_var.set(str(p2["detector3"].get("max", 10)))
|
||
# Pulse 3
|
||
if "pulse3" in sync_signals:
|
||
p3 = sync_signals["pulse3"]
|
||
if "detector1" in p3:
|
||
self.pulse3_det1_min_var.set(str(p3["detector1"].get("min", 1)))
|
||
self.pulse3_det1_max_var.set(str(p3["detector1"].get("max", 10)))
|
||
if "detector2" in p3:
|
||
self.pulse3_det2_min_var.set(str(p3["detector2"].get("min", 1)))
|
||
self.pulse3_det2_max_var.set(str(p3["detector2"].get("max", 10)))
|
||
if "detector3" in p3:
|
||
self.pulse3_det3_min_var.set(str(p3["detector3"].get("min", 1)))
|
||
self.pulse3_det3_max_var.set(str(p3["detector3"].get("max", 10)))
|
||
# Pulse 4
|
||
if "pulse4" in sync_signals:
|
||
p4 = sync_signals["pulse4"]
|
||
if "detector1" in p4:
|
||
self.pulse4_det1_min_var.set(str(p4["detector1"].get("min", 1)))
|
||
self.pulse4_det1_max_var.set(str(p4["detector1"].get("max", 10)))
|
||
if "detector2" in p4:
|
||
self.pulse4_det2_min_var.set(str(p4["detector2"].get("min", 1)))
|
||
self.pulse4_det2_max_var.set(str(p4["detector2"].get("max", 10)))
|
||
if "detector3" in p4:
|
||
self.pulse4_det3_min_var.set(str(p4["detector3"].get("min", 1)))
|
||
self.pulse4_det3_max_var.set(str(p4["detector3"].get("max", 10)))
|
||
|
||
# 设置探测器配置
|
||
if detector_configs and isinstance(detector_configs, dict):
|
||
for detector, det_config in detector_configs.items():
|
||
if detector in self.detector_configs:
|
||
# 清理配置，只保留必要的参数
|
||
cleaned_config = self._clean_detector_config(det_config)
|
||
self.detector_configs[detector] = cleaned_config
|
||
|
||
# 更新探测器配置显示
|
||
self.update_config_display()
|
||
|
||
def _clean_detector_config(self, det_config):
|
||
"""清理探测器配置，只保留必要的参数"""
|
||
cleaned = {
|
||
"sample_space_size": det_config.get("sample_space_size", 5000),
|
||
"allow_replacement": det_config.get("allow_replacement", True),
|
||
"energy_distribution": {},
|
||
"timestamp_distribution": {}
|
||
}
|
||
|
||
# 清理能量分布配置
|
||
energy_dist = det_config.get("energy_distribution", {})
|
||
energy_type = energy_dist.get("type", "normal")
|
||
cleaned["energy_distribution"]["type"] = energy_type
|
||
|
||
if energy_type == "normal":
|
||
cleaned["energy_distribution"]["mean"] = energy_dist.get("mean", 1000.0)
|
||
cleaned["energy_distribution"]["std"] = energy_dist.get("std", 200.0)
|
||
elif energy_type == "uniform":
|
||
cleaned["energy_distribution"]["low"] = energy_dist.get("low", 0.0)
|
||
cleaned["energy_distribution"]["high"] = energy_dist.get("high", 2000.0)
|
||
elif energy_type == "exponential":
|
||
cleaned["energy_distribution"]["scale"] = energy_dist.get("scale", 50.0)
|
||
cleaned["energy_distribution"]["loc"] = energy_dist.get("loc", 0.0)
|
||
elif energy_type == "gamma":
|
||
cleaned["energy_distribution"]["shape"] = energy_dist.get("shape", 2.0)
|
||
cleaned["energy_distribution"]["scale"] = energy_dist.get("scale", 50.0)
|
||
elif energy_type == "poisson":
|
||
cleaned["energy_distribution"]["lam"] = energy_dist.get("lam", 1000.0)
|
||
elif energy_type == "lognormal":
|
||
cleaned["energy_distribution"]["mean"] = energy_dist.get("mean", 6.0)
|
||
cleaned["energy_distribution"]["sigma"] = energy_dist.get("sigma", 0.5)
|
||
elif energy_type == "constant":
|
||
cleaned["energy_distribution"]["value"] = energy_dist.get("value", 1000.0)
|
||
|
||
# 清理时间戳分布配置
|
||
timestamp_dist = det_config.get("timestamp_distribution", {})
|
||
timestamp_type = timestamp_dist.get("type", "exponential")
|
||
cleaned["timestamp_distribution"]["type"] = timestamp_type
|
||
|
||
if timestamp_type == "normal":
|
||
cleaned["timestamp_distribution"]["mean"] = timestamp_dist.get("mean", 1000.0)
|
||
cleaned["timestamp_distribution"]["std"] = timestamp_dist.get("std", 200.0)
|
||
elif timestamp_type == "uniform":
|
||
cleaned["timestamp_distribution"]["low"] = timestamp_dist.get("low", 0.0)
|
||
cleaned["timestamp_distribution"]["high"] = timestamp_dist.get("high", 2000.0)
|
||
elif timestamp_type == "exponential":
|
||
cleaned["timestamp_distribution"]["scale"] = timestamp_dist.get("scale", 50.0)
|
||
cleaned["timestamp_distribution"]["loc"] = timestamp_dist.get("loc", 0.0)
|
||
elif timestamp_type == "gamma":
|
||
cleaned["timestamp_distribution"]["shape"] = timestamp_dist.get("shape", 2.0)
|
||
cleaned["timestamp_distribution"]["scale"] = timestamp_dist.get("scale", 50.0)
|
||
elif timestamp_type == "poisson":
|
||
cleaned["timestamp_distribution"]["lam"] = timestamp_dist.get("lam", 1000.0)
|
||
elif timestamp_type == "lognormal":
|
||
cleaned["timestamp_distribution"]["mean"] = timestamp_dist.get("mean", 6.0)
|
||
cleaned["timestamp_distribution"]["sigma"] = timestamp_dist.get("sigma", 0.5)
|
||
|
||
return cleaned
|
||
|
||
def _get_output_format(self):
|
||
"""获取输出格式"""
|
||
formats = []
|
||
if self.bin_var.get():
|
||
formats.append("binary")
|
||
if self.txt_var.get():
|
||
formats.append("text")
|
||
if self.debug_var.get():
|
||
formats.append("debug")
|
||
if not formats:
|
||
return "binary"
|
||
if len(formats) == 3:
|
||
return "all"
|
||
return formats[0]
|
||
|
||
def _set_output_format(self, format_str):
|
||
"""设置输出格式"""
|
||
if format_str == "all":
|
||
self.bin_var.set(True)
|
||
self.txt_var.set(True)
|
||
self.debug_var.set(True)
|
||
elif format_str == "binary":
|
||
self.bin_var.set(True)
|
||
self.txt_var.set(False)
|
||
self.debug_var.set(False)
|
||
elif format_str == "text":
|
||
self.bin_var.set(False)
|
||
self.txt_var.set(True)
|
||
self.debug_var.set(False)
|
||
elif format_str == "debug":
|
||
self.bin_var.set(False)
|
||
self.txt_var.set(False)
|
||
self.debug_var.set(True)
|