def create_new_mapping(input_path, output_path): """ Create a TargetCalib Mapping file with the latest pixel positions, but the prod3 pixel ordering """ create_directory(os.path.dirname(output_path)) df = pd.read_csv(input_path, sep='\t') df_new = df.sort_values(['row', 'col']) df_new['pixel'] = np.arange(2048) sp_ordering = df_new.groupby('superpixel').min().sort_values( 'pixel').index.values lookup = np.argsort(sp_ordering) df_new['superpixel'] = lookup[df_new['superpixel'].values] slot_ordering = df_new.groupby('slot').min().sort_values( 'pixel').index.values lookup = np.argsort(slot_ordering) df_new['slot'] = lookup[df_new['slot'].values] for itm in range(32): lookup = np.argsort(df_new.loc[df_new['slot'] == itm]['pixel'].values) df_new.loc[df_new['slot'] == itm, 'tmpix'] = lookup df_new.to_csv(output_path, sep='\t', float_format='%.7f', index=False)
def main(): description = ( "Generate the pedestals from an R0 file, subtract it from another " "R0 file, and plot the comparison of residuals from different " "pedestal methods") parser = argparse.ArgumentParser(description=description, formatter_class=Formatter) parser.add_argument('-f', '--file', dest='r0_path', required=True, help='R0 file to obtain residuals from') parser.add_argument('-p', '--pedestal', dest='pedestal_r0_path', required=True, help='R0 file to generate pedestal from') parser.add_argument('-o', '--output', dest='output_dir', required=True, help='directort to store output plots') args = parser.parse_args() r0_path = args.r0_path pedestal_r0_path = args.pedestal_r0_path output_dir = args.output_dir create_directory(output_dir) reader_ped = TIOReader(pedestal_r0_path, max_events=100000) reader_res = TIOReader(r0_path, max_events=1000) # Generate Pedestals pedestal = PedestalTargetCalib(reader_ped.n_pixels, reader_ped.n_samples, reader_ped.n_cells) desc = "Generating pedestal" for wfs in tqdm(reader_ped, total=reader_ped.n_events, desc=desc): if wfs.missing_packets: continue pedestal.add_to_pedestal(wfs, wfs.first_cell_id) channel_stats = PixelStats(reader_res.n_pixels) # Subtract Pedestals desc = "Subtracting pedestal" for wfs in tqdm(reader_res, total=reader_res.n_events, desc=desc): if wfs.missing_packets: continue subtracted_tc = pedestal.subtract_pedestal(wfs, wfs.first_cell_id) channel_stats.add_to_stats(subtracted_tc) # Plot results p_channel_std = ChannelStd() p_channel_std.plot(channel_stats.std) p_channel_std.save(join(output_dir, "channel_std.pdf")) p_ci_stats = CameraStats(reader_res.mapping) p_ci_stats.set_image(channel_stats.mean, channel_stats.std) p_ci_stats.save(join(output_dir, f"ci_stats.pdf"))
def main(): parser = argparse.ArgumentParser( description="Generate Camera configuration files") parser.add_argument('-o', dest='output', help='Output directory') args = parser.parse_args() output_dir = args.output create_directory(output_dir) n_samples = 128 width = 14 sigma = width / 2.355 for opct in np.linspace(0, 0.5, 6): for mv_per_pe in np.linspace(0.4, 4, 5): for nsb in np.linspace(0, 50, 5): pulse = GaussianPulse(20, sigma, 40, mv_per_pe=mv_per_pe) spe = SiPMPrompt(opct=opct, normalise_charge=False) coupling = ACOffsetCoupling(pulse_area=pulse.area, spectrum_average=spe.average) camera = Camera( mapping=SSTCameraMapping(), photoelectron_spectrum=spe, photoelectron_pulse=pulse, coupling=coupling, n_waveform_samples=n_samples, continuous_readout_duration=n_samples, readout_noise=GaussianNoise(stddev=0.5), digitisation_noise=GaussianNoise(stddev=1), ) camera.attach_metadata("nsb", nsb) name = f"camera_{opct:.2f}_{mv_per_pe:.2f}_{nsb:.2f}.pkl" camera.save(join(output_dir, name))
def main(): parser = argparse.ArgumentParser( description="Generate Camera configuration files") parser.add_argument('-o', dest='output', help='Output directory') args = parser.parse_args() output_dir = args.output create_directory(output_dir) n_samples = 96 spe = SiPMPrompt(opct=0.1, normalise_charge=False) camera_kwargs = dict( mapping=SSTCameraMapping(), photoelectron_spectrum=spe, n_waveform_samples=n_samples, continuous_readout_duration=n_samples, readout_noise=GaussianNoise(stddev=2), digitisation_noise=GaussianNoise(stddev=1), ) for mv_per_pe in [0.5, 0.8, 1.1, 1.375, 2.25, 3.125, 4]: for width in [2, 4, 6, 8, 10, 14, 20]: sigma = width / 2.355 pulse = GaussianPulse(30, sigma, 60, mv_per_pe=mv_per_pe) coupling = ACOffsetCoupling(pulse_area=pulse.area, spectrum_average=spe.average) camera = Camera(**camera_kwargs, photoelectron_pulse=pulse, coupling=coupling) name = f"width_{width:.2f}_height_{mv_per_pe:.2f}.pkl" camera.save(join(output_dir, name))
def main(): parser = argparse.ArgumentParser( description="Generate Camera configuration files") parser.add_argument('-o', dest='output', help='Output directory') args = parser.parse_args() output_dir = args.output create_directory(output_dir) # Define camera n_samples = 128 width = 8 # ns sigma = width / (2 * np.sqrt(2 * np.log(2))) pulse = GaussianPulse(mean=15, sigma=sigma, duration=30, mv_per_pe=4) camera_kwargs = dict( photoelectron_pulse=pulse, n_waveform_samples=n_samples, continuous_readout_duration=n_samples, digitisation_noise=GaussianNoise(stddev=1), ) # from scipy.signal import find_peaks, peak_widths # # def _extract_widths(pulse_y): # peaks, _ = find_peaks(pulse_y) # return peak_widths(pulse_y, peaks) # # def extract_width(pulse_x, pulse_y): # sample_width = pulse_x[1] - pulse_x[0] # pulse_width = _extract_widths(pulse_y)[0][0] * sample_width # # undershoot_widths = _extract_widths(-pulse_y) # if len(undershoot_widths[0]) == 0 : # undershoot_width = 0 # else: # undershoot_width = undershoot_widths[0][-1] * sample_width # return pulse_width, undershoot_width # # from matplotlib import pyplot as plt # plt.plot(pulse.time, pulse.amplitude) # plt.show() # width_pos, width_neg = extract_width(pulse.time, pulse.amplitude) # print(width_pos, width_neg) time_constant_list = [0, 5, 10, 20, 50, 100, 200, 1000] opct_list = np.linspace(0.01, 0.99, 50) for time_constant in time_constant_list: for opct in opct_list: spe = SiPMDelayed(opct=opct, time_constant=time_constant, normalise_charge=False) coupling = ACOffsetCoupling(pulse_area=pulse.area, spectrum_average=spe.average) camera = Camera(**camera_kwargs, photoelectron_spectrum=spe, coupling=coupling) name = f"opct{opct:.2f}_tc{time_constant:.0f}.pkl" camera.save(join(output_dir, name))
def main(): description = ( "Generate the pedestals from an R0 file, subtract it from another " "R0 file, and plot the comparison of residuals from different " "pedestal methods" ) parser = argparse.ArgumentParser(description=description, formatter_class=Formatter) parser.add_argument('-f', '--file', dest='r0_path', required=True, help='R0 file to obtain residuals from') parser.add_argument('-p', '--pedestal', dest='pedestal_r0_path', required=True, help='R0 file to generate pedestal from') parser.add_argument('-o', '--output', dest='output_dir', required=True, help='directort to store output plots') args = parser.parse_args() r0_path = args.r0_path pedestal_r0_path = args.pedestal_r0_path output_dir = args.output_dir create_directory(output_dir) reader_ped = TIOReader(pedestal_r0_path, max_events=100000) reader_res = TIOReader(r0_path, max_events=100000) # Generate Pedestals pedestal = PedestalTargetCalib( reader_ped.n_pixels, reader_ped.n_samples, reader_ped.n_cells ) desc = "Generating pedestal" for wfs in tqdm(reader_ped, total=reader_ped.n_events, desc=desc): if wfs.missing_packets: continue pedestal.add_to_pedestal(wfs, wfs.first_cell_id) online_stats = OnlineStats() online_hist = OnlineHist(bins=100, range_=(-10, 10)) # Subtract Pedestals desc = "Subtracting pedestal" for wfs in tqdm(reader_res, total=reader_res.n_events, desc=desc): if wfs.missing_packets: continue subtracted_tc = pedestal.subtract_pedestal(wfs, wfs.first_cell_id) online_stats.add_to_stats(subtracted_tc) online_hist.add(subtracted_tc) p_hist = HistPlot() p_hist.plot( online_hist.hist, online_hist.edges, online_stats.mean, online_stats.std, ) p_hist.save(join(output_dir, "hist.pdf"))
def main(): parser = argparse.ArgumentParser(description="Generate Camera configuration files") parser.add_argument('-o', dest='output', help='Output directory') args = parser.parse_args() output_dir = args.output create_directory(output_dir) # Define camera (CHEC-S) n_samples = 128 camera_kwargs = dict( photoelectron_spectrum=SiPMGentileSPE(x_max=20, spe_sigma=0.12, opct=0.4), n_waveform_samples=n_samples, continuous_readout_duration=n_samples, readout_noise=GaussianNoise(stddev=0.15), ) x = np.linspace(0, 128, 1000) n_sigma0 = 35 n_sigma1 = 40 ratio_values = [0.2, 0.4, 0.6, 0.8] sigma0_values = np.linspace(0.5, 20, n_sigma0) sigma1_values = np.linspace(0, 20, n_sigma1) pulse_width = np.zeros((n_sigma0, n_sigma1)) undershoot_width = np.zeros((n_sigma0, n_sigma1)) for ratio in tqdm(ratio_values): for isigma0, sigma0 in tqdm(enumerate(sigma0_values), total=n_sigma0): for isigma1, sigma1 in tqdm(enumerate(sigma1_values), total=n_sigma1): for scale in np.arange(0.1, 100, 0.04): # Find scale required for ratio y = pulse_(x, scale, sigma0, sigma1) area_pos, area_neg = extract_area(x, y) if np.sqrt((area_neg/area_pos - ratio)**2) < 0.05: break if sigma1 == 0: scale = 1 break else: continue y = pulse_(x, scale, sigma0, sigma1) width_pos, width_neg = extract_width(x, y) pulse_width[isigma0, isigma1] = width_pos undershoot_width[isigma0, isigma1] = width_neg if sigma1 > 0 else 0 pulse = GenericPulse(x, y) camera = Camera(**camera_kwargs, photoelectron_pulse=pulse) name = f"undershoot_{ratio:.2f}_{sigma0:.2f}_{sigma1:.2f}.pkl" camera.save(join(output_dir, name))
def create_new_camera_cfg(tc_cfg_path, output_path): """ Create a new sim_telarray camera cfg file using a TargetCalib mapping file """ create_directory(os.path.dirname(output_path)) mapping = Mapping(tc_cfg_path) mappingsp = mapping.GetMappingSP() with open(output_path, 'w') as f: write_PixType(f) write_pixel_positions(f, mapping) # write_trigger_groups_original(f, mapping, mappingsp) write_trigger_groups_unique(f, mapping, mappingsp)
def __init__(self, mapping, output_dir): super().__init__() self.fig = plt.figure(figsize=(8, 6)) self.ax = self.fig.add_subplot(1, 1, 1) self.ci = CameraImage.from_mapping(mapping, ax=self.ax) self.ci.add_colorbar("Pixel Amplitude (p.e.)", pad=-0.15) # self.ci.colorbar.set_label("Pixel Amplitude (p.e.)", labelpad=20) self.output_dir = output_dir self.source_point = None self.source_label = None self.alpha_line = None self.iframe = 0 create_directory(output_dir)
def main(): description = ( "Generate the pedestals from an R0 file, subtract it from another " "R0 file, and plot the comparison of residuals from different " "pedestal methods" ) parser = argparse.ArgumentParser(description=description, formatter_class=Formatter) parser.add_argument('-f', '--file', dest='r0_path', required=True, help='R0 file to obtain residuals from') parser.add_argument('-o', '--output', dest='output_dir', required=True, help='directort to store output plots') args = parser.parse_args() r0_path = args.r0_path channel = 0 output_dir = args.output_dir create_directory(output_dir) reader = TIOReader(r0_path, max_events=100000) # Generate Pedestals pedestal = PedestalCellPosition( reader.n_pixels, reader.n_samples, reader.n_cells ) desc = "Generating pedestal" for wfs in tqdm(reader, total=reader.n_events, desc=desc): if wfs.missing_packets: continue pedestal.add_to_pedestal(wfs, wfs.first_cell_id) # embed() for cell in range(reader.n_cells): if (pedestal.hits[channel, cell] == 0).all(): continue p_cell_wf = CellWaveform() p_cell_wf.plot( pedestal.pedestal[channel, cell], pedestal.std[channel, cell], pedestal.hits[channel, cell], cell ) p_cell_wf.save( join(output_dir, f"cell_pedestal_vs_position/{cell:04d}.pdf") )
def main(): with pd.HDFStore("performance.h5", mode='r') as store: df_data = store['data'] # Select fully sampled region df_data = df_data.loc[(df_data['pulse_width'] <= 20) & (df_data['undershoot_width'] <= 30)] # 20% UNDERSHOOT df = df_data.loc[df_data['ratio'] == 0.2] create_directory("figures") plot_tricontourf(df, "figures/tricontourf.png") plot_width_ratio(df, "figures/widthratio.pdf") plot_1d_pulse_width(df, "figures/1d_pulse_width.pdf") plot_1d_undershoot_width(df, "figures/1d_undershoot_width.pdf") plot_best(df_data, "figures/best.pdf")
def __init__(self, dl1_path, totalrows, monitor_path=None): print("Creating HDF5 file: {}".format(dl1_path)) create_directory(os.path.dirname(dl1_path)) if os.path.exists(dl1_path): remove(dl1_path) self.totalrows = totalrows self.metadata = {} self.n_bytes = 0 self.df_list = [] self.df_list_n_bytes = 0 self.monitor = None self.store = pd.HDFStore(dl1_path, complevel=9, complib='blosc:blosclz') if monitor_path: self.monitor = MonitorWriter(monitor_path, self.store)
def main(): parser = argparse.ArgumentParser( description="Generate Camera configuration files") parser.add_argument('-o', dest='output', help='Output directory') args = parser.parse_args() output_dir = args.output create_directory(output_dir) # Define camera n_samples = 128 width = 8 # ns sigma = width / (2 * np.sqrt(2 * np.log(2))) pulse = GaussianPulse(mean=15, sigma=sigma, duration=30, mv_per_pe=4) mapping = SSTCameraMapping() camera_kwargs = dict( mapping=mapping, photoelectron_pulse=pulse, n_waveform_samples=n_samples, continuous_readout_duration=n_samples, digitisation_noise=GaussianNoise(stddev=1), ) self_opct_l = [0.08, 0.15, 0.3] reflected_opct_l = [0, 0.08, 0.15, 0.3] reflected_scale_l = [0.6, 1.0, 1.5, 2.3, 5] for self_opct in self_opct_l: for reflected_opct in reflected_opct_l: for reflected_scale in reflected_scale_l: spe = SiPMReflectedOCT( opct=self_opct, reflected_opct=reflected_opct, reflected_scale=reflected_scale, normalise_charge=False, mapping=mapping, ) coupling = ACOffsetCoupling(pulse_area=pulse.area, spectrum_average=spe.average) camera = Camera(**camera_kwargs, photoelectron_spectrum=spe, coupling=coupling) name = f"refl_opct_{self_opct:.2f}_{reflected_opct:.2f}_{reflected_scale:.2f}.pkl" camera.save(join(output_dir, name))
def __init__(self, path): """ Helper class to write dataframes and metadata to a HDF5 file Parameters ---------- path : str Path to store the HDF5 """ create_directory(os.path.dirname(path)) print("Creating HDF5 file: {}".format(path)) self.keys = set() self.metadata = defaultdict(lambda: defaultdict(dict)) self.df_list = defaultdict(list) self.df_list_n_bytes = defaultdict(int) self.n_bytes = defaultdict(int) self.store = pd.HDFStore( path, mode='w', complevel=9, complib='blosc:blosclz' )
def get_data(path): data_path = os.path.join(_DATA, path) create_directory(os.path.dirname(data_path)) return data_path
def main(): description = ( "Generate the pedestals from an R0 file, subtract it from another " "R0 file, and plot the comparison of residuals from different " "pedestal methods") parser = argparse.ArgumentParser(description=description, formatter_class=Formatter) parser.add_argument('-f', '--file', dest='r0_path', required=True, help='R0 file to obtain residuals from') parser.add_argument('-p', '--pedestal', dest='pedestal_r0_path', required=True, help='R0 file to generate pedestal from') parser.add_argument('-o', '--output', dest='output_dir', required=True, help='directort to store output plots') args = parser.parse_args() r0_path = args.r0_path pedestal_r0_path = args.pedestal_r0_path output_dir = args.output_dir create_directory(output_dir) reader_ped = TIOReader(pedestal_r0_path) reader_res = TIOReader(r0_path, max_events=1000) # Generate Pedestals pedestal_info = (reader_ped.n_pixels, reader_ped.n_samples, reader_ped.n_cells) pedestal_tc = PedestalTargetCalib(*pedestal_info) pedestal_bp = PedestalBlockphase(*pedestal_info) desc = "Generating pedestal" for wfs in tqdm(reader_ped, total=reader_ped.n_events, desc=desc): if wfs.missing_packets: continue pedestal_tc.add_to_pedestal(wfs, wfs.first_cell_id) pedestal_bp.add_to_pedestal(wfs, wfs.first_cell_id) pstats_tc = PixelStats(reader_res.n_pixels) pstats_bp = PixelStats(reader_res.n_pixels) stats_tc = OnlineStats() stats_bp = OnlineStats() hist_tc = OnlineHist(100, (-10, 10)) hist_bp = OnlineHist(100, (-10, 10)) wf_list_tc = [] wf_list_bp = [] fci = [] # Subtract Pedestals desc = "Subtracting pedestal" for wfs in tqdm(reader_res, total=reader_res.n_events, desc=desc): if wfs.missing_packets: continue subtracted_tc = pedestal_tc.subtract_pedestal(wfs, wfs.first_cell_id) subtracted_bp = pedestal_bp.subtract_pedestal(wfs, wfs.first_cell_id) pstats_tc.add_to_stats(subtracted_tc) stats_tc.add_to_stats(subtracted_tc) hist_tc.add(subtracted_tc) pstats_bp.add_to_stats(subtracted_bp) stats_bp.add_to_stats(subtracted_bp) hist_bp.add(subtracted_bp) wf_list_tc.append(subtracted_tc) wf_list_bp.append(subtracted_bp) fci.append(wfs.first_cell_id) # Plot results label_tc = pedestal_tc.__class__.__name__ label_bp = pedestal_bp.__class__.__name__ p_pix_stats = StatsPlot() p_pix_stats.plot(pstats_tc.mean, pstats_tc.std, label_tc) p_pix_stats.plot(pstats_bp.mean, pstats_bp.std, label_bp) p_pix_stats.save(join(output_dir, "pix_stats.pdf")) p_ci_stats = Camera2(reader_res.mapping) p_ci_stats.set_image(pstats_tc.mean, pstats_tc.std) p_ci_stats.save(join(output_dir, f"ci_stats_{label_tc}.pdf")) p_ci_stats.set_image(pstats_bp.mean, pstats_bp.std) p_ci_stats.save(join(output_dir, f"ci_stats_{label_bp}.pdf")) p_hist = HistPlot() p_hist.plot(hist_tc.hist, hist_tc.edges, stats_tc.mean, stats_tc.std, label_tc) p_hist.plot(hist_bp.hist, hist_bp.edges, stats_bp.mean, stats_bp.std, label_bp) p_hist.save(join(output_dir, "hist.pdf")) p_wf_tc = WaveformPlot() p_wf_bp = WaveformPlot() wfs_tc = np.stack(wf_list_tc) wfs_bp = np.stack(wf_list_bp) avg_tc = np.average(wfs_tc, axis=0) avg_bp = np.average(wfs_bp, axis=0) for iev in range(len(wf_list_tc)): ev_avg_tc = np.average(wf_list_tc[iev] - avg_tc, axis=0) ev_avg_bp = np.average(wf_list_bp[iev] - avg_bp, axis=0) p_wf_tc.plot(ev_avg_tc, fci[iev]) p_wf_bp.plot(ev_avg_bp, fci[iev]) p_wf_tc.save(join(output_dir, f"wfs_{label_tc}.pdf")) p_wf_bp.save(join(output_dir, f"wfs_{label_bp}.pdf"))
def create_directory(directory): create_directory(directory)
def get_plot(path): plot_path = os.path.join(_PLOT, path) create_directory(os.path.dirname(plot_path)) return plot_path