def test_baseline(): for event in event_stream(example_file_path): for tel_id in event.r0.tels_with_data: assert (event.r0.tel[tel_id].digicam_baseline == np.zeros(N_PIXELS) ).all() for event in event_stream(example_file_path_2): for tel_id in event.r0.tels_with_data: baseline = event.r0.tel[tel_id].digicam_baseline np.testing.assert_array_equal(baseline, EXPECTED_BASELINE)
def test_calibration_event_stream(): max_events = 10 calib_stream = calibration_event_stream(example_file_path, max_events=max_events) values = [] for event_calib in calib_stream: values.append([ event_calib.data.adc_samples, event_calib.data.digicam_baseline, event_calib.pixel_id ]) assert len(values) == max_events del calib_stream obs_stream = event_stream(example_file_path, max_events=max_events) for i, event in enumerate(obs_stream): event = list(event.r0.tel.values())[0] assert (values[i][0] == event.adc_samples).all() assert (values[i][1] == event.digicam_baseline).all() assert len(values[i][2]) == event.adc_samples.shape[0]
def test_event_source_old_style(): for _ in event_stream( [example_file_path], camera=digicam, camera_geometry=digicam_geometry): pass
def make_dark_base_line(): from digicampipe.calib.camera import filter from digicampipe.io.event_stream import event_stream from digicampipe.io.save_adc import save_dark with TemporaryDirectory() as temp_dir: outfile_path = os.path.join(temp_dir, "dark_baseline.npz") data_stream = event_stream(example_file_path) data_stream = filter.set_pixels_to_zero( data_stream, unwanted_pixels=[], ) data_stream = filter.filter_event_types(data_stream, flags=[8]) data_stream = save_dark(data_stream, outfile_path) for event_counter, _ in enumerate(data_stream): pass assert event_counter >= 5 npz_file = np.load(outfile_path) assert not np.any(np.isnan(npz_file['baseline'])) assert not np.any(np.isnan(npz_file['standard_deviation'])) assert len(npz_file['baseline']) == 1296 return npz_file
def test_compare_trigger_input_7(): events_digi = event_stream([example_file_path], disable_bar=True) events_digi = fill_trigger_input_7(events_digi) events_comp = event_stream([example_file_path], disable_bar=True) events_comp = fill_digicam_baseline(events_comp) events_comp = fill_trigger_patch(events_comp) events_comp = fill_trigger_input_7(events_comp) for event_digi, event_comp in zip(events_digi, events_comp): tel = event_digi.r0.tels_with_data[0] ti7_digi = event_digi.r0.tel[tel].trigger_input_7 ti7_comp = event_comp.r0.tel[tel].trigger_input_7 abs_diff = np.abs(ti7_digi - ti7_comp) sum_ti7 = ti7_digi + ti7_comp assert np.mean(abs_diff) < 3 assert np.nanmean(abs_diff / sum_ti7) < .05
def test_event_stream(): events = event_stream([example_file_path]) for event in events: event_id = event.r0.event_id energy = event.mc.energy break assert event_id == EVENT_ID assert energy == ENERGY
def test_compute_trigger_input_7(): events = event_stream([example_file_path]) events = fill_digicam_baseline(events) events = fill_trigger_patch(events) events = fill_trigger_input_7(events) for event in events: tel = event.r0.tels_with_data[0] assert np.all(np.isfinite(event.r0.tel[tel].trigger_input_7))
def main(baseline_file_path, urls, unwanted_pixels=[]): data_stream = event_stream(urls) data_stream = filter.set_pixels_to_zero(data_stream, unwanted_pixels=unwanted_pixels) data_stream = filter.filter_event_types(data_stream, flags=[8]) data_stream = save_dark(data_stream, baseline_file_path) for _ in tqdm(data_stream): pass
def entry(): args = docopt(__doc__) event_id = args['--event_id'] event_id = int(event_id) if event_id != 'None' else None data_stream = event_stream.event_stream(args['<INPUT>'], event_id=event_id - 1) for _, i in zip(data_stream, range(int(args['--start']))): pass display = EventViewer(data_stream) display.draw()
def main(infile): baselines = [] for data in tqdm(event_stream(infile)): for r0 in data.r0.tel.values(): baselines.append(r0.digicam_baseline) baselines = np.array(baselines) plt.figure() plt.plot(baselines[0]) plt.plot(baselines[1]) plt.plot(baselines[2]) plt.plot(baselines[-1]) plt.show()
def main(output_directory, urls, unwanted_patches, unwanted_clusters, blinding): dark_file_path = path.join(output_directory, 'dark.npz') dark_trigger_file_path = path.join(output_directory, 'bias_curve_dark.npz') thresholds = np.arange(0, 400, 10) data_stream = event_stream(urls, camera=DigiCam) data_stream = filter.set_patches_to_zero(data_stream, unwanted_patch=unwanted_patches) data_stream = r0.fill_trigger_input_7(data_stream) # Fill the flags (to be replaced by Digicam) data_stream = filter.filter_event_types(data_stream, flags=[8]) data_stream = save_bias_curve(data_stream, thresholds=thresholds, blinding=blinding, output_filename=dark_trigger_file_path, unwanted_cluster=unwanted_clusters) data_stream = save_dark(data_stream, dark_file_path) for _ in tqdm(data_stream): pass # Filter the events for display data_dark = np.load(dark_file_path) data_rate = np.load(dark_trigger_file_path) plt.figure() plt.hist(data_dark['baseline'], bins='auto') plt.xlabel('dark baseline [LSB]') plt.ylabel('count') plt.figure() plt.hist(data_dark['standard_deviation'], bins='auto') plt.xlabel('dark std [LSB]') plt.ylabel('count') fig = plt.figure() axis = fig.add_subplot(111) axis.errorbar(x=data_rate['threshold'], y=data_rate['rate'] * 1E9, yerr=data_rate['rate_error'] * 1E9, label='Blinding : {}'.format(blinding)) axis.set_ylabel('rate [Hz]') axis.set_xlabel('threshold [LSB]') axis.set_yscale('log') axis.legend(loc='best') plt.show()
def test_add_slow_data(): data_stream = event_stream(example_file_path, max_events=100) data_stream = add_slow_data(data_stream, basepath=aux_basepath) ts_slow = [] ts_data = [] for event in data_stream: tel_id = event.r0.tels_with_data[0] ts_slow.append(event.slow_data.DriveSystem.timestamp * 1e-3) ts_data.append(event.r0.tel[tel_id].local_camera_clock * 1e-9) ts_slow = np.array(ts_slow) ts_data = np.array(ts_data) diff = ts_data - ts_slow assert (diff <= 1.1).all()
def main(urls, outfile_path, baseline_path, do_plots=False): baseline = np.load(baseline_path) digicam = Camera() data_stream = event_stream(urls, expert_mode=True, camera=digicam, camera_geometry=digicam.geometry) data_stream = random_triggers.fill_baseline_r0(data_stream, n_bins=1050) data_stream = filter.filter_missing_baseline(data_stream) data_stream = filter.filter_event_types(data_stream, flags=[8]) data_stream = r1.calibrate_to_r1(data_stream, baseline) data_stream = filter.filter_period(data_stream, period=10 * u.second) save_external_triggers(data_stream, output_filename=outfile_path, pixel_list=np.arange(1296)) if do_plots: make_plots(outfile_path)
def test_event_id(): event_id = LAST_EVENT_ID - 3 for data in zfits_event_source(example_file_path, event_id=event_id): tel_id = 1 r0 = data.r0.tel[tel_id] number = r0.camera_event_number break assert number == event_id for data in event_stream(example_file_path, event_id=event_id): tel_id = 1 r0 = data.r0.tel[tel_id] number = r0.camera_event_number break assert number == event_id
def compute(files, output_filename, thresholds, n_samples=1024): thresholds = thresholds.astype(float) data_stream = event_stream(files) # data_stream = trigger.fill_event_type(data_stream, flag=8) data_stream = filters.filter_event_types(data_stream, flags=CameraEventType.INTERNAL) data_stream = baseline.fill_baseline_r0(data_stream, n_bins=n_samples) data_stream = filters.filter_missing_baseline(data_stream) data_stream = trigger.fill_trigger_patch(data_stream) data_stream = trigger.fill_trigger_input_7(data_stream) data_stream = trigger.fill_trigger_input_19(data_stream) output = compute_bias_curve( data_stream, thresholds=thresholds, ) rate, rate_error, cluster_rate, cluster_rate_error, thresholds, \ start_event_id, end_event_id, start_event_time, end_event_time = output with fitsio.FITS(output_filename, mode='rw', clobber=True) as f: f.write([ np.array([start_event_id, end_event_id]), np.array([start_event_time, end_event_time]) ], extname='meta', names=['event_id', 'time']) f.write(thresholds, extname='threshold', compress='gzip') f.write([rate, rate_error], extname='camera', names=['rate', 'error'], compress='gzip') f.write([cluster_rate, cluster_rate_error], names=['rate', 'error'], extname='cluster', compress='gzip') return output
def trigger_uniformity(files, plot="show", event_types=None, disable_bar=False): events = event_stream(files, disable_bar=disable_bar) if event_types is not None: events = filter_event_types(events, flags=event_types) # patxh matrix is a bool of size n_patch x n_pixel patch_matrix = compute_patch_matrix(camera=DigiCam) n_patch, n_pixel = patch_matrix.shape top7 = np.zeros([n_patch], dtype=np.float32) n_event = 0 for event in events: n_event += 1 tel = event.r0.tels_with_data[0] top7 += np.sum(event.r0.tel[tel].trigger_output_patch7, axis=1) patches_rate = top7 / n_event pixels_rate = patches_rate.reshape([1, -1]).dot(patch_matrix).flatten() print('pixels_rate from', np.min(pixels_rate), 'to', np.max(pixels_rate), 'trigger/event') if plot is None: return pixels_rate fig1 = plt.figure() ax = plt.gca() display = CameraDisplay(DigiCam.geometry, ax=ax, title='Trigger uniformity') display.add_colorbar() display.image = pixels_rate output_path = os.path.dirname(plot) if plot == "show" or not os.path.isdir(output_path): if not plot == "show": print('WARNING: Path ' + output_path + ' for output trigger ' + 'uniformity does not exist, displaying the plot instead.\n') plt.show() else: plt.savefig(plot) plt.close(fig1) return pixels_rate
def main(files, output_filename, display=False): n_bins = 1024 thresholds = np.arange(0, 400, 10) blinding = True data_stream = event_stream(files) data_stream = r0.fill_event_type(data_stream, flag=8) data_stream = random_triggers.fill_baseline_r0(data_stream, n_bins=n_bins) data_stream = filter.filter_missing_baseline(data_stream) data_stream = r0.fill_trigger_patch(data_stream) data_stream = r0.fill_trigger_input_7(data_stream) data_stream = r0.fill_trigger_input_19(data_stream) output = compute_bias_curve( data_stream, thresholds=thresholds, blinding=blinding, ) rate, rate_error, cluster_rate, cluster_rate_error, thresholds = output np.savez(file=output_filename, rate=rate, rate_error=rate_error, cluster_rate=cluster_rate, cluster_rate_error=cluster_rate_error, thresholds=thresholds) if display: fig = plt.figure() axes = fig.add_subplot(111) axes.errorbar(thresholds, rate * 1E9, yerr=rate_error * 1E9) axes.set_yscale('log') axes.set_xlabel('Threshold [LSB]') axes.set_ylabel('Rate [Hz]') plt.show()
def test_add_slow_data(): data_stream = event_stream(example_file_path, max_events=100) data_stream = add_slow_data(data_stream, basepath=aux_basepath, aux_services=( 'DigicamSlowControl', 'MasterSST1M', 'PDPSlowControl', 'SafetyPLC', 'DriveSystem', )) ts_digicam = [] ts_master = [] ts_pdp = [] ts_safety = [] ts_drive = [] ts_data = [] for event in data_stream: tel_id = event.r0.tels_with_data[0] ts_digicam.append(event.slow_data.DigicamSlowControl.timestamp * 1e-3) ts_master.append(event.slow_data.MasterSST1M.timestamp * 1e-3) ts_pdp.append(event.slow_data.PDPSlowControl.timestamp * 1e-3) ts_safety.append(event.slow_data.SafetyPLC.timestamp * 1e-3) ts_drive.append(event.slow_data.DriveSystem.timestamp * 1e-3) ts_data.append(event.r0.tel[tel_id].local_camera_clock * 1e-9) ts_digicam = np.array(ts_digicam) ts_master = np.array(ts_master) ts_pdp = np.array(ts_pdp) ts_safety = np.array(ts_safety) ts_drive = np.array(ts_drive) ts_data = np.array(ts_data) assert ((ts_data - ts_digicam) <= 1.1).all() assert ((ts_data - ts_master) <= 1.1).all() assert ((ts_data - ts_pdp) <= 1.1).all() assert ((ts_data - ts_safety) <= 1.1).all() assert ((ts_data - ts_drive) <= 1.1).all()
def main(args): # Input/Output files dark_baseline = np.load(args['--baseline_path']) digicam = Camera( # Source coordinates (in camera frame) source_x=0. * u.mm, source_y=0. * u.mm, ) # Config for NSB + baseline evaluation n_bins = 1000 # Config for Hillas parameters analysis reclean = True # Noisy pixels not taken into account in Hillas pixel_not_wanted = [ 1038, 1039, 1002, 1003, 1004, 966, 967, 968, 930, 931, 932, 896 ] additional_mask = np.ones(1296) additional_mask[pixel_not_wanted] = 0 additional_mask = additional_mask > 0 # Integration configuration (signal reco.) time_integration_options = { 'mask': None, 'mask_edges': None, 'peak': None, 'window_start': 3, 'window_width': 7, 'threshold_saturation': np.inf, 'n_samples': 50, 'timing_width': 6, 'central_sample': 11 } peak_position = utils.fake_timing_hist( time_integration_options['n_samples'], time_integration_options['timing_width'], time_integration_options['central_sample']) (time_integration_options['peak'], time_integration_options['mask'], time_integration_options['mask_edges']) = utils.generate_timing_mask( time_integration_options['window_start'], time_integration_options['window_width'], peak_position) # Image cleaning configuration picture_threshold = 15 boundary_threshold = 10 shower_distance = 200 * u.mm # Define the event stream data_stream = event_stream(args['<files>'], camera=digicam) # Clean pixels data_stream = filter.set_pixels_to_zero(data_stream, unwanted_pixels=pixel_not_wanted) # Compute baseline with clocked triggered events # (sliding average over n_bins) data_stream = random_triggers.fill_baseline_r0(data_stream, n_bins=n_bins) # Stop events that are not triggered by DigiCam algorithm # (end of clocked triggered events) data_stream = filter.filter_event_types(data_stream, flags=[1, 2]) # Do not return events that have not the baseline computed # (only first events) data_stream = filter.filter_missing_baseline(data_stream) # Run the r1 calibration (i.e baseline substraction) data_stream = r1.calibrate_to_r1(data_stream, dark_baseline) # Run the dl0 calibration (data reduction, does nothing) data_stream = dl0.calibrate_to_dl0(data_stream) # Run the dl1 calibration (compute charge in photons + cleaning) data_stream = dl1.calibrate_to_dl1(data_stream, time_integration_options, additional_mask=additional_mask, picture_threshold=picture_threshold, boundary_threshold=boundary_threshold) # Return only showers with total number of p.e. above min_photon data_stream = filter.filter_shower(data_stream, min_photon=args['--min_photon']) # Run the dl2 calibration (Hillas) data_stream = dl2.calibrate_to_dl2(data_stream, reclean=reclean, shower_distance=shower_distance) if args['--display']: with plt.style.context('ggplot'): display = EventViewer(data_stream) display.draw() else: save_hillas_parameters_in_text(data_stream=data_stream, output_filename=args['--outfile_path'])
'central_sample': 11 } peak_position = utils.fake_timing_hist( time_integration_options['n_samples'], time_integration_options['timing_width'], time_integration_options['central_sample']) time_integration_options['peak'], time_integration_options['mask'], \ time_integration_options['mask_edges'] = utils.generate_timing_mask( time_integration_options['window_start'], time_integration_options['window_width'], peak_position) # Define the event stream data_stream = event_stream(urls, camera_geometry=digicam_geometry, expert_mode=True) # Fill the flags (to be replaced by Digicam) data_stream = filter.fill_flag(data_stream, unwanted_patch=unwanted_patch) # Fill the baseline (to be replaced by Digicam) data_stream = random_triggers.fill_baseline_r0(data_stream, n_bins=3000) # data_stream = filter.filter_event_types(data_stream, flags=[1]) data_stream = filter.filter_missing_baseline(data_stream) save_to_pickle_gz(data_stream, 'test.pickle', overwrite=True, max_events=100)
def test_calibrate_to_dl1(): from digicampipe.calib.camera.dl1 import calibrate_to_dl1 # The next 50 lines are just setp. dark_baseline = make_dark_base_line() n_bins = 50 pixel_not_wanted = [ 1038, 1039, 1002, 1003, 1004, 966, 967, 968, 930, 931, 932, 896 ] additional_mask = np.ones(1296) additional_mask[pixel_not_wanted] = 0 additional_mask = additional_mask > 0 time_integration_options = { 'mask': None, 'mask_edges': None, 'peak': None, 'window_start': 3, 'window_width': 7, 'threshold_saturation': np.inf, 'n_samples': 50, 'timing_width': 6, 'central_sample': 11 } peak_position = utils.fake_timing_hist( time_integration_options['n_samples'], time_integration_options['timing_width'], time_integration_options['central_sample']) (time_integration_options['peak'], time_integration_options['mask'], time_integration_options['mask_edges']) = utils.generate_timing_mask( time_integration_options['window_start'], time_integration_options['window_width'], peak_position) data_stream = event_stream(example_file_path) data_stream = filter.set_pixels_to_zero( data_stream, unwanted_pixels=pixel_not_wanted, ) data_stream = random_triggers.fill_baseline_r0( data_stream, n_bins=n_bins, ) data_stream = filter.filter_event_types(data_stream, flags=[1, 2]) data_stream = filter.filter_missing_baseline(data_stream) data_stream = r1.calibrate_to_r1(data_stream, dark_baseline) data_stream = dl0.calibrate_to_dl0(data_stream) # This is the function under test data_stream = calibrate_to_dl1( data_stream, time_integration_options, additional_mask=additional_mask, picture_threshold=15, boundary_threshold=10, ) # This is the actual test: for event_counter, event in enumerate(data_stream): for dl1 in event.dl1.tel.values(): assert dl1.cleaning_mask.shape == (1296, ) assert dl1.cleaning_mask.dtype == np.bool assert not np.isnan(dl1.time_spread) assert dl1.pe_samples.shape == (1296, ) assert dl1.pe_samples.dtype == np.float64 assert dl1.on_border.shape == () assert dl1.on_border.dtype == np.bool assert event_counter >= 86
def main( files, outfile_path, outfile_suffix, picture_threshold=15, boundary_threshold=7, baseline0=9, baseline1=15, ): # Input/Output files digicam_config_file = args['--camera_config'] dark_baseline = None # Source coordinates (in camera frame) source_x = 0. * u.mm source_y = 0. * u.mm # Camera and Geometry objects # (mapping, pixel, patch + x,y coordinates pixels) digicam = Camera(_config_file=digicam_config_file) digicam_geometry = geometry.generate_geometry_from_camera( camera=digicam, source_x=source_x, source_y=source_y) # Noisy pixels not taken into account in Hillas pixel_not_wanted = [ 1038, 1039, 1002, 1003, 1004, 966, 967, 968, 930, 931, 932, 896 ] additional_mask = np.ones(1296) additional_mask[pixel_not_wanted] = 0 additional_mask = additional_mask > 0 # Integration configuration (signal reco.) time_integration_options = { 'mask': None, 'mask_edges': None, 'peak': None, 'window_start': 3, 'window_width': 7, # length of integration window 'threshold_saturation': np.inf, 'n_samples': 50, 'timing_width': 6, 'central_sample': 11 } peak_position = utils.fake_timing_hist( time_integration_options['n_samples'], time_integration_options['timing_width'], time_integration_options['central_sample']) (time_integration_options['peak'], time_integration_options['mask'], time_integration_options['mask_edges']) = utils.generate_timing_mask( time_integration_options['window_start'], time_integration_options['window_width'], peak_position) # Image cleaning configuration shower_distance = 200 * u.mm # Filtering on big showers min_photon = 50 # Config for Hillas parameters analysis n_showers = 100000000 reclean = True # Define the event stream data_stream = event_stream(files, camera_geometry=digicam_geometry, camera=digicam) # Clean pixels data_stream = filter.set_pixels_to_zero(data_stream, unwanted_pixels=pixel_not_wanted) # Computation of baseline # # Methods: # # simtel_baseline.baseline_data() # Baseline is computed as a mean of 'n_bins0' first time samples, # 'n_bins1' last time samples. # A key assumption in this method is that the shower in simulated # data is somewhere in the middle of 50 samples. # Each pixel in each event has its own baseline # # simtel_baseline.baseline_simtel() # Baseline is taken as a value reported by sim_telarray # event.mc.tel[tel_id].pedestal/event.r0.tel[tel_id].num_samples. # That should be OK for all sim_telarray version from April # 2018, where an error for DC coupled simulations was corrected. data_stream = simtel_baseline.baseline_data(data_stream, n_bins0=baseline0, n_bins1=baseline1) # data_stream = simtel_baseline.baseline_simtel(data_stream) # Run the r1 calibration (i.e baseline substraction) data_stream = r1.calibrate_to_r1(data_stream, dark_baseline) # Run the dl1 calibration (compute charge in photons + cleaning) data_stream = dl1.calibrate_to_dl1(data_stream, time_integration_options, additional_mask=additional_mask, picture_threshold=picture_threshold, boundary_threshold=boundary_threshold) # Return only showers with total number of p.e. above min_photon data_stream = filter.filter_shower(data_stream, min_photon=min_photon) # Save cleaned events - pixels and corresponding values filename_pix = 'pixels.txt' filename_eventsimage = 'events_image_' + outfile_suffix + '.txt' data_stream = events_image.save_events(data_stream, outfile_path + filename_pix, outfile_path + filename_eventsimage) # Save simulated shower paramters filename_showerparam = 'pipedmc_param_' + outfile_suffix + '.txt' data_stream = mc_shower.save_shower(data_stream, outfile_path + filename_showerparam) # Run the dl2 calibration (Hillas) data_stream = dl2.calibrate_to_dl2(data_stream, reclean=reclean, shower_distance=shower_distance) # Save arrival times of photons in pixels passed cleaning filename_timing = 'timing_' + outfile_suffix + '.txt' data_stream = events_image.save_timing(data_stream, outfile_path + filename_timing) # Save mean baseline in event pixels filename_baseline = ('baseline_' + outfile_suffix + '_bas' + str(baseline0).zfill(2) + str(baseline1).zfill(2) + '.txt') # data_stream = simtel_baseline.save_mean_event_baseline( # data_stream, directory + filename_baseline) if args['--display']: with plt.style.context('ggplot'): display = EventViewer(data_stream) display.draw() else: # Save Hillas hillas_filename = 'hillas_' + outfile_suffix save_hillas_parameters(data_stream=data_stream, n_showers=n_showers, output_filename=outfile_path + hillas_filename) # save_hillas_parameters_in_text( # data_stream=data_stream, # output_filename=outfile_path + hillas_filename) """
[1.00000006e+08, 1.00000006e+08, 1.00000006e+08, 1.00000006e+08, 9.98248525e+07, 4.58257597e+07, 7.87400834e+06], [1.44337576e+08, 1.44337576e+08, 1.44337576e+08, 1.44337576e+08, 1.39066839e+08, 7.07843010e+07, 6.14071151e+07, 6.12372472e+07, 6.12372472e+07, 6.12372472e+07, 6.12372472e+07, 6.12372472e+07] ] threshold_care = [ [10., 25., 40., 55., 70., 85., 100.], [10., 20., 30., 40., 50., 60., 70.], [10., 20., 30., 40., 50., 60., 70., 80., 90., 100., 110., 120.] ] nsb_care = [1.5, 1.0, 0.9] # Define the event stream data_stream = event_stream(args['<fitsfiles>']) data_stream = filter.filter_event_types(data_stream, flags=[8]) data = np.load(args['<outfile>']) fig = plt.figure() axis = fig.add_subplot(111) axis.errorbar( data['threshold'], data['rate'] * 1E9, yerr=data['rate_error'] * 1E9, label='Blinding : {}'.format(blinding) ) axis.errorbar( threshold_care[0], rate_care[0],
def test_event_stream(): for _ in event_stream(example_file_path): pass
def func(): for _, i in zip(event_stream(example_file_path), range(100)): pass assert i == 99
def test_event_type_enum_behavior(): for event in event_stream(example_file_path): for _, r0 in event.r0.tel.items(): assert r0.camera_event_type.INTERNAL in r0.camera_event_type
def test_event_source_new_style(): for _ in event_stream(example_file_path): pass
def test_n_pixels(): for event in event_stream(example_file_path): assert event.inst.num_pixels[TEL_WITH_DATA] == N_PIXELS
def test_tel_with_data(): for event in event_stream(example_file_path): assert TEL_WITH_DATA in event.r0.tels_with_data
from digicamviewer import viewer from digicampipe.io import event_stream if __name__ == '__main__': directory = '/home/alispach/data/CRAB_01/' camera_config_file = '/home/alispach/Documents/PhD/ctasoft/CTS/config/camera_config.cfg' file_basename = directory + 'CRAB_01_0_000.%.3d.fits.fz' file_list = [file_basename % i for i in range(1, 11)] print(file_list) data_stream = event_stream.event_stream(file_list=file_list, expert_mode=True, geom_file=camera_config_file, remapped=True) display = viewer.EventViewer2( data_stream, n_samples=50, camera_config_file=camera_config_file) #, scale='lin') display.next(step=1) display.draw()