def main(): path = "/Users/Jason/Downloads/tempdata/muon_search/Run13312_dl1.h5" output_dir = path.replace("_dl1.h5", "_muonsearch") threshold = 60 number = 11 with DL1Reader(path) as reader: n_events = reader.n_events p_images = ImagePlotter(reader.mapping) for df in tqdm(reader.iterate_over_events(), total=n_events): iev = df['iev'].values[0] t_cpu = df['t_cpu'].values[0] sp_max = df['sp_max'].values above_threshold = sp_max > threshold n_sp_above = np.sum(above_threshold) // 4 if n_sp_above < number: continue sp_argmax = df['sp_argmax'].values image = df['photons'].values image_t = df['pulse_time'].values p_images.set_image( iev, t_cpu, above_threshold, sp_argmax, image, image_t, None ) p_images.save(join(output_dir, f"e{iev}.png"))
def process(file, fitter_class): name = file.__class__.__name__ input_paths = file.dl1_paths spe_config = file.spe_config poi = file.poi output_dir = get_plot(f"d190313_spectra_fitting/{name}") fitter_class_name = fitter_class.__name__ readers = [DL1Reader(path) for path in input_paths] n_illuminations = len(readers) fitter = fitter_class(n_illuminations, spe_config) charges = [] for reader in readers: pixel, charge = reader.select_columns(['pixel', 'charge_cc']) if poi != -1: charge_p = charge[pixel == poi] else: charge_p = charge charges.append(charge_p) fitter.apply(*charges) fitx = np.linspace(fitter.range[0], fitter.range[1], 1000) p_spe = SPEPlotter() p_spe.plot(fitx, fitter) p_spe.save(os.path.join(output_dir, f"fit_{fitter_class_name}.pdf")) p_spe_table = SPEPlotterTable() p_spe_table.plot(fitx, fitter) p_spe_table.save( os.path.join(output_dir, f"fit_table_{fitter_class_name}.pdf"))
def howmanyh5datasets(onlyone, maxdatain, datainlist, pathdir): dataincounta = -1 if onlyone == 0: stronly = 0 #OUTPUT for datain in range(0, maxdatain): str = datainlist[datain] #OUTPUT strtest = str.endswith("h5") if strtest == True: dataincounta = dataincounta + 1 #OUTPUT if onlyone == 1: dataincounta = 0 #OUTPUT str = "data_Run030_dl1.h5" #OUTPUT stronly = "data_Run030_dl1.h5" #OUTPUT openfirst = 0 datain = 0 while openfirst == 0: strtest = datainlist[datain].endswith("h5") if strtest == True: path = (pathdir + '/' + datainlist[datain]) readert = DL1Reader(path) #OUTPUT ievt = readert.select_column('iev').values #OUTPUT maxievt = max(ievt) #OUTPUT openfirst = 1 else: datain = datain + 1 return { 'onlyone': onlyone, 'dataincounta': dataincounta, 'str': str, 'maxievt': maxievt, 'ievt': ievt, 'readert': readert, 'stronly': stronly }
def main(): paths = [ "/Volumes/gct-jason/astri_onsky_archive/d2019-05-15_simulations/proton/run1_dl1.h5", ] df_list = [] for ipath, path in enumerate(paths): with DL1Reader(path) as reader: n_events = reader.get_metadata()['n_events'] mapping = reader.get_mapping() geom = get_ctapipe_camera_geometry(mapping, plate_scale=37.56e-3) desc = "Looping over events" it = reader.iterate_over_events() for df in tqdm(it, total=n_events, desc=desc): iev = df['iev'].values[0] image = df['photons'].values time = df['pulse_time'].values mask = obtain_cleaning_mask(geom, image, time) if not mask.any(): continue image_m = image[mask] time_m = time[mask] geom_m = geom[mask] try: hillas = hillas_parameters(geom_m, image_m) except HillasParameterizationError: continue # timing_parameters(geom_m, image_m, time_m, hillas) gt0 = image_m > 0 pix_x = geom_m.pix_x[gt0] pix_y = geom_m.pix_y[gt0] peakpos = time_m[gt0] intensity = image_m[gt0] longi, trans = camera_to_shower_coordinates( pix_x, pix_y, hillas.x, hillas.y, hillas.psi) longi = longi.value trans = trans.value # df_list.append(pd.DataFrame(dict( # ipath=ipath, # iev=iev, # longi=longi, # peakpos=peakpos, # ))) p_relation = RelationPlotter() p_relation.plot(longi, peakpos, intensity) p_relation.save( get_plot( f"d190524_time_gradient/relation/i{ipath}_e{iev}.pdf"))
def get_numpy(): """ Pandas dataframe columns are essentially numpy arrays. """ r = DL1Reader(PATH) df = r.load_entire_table() charge_numpy_array = df['charge'].values print(type(charge_numpy_array))
def select_subset(): """ A subset of the DataFrame can be selected to produce a new DataFrame """ r = DL1Reader(PATH) df = r.load_entire_table() df['tm'] = df['pixel'] // 64 df_tm4 = df.loc[df['tm'] == 4] print(df_tm4)
def get_table_mean(): """ Pandas also has its own methods for obtaining many statistical results, which can be applied to the entire table at once efficiently. """ r = DL1Reader(PATH) df = r.load_entire_table() mean_series = df.mean() print(mean_series)
def get_numpy_mean(): """ Pandas dataframe columns are essentially numpy array, and therefore can be operated on by any of the numpy methods. """ r = DL1Reader(PATH) df = r.load_entire_table() charge_mean = np.mean(df['charge']) print(charge_mean)
def open_runlist_dl1(path, open_readers=True): from CHECLabPy.core.io import DL1Reader df = read_runlist(path) input_dir = os.path.dirname(path) input_run_path = os.path.join(input_dir, "Run{:05d}_dl1.h5") df['path'] = [input_run_path.format(i) for i in df.index] if open_readers: df['reader'] = [DL1Reader(fp) for fp in df['path'].values] return df
def main(): description = ('Extract and fit the Single-Photoelectron spectrum ' 'from N dl1 files simultaneously') parser = argparse.ArgumentParser(description=description, formatter_class=Formatter) parser.add_argument('-f', '--files', dest='input_paths', nargs='+', help='path to the input dl1 run files') parser.add_argument('-o', '--output', dest='output_path', action='store', required=True, help='path to store the output image') parser.add_argument('-s', '--fitter', dest='fitter', action='store', default='GentileFitter', choices=SpectrumFitterFactory.subclass_names, help='SpectrumFitter to use') parser.add_argument('-c', '--config', dest='config', action='store', default=None, help='Path to SpectrumFitter configuration YAML file') parser.add_argument('-p', '--pixel', dest='plot_pixel', action='store', default=None, type=int, help='Pixel to plot. "-1" speciefies the ' 'entire camera') args = parser.parse_args() input_paths = args.input_paths output_path = args.output_path fitter_str = args.fitter config_path = args.config poi = args.plot_pixel readers = [DL1Reader(path) for path in input_paths] kwargs = dict( product_name=fitter_str, n_illuminations=len(readers), config_path=config_path ) fitter = SpectrumFitterFactory.produce(**kwargs) output_dir = os.path.dirname(output_path) if not os.path.exists(output_dir): os.makedirs(output_dir) print("Created directory: {}".format(output_dir)) if os.path.exists(output_path): os.remove(output_path) charges = [] for reader in readers: pixel, charge = reader.select_columns(['pixel', 'charge']) if poi != -1: charge_p = charge[pixel == poi] else: charge_p = charge charges.append(charge_p) fitter.apply(*charges) p_data = SPEPlotter() p_data.plot(fitter) p_data.save(output_path)
def get_multiple_statistics(): """ The `aggregate` method allows multiple operations to be performed at once """ r = DL1Reader(PATH) df = r.load_entire_table() df['tm'] = df['pixel'] // 64 df_stats = df[['tm', 'charge']].groupby('tm').agg(['mean', 'min', 'max']) print(df_stats) print(df_stats['charge']['mean'])
def main(): path = "/Volumes/gct-jason/astri_onsky_archive/d2019-10-03_simulations/gamma_1deg/run1_dl1.h5" # path = "/Volumes/gct-jason/astri_onsky_archive/d2019-05-15_simulations/gamma_1deg/run1_dl1_old.h5" reader = DL1Reader(path) df = reader.load_entire_table() image = df.groupby(['pixel']).sum()['photons'] ci = CameraImage.from_mapping(reader.mapping) ci.image = image ci.save(get_plot("d190717_alpha/true_images.pdf"))
def get_mean_per_tm(): """ The Pandas groupby method can be used to calculate statistics per group """ r = DL1Reader(PATH) df = r.load_entire_table() df['tm'] = df['pixel'] // 64 df_mean = df.groupby('tm').mean().reset_index() # reset_index() restores the tm column, # otherwise it will remain as the index print(df_mean)
def apply_different_statistic_to_different_column(): """ Passing a dict to `aggregate` allows you to specify a different operation depending on the column """ r = DL1Reader(PATH) df = r.load_entire_table() df['tm'] = df['pixel'] // 64 f = dict(pixel='first', charge='std') df_stats = df[['tm', 'pixel', 'charge']].groupby('tm').agg(f) print(df_stats)
def main(): description = 'Plot DL1 images' parser = argparse.ArgumentParser(description=description, formatter_class=Formatter) parser.add_argument('-f', '--file', dest='input_path', required=True, help='path to the HDF5 dl1 file') parser.add_argument('-o', '--output', dest='output_dir', help='directory to save the plots') parser.add_argument('-t', dest='datetime', required=True, help='Datetime to plot from (UTC)', type=valid_datetime) parser.add_argument('-m', dest='max_events', help='Max events', type=int) args = parser.parse_args() input_path = args.input_path output = args.output_dir dt = args.datetime max_events = args.max_events if output is None: output = input_path.replace("_dl1.h5", "_dl1images_dt") with DL1Reader(input_path) as reader: n_events = reader.n_events n_pixels = reader.n_pixels mapping = reader.mapping if max_events and max_events < n_events: n_events = max_events print(f"Ordering events from datetime: {dt}") t_cpu = reader.select_column("t_cpu").values.reshape( (n_events, n_pixels) )[:, 0] t_delta = t_cpu - np.datetime64(dt) indicis = np.argsort(np.absolute(t_delta)) if max_events: indicis = indicis[:max_events] p_image = ImagePlotter(mapping) desc = "Looping over events" for ientry, index in tqdm(enumerate(indicis), desc=desc): df = reader.select_event_index(index) iev = df['iev'].values[0] t_cpu = df['t_cpu'].values[0] image_c = df['photons'].values image_t = df['pulse_time'].values image_h = df['pulse_height'].values p_image.set_image(iev, image_c, image_t, image_h) p_image.fig.suptitle(f"Event: {iev}, Time: {t_cpu}") p_image.save(join(output, f"i{ientry}_e{iev}.png"))
def plot_imshow(): """ Plot the camera image using imshow (essentially a 2D histogram). Therefore does not include module gaps """ r = DL1Reader("/Users/Jason/Software/CHECLabPy/refdata/Run17473_dl1.h5") camera = CameraImageImshow.from_mapping(r.mapping) camera.add_colorbar("Charge (mV ns)") for df in r.iterate_over_events(): charge = df['charge'].values camera.image = charge plt.pause(0.1)
def apply_custom_function_agg(): """ One can also apply a custom function inside the agg approach """ r = DL1Reader(PATH) df = r.load_entire_table() df['tm'] = df['pixel'] // 64 f_camera_first_half = lambda g: df.loc[g.index].iloc[0]['tm'] < 32/2 f = dict(pixel=f_camera_first_half, charge='std') df_stats = df[['tm', 'pixel', 'charge']].groupby('tm').agg(f) df_stats = df_stats.rename(columns={'pixel': 'camera_first_half'}) print(df_stats)
def main(): poi = 1920 files = [ "/Volumes/gct-jason/data_checs/dynamicrange_180514/tf_poly/Run43520_dl1.h5", # "/Volumes/gct-jason/data_checs/dynamicrange_180514/tf_poly/Run43519_dl1.h5", "/Volumes/gct-jason/data_checs/dynamicrange_180514/tf_poly/Run43518_dl1.h5", # "/Volumes/gct-jason/data_checs/dynamicrange_180514/tf_poly/Run43517_dl1.h5", "/Volumes/gct-jason/data_checs/dynamicrange_180514/tf_poly/Run43516_dl1.h5", # "/Volumes/gct-jason/data_checs/dynamicrange_180514/tf_poly/Run43515_dl1.h5", "/Volumes/gct-jason/data_checs/dynamicrange_180514/tf_poly/Run43514_dl1.h5", # "/Volumes/gct-jason/data_checs/dynamicrange_180514/tf_poly/Run43513_dl1.h5", "/Volumes/gct-jason/data_checs/dynamicrange_180514/tf_poly/Run43512_dl1.h5", # "/Volumes/gct-jason/data_checs/dynamicrange_180514/tf_poly/Run43511_dl1.h5", "/Volumes/gct-jason/data_checs/dynamicrange_180514/tf_poly/Run43510_dl1.h5", # "/Volumes/gct-jason/data_checs/dynamicrange_180514/tf_poly/Run43509_dl1.h5", ] readers = [DL1Reader(i) for i in files] output_dir = os.path.abspath(os.path.dirname(__file__)) if not os.path.exists(output_dir): os.makedirs(output_dir) print("Created directory: {}".format(output_dir)) charges = [] desc = "Extracting charges from files" for r in tqdm(readers, desc=desc): p, c = r.select_columns(['pixel', 'charge']) c_pixel = c[p == poi] charges.append(c_pixel) # charges.append(c) fitter = GentileFitter(n_illuminations=len(charges)) fitter.range = [-25, 170] fitter.apply(*charges) coeff = fitter.coeff print(yaml.dump(coeff, indent=3)) p_spectrum = SpectrumPlotter() for i in range(len(readers)): hist = fitter.hist[i] edges = fitter.edges between = fitter.between fit_x = fitter.fit_x fit = fitter.fit[i] lambda_ = fitter.coeff['lambda_{}'.format(i)] p_spectrum.plot(hist, edges, between, fit_x, fit, lambda_) p_spectrum.save(os.path.join(output_dir, "multi_spectrum.pdf"))
def process(file): input_path = file.dl1_path angular_response_path = file.angular_response_path illumination_profile_path = file.illumination_profile_path plot_dir = file.plot_dir ip = IlluminationProfile(angular_response_path) reader = DL1Reader(input_path) mapping = reader.mapping pixel, true = reader.select_columns(['pixel', 'mc_true']) xpix = mapping['xpix'].values ypix = mapping['ypix'].values dist = np.sqrt(xpix**2 + ypix**2) n_pixels = mapping.metadata['n_pixels'] n_events = reader.n_events true_p = true.values.reshape((n_events, 2048)).mean(0) df = pd.DataFrame( dict( pixel=np.arange(n_pixels), distance=dist, true=true_p, )) pixel = df['pixel'].values true = df['true'].values dist = df['distance'].values params = polyfit(dist, true, [0, 2]) params_norm = params / polyval(0, params) pixel_corrections = polyval(dist, params_norm) df_corr = pd.DataFrame(dict( pixel=pixel, correction=pixel_corrections, )) df_params = pd.DataFrame(params_norm) with HDF5Writer(illumination_profile_path) as writer: writer.write(correction=df_corr, params=df_params) writer.write_mapping(mapping) p_dvt = PixelScatter(ip) p_dvt.plot(dist, true, params) p_dvt.save(os.path.join(plot_dir, "illumination_profile.pdf")) p_f = CameraImage.from_mapping(mapping) p_f.image = pixel_corrections p_f.add_colorbar("Illumination Profile Correction") p_f.save(os.path.join(plot_dir, "illumination_profile_camera.pdf"))
def main(): description = 'Plot the charge spectrum from a dl1 file' parser = argparse.ArgumentParser(description=description, formatter_class=Formatter) parser.add_argument('-f', '--file', dest='input_path', action='store', required=True, help='path to the dl1 HDF5 run file') parser.add_argument('-p', '--pixel', dest='pixel', action='store', type=int, default=0, help='pixel to plot the spectrum of') parser.add_argument('-C', '--charge_col_name', dest='charge_col_name', action='store', default='charge', type=str, help='The column name of the charge to' 'be used in the fit.') args = parser.parse_args() input_path = args.input_path pixel = args.pixel with DL1Reader(input_path) as reader: pixel_arr, charge = reader.select_columns( ['pixel', args.charge_col_name]) charge_pix = charge[pixel_arr == pixel] fig = plt.figure() ax = fig.add_subplot(1, 1, 1) _, edges, _ = ax.hist(charge, bins=1000, histtype='step', normed=True, label="All") ax.hist(charge_pix, bins=edges, histtype='step', normed=True, label="Pixel {}".format(pixel)) ax.legend(loc="upper right") plt.show()
def plot_from_dl1(): """ Use the CHECLabPy mapping dataframe to plot an image """ path = "/Users/Jason/Software/CHECLabPy/refdata/Run17473_dl1.h5" r = DL1Reader(path) camera = CameraImage.from_mapping(r.mapping) camera.add_colorbar("Charge (mV ns)") for i, df in enumerate(r.iterate_over_events()): if i > 10: break charge = df['charge'].values camera.image = charge plt.pause(0.1)
def process(spe_paths, spe_config, output_path, poi): readers = [DL1Reader(path) for path in spe_paths] n_illuminations = len(readers) fitter = SiPMGentileFitter(n_illuminations, spe_config) charges = [] for reader in readers: pixel, charge = reader.select_columns(['pixel', 'charge_cc']) charge_p = charge[pixel == poi] charges.append(charge_p) fitter.apply(*charges) p_spe = SPEPlotter() p_spe.plot(fitter) p_spe.save(output_path)
def process(file): dl1_paths = file.dl1_paths pde = file.pde mc_calib_path = file.mc_calib_path output_path = file.intensity_resolution_path n_runs = len(dl1_paths) reader_list = [DL1Reader(p) for p in dl1_paths] mapping = reader_list[0].mapping n_pixels = reader_list[0].n_pixels n_rows = n_pixels * 1000 with HDF5Reader(mc_calib_path) as reader: df = reader.read("data") mc_m = df['mc_m'].values cr = ChargeResolution(mc_true=True) cs = ChargeStatistics() desc0 = "Looping over files" for reader in tqdm(reader_list, total=n_runs, desc=desc0): pixel, charge, true = reader.select_columns( ['pixel', 'charge', 'mc_true'], stop=n_rows) true_photons = true / pde measured = charge / mc_m[pixel] f = true > 0 true_photons = true_photons[f] measured = measured[f] cr.add(pixel, true_photons, measured) cs.add(pixel, true_photons, measured) reader.store.close() df_cr_pixel, df_cr_camera = cr.finish() df_cs_pixel, df_cs_camera = cs.finish() with HDF5Writer(output_path) as writer: writer.write( charge_resolution_pixel=df_cr_pixel, charge_resolution_camera=df_cr_camera, charge_statistics_pixel=df_cs_pixel, charge_statistics_camera=df_cs_camera, ) writer.write_mapping(mapping) writer.write_metadata(n_pixels=n_pixels)
def apply_custom_function(): """ Any function can be passed to the `apply` method, including numpy functions You will notice that the numpy std method produces a different result to the pandas result. Thats because by default numpy calculates the sample standard deviation, whereas pandas includes the Bessel correction by default to correct for the bias in the estimation of the population variance. """ r = DL1Reader(PATH) df = r.load_entire_table() df['tm'] = df['pixel'] // 64 df_pd_std = df[['tm', 'charge']].groupby('tm').std()['charge'] df_np_std = df[['tm', 'charge']].groupby('tm').apply(np.std)['charge'] df_comparison = pd.DataFrame(dict(pd=df_pd_std, np=df_np_std)) print(df_comparison)
def process(file): dl1_paths = file.dl1_paths pde = file.pde mc_calib_path = file.mc_calib_path with DL1Reader(dl1_paths[0]) as reader: n_pixels = reader.n_pixels mapping = reader.mapping cols = ['pixel', 'charge', 'mc_true'] pixel, charge, true = reader.select_columns(cols) df = pd.DataFrame(dict( pixel=pixel, charge=charge, true=true, )) df_agg = df.groupby(['pixel', 'true']).agg({'charge': ['mean', 'std']}).reset_index() pixels = np.where(df.groupby('pixel').sum()['true'].values > 1000)[0] m_array = np.full(n_pixels, np.nan) for p in pixels: df_p = df_agg.loc[(df_agg['pixel'] == p) & (df_agg['true'] > 0)] x = df_p['true'].values / pde y = df_p['charge']['mean'].values yerr = df_p['charge']['std'].values yerr[np.isnan(yerr)] = 1000 yerr[yerr == 0] = 1000 c, m = polyfit(x, y, [1], w=y/yerr) m_array[p] = m df_calib = pd.DataFrame(dict( pixel=np.arange(n_pixels), mc_m=m_array, )) df_calib_mean = df_calib.copy() df_calib_mean['mc_m'] = np.nanmean(m_array) print("Average Gradient = {}".format(np.nanmean(m_array))) with HDF5Writer(mc_calib_path) as writer: writer.write(data=df_calib) writer.write_mapping(mapping) writer.write_metadata(n_pixels=n_pixels)
def process(file): illumination = 50 r1_path, _, _ = file.get_run_with_illumination(illumination, r1=True) dl1_path, _, _ = file.get_run_with_illumination(illumination, r1=False) poi = file.poi plot_dir = file.waveforms_plot_dir ff_path = file.ff_path with HDF5Reader(ff_path) as reader: df = reader.read("data") ff_m = df['ff_m'].values ff_c = df['ff_c'].values reader = TIOReader(r1_path) n_events = reader.n_events n_pixels = reader.n_pixels n_samples = reader.n_samples wfs = np.zeros((n_events, n_pixels, n_samples)) desc = "Processing events" for wf in tqdm(reader, total=n_events, desc=desc): wfs[wf.iev] = wf reader = DL1Reader(dl1_path) iev, pixel, charge_1d = reader.select_columns(['iev', 'pixel', 'charge']) charge_1d = (charge_1d - ff_c[pixel]) / ff_m[pixel] charge = np.zeros((n_events, n_pixels)) charge[iev, pixel] = charge_1d x = np.arange(n_samples) p_wf = WFPlotter(switch_backend=True) p_wf.plot(x, wfs[:, poi].T) p_wf.save(os.path.join(plot_dir, "p{}.pdf".format(poi))) p_wf = WFPlotter() p_wf.plot(x, wfs.mean(0).T) p_wf.save(get_plot(os.path.join(plot_dir, "average.pdf"))) p_hist = HistPlotter(switch_backend=True) p_hist.plot(charge[:, poi]) p_hist.save(os.path.join(plot_dir, "hist.pdf"))
def datareadin(ieve): #path=(b'C:\Users\Jamie Williams\Desktop\New folder\NSB200PE\data_Run030_dl1.h5') path = ( b'C:\Users\Jamie Williams\Desktop\New folder\Old data sets\Run17473_dl1.h5' ) ievcount = 10 reader = DL1Reader(path) reader.load_entire_table() charge = reader.select_column('charge').values iev = reader.select_column('iev').values charge = charge[iev == ievcount] #okpixel= okpixel[iev == ievcount] m = reader.mapping row = m['row'].values col = m['col'].values n_rows = m.metadata['n_rows'] n_cols = m.metadata['n_columns'] size = max(row + 1) okpixel = np.ones(len(charge), ) lencharge = len(charge) okpixel[ieve] = 0 data = np.ma.zeros((n_rows, n_cols)) data[row, col] = np.multiply(charge, okpixel) okpixel2 = np.ma.zeros((n_rows, n_cols)) okpixel2[row, col] = okpixel if size == 480: (mu, sigma) = norm.fit(data) #used to identify dead pixels for i1 in range(0, 48): for j1 in range(0, 48): if (data[i1, j1] < mu - sigma): #if (data[row,col]<mu-10*sigma): #do it without the loop? okpixel2[i1, j1] = 0 return { 'data': data, 'okpixel2': okpixel2, 'size': size, 'lencharge': lencharge }
def main(): description = ('Extract and fit the Single-Photoelectron spectrum ' 'from N dl1 files simultaneously') parser = argparse.ArgumentParser(description=description, formatter_class=Formatter) parser.add_argument('-f', '--files', dest='input_paths', nargs='+', help='path to the input dl1 run files') parser.add_argument('-o', '--output', dest='output_path', action='store', help='path to store the output HDF5 file ' '(OPTIONAL, will be automatically set if ' 'not specified)') parser.add_argument('-s', '--fitter', dest='fitter', action='store', default='GentileFitter', choices=SpectrumFitterFactory.subclass_names, help='SpectrumFitter to use') parser.add_argument('-c', '--config', dest='config', action='store', default=None, help='Path to SpectrumFitter configuration YAML file') parser.add_argument('-p', '--pixel', dest='plot_pixel', action='store', default=None, type=int, help='Enter plot mode, and plot the spectrum and fit ' 'for the pixel specified. "-1" speciefies the ' 'entire camera') args = parser.parse_args() input_paths = args.input_paths output_path = args.output_path fitter_str = args.fitter config_path = args.config plot_pixel = args.plot_pixel readers = [DL1Reader(path) for path in input_paths] kwargs = dict(product_name=fitter_str, n_illuminations=len(readers), config_path=config_path) fitter = SpectrumFitterFactory.produce(**kwargs) fit_processor = SpectrumFitProcessor(fitter, *readers) if plot_pixel is not None: p_fit = SpectrumFitPlotter() if plot_pixel == -1: charges = fit_processor.charges p_fit.plot_from_fitter(fitter, charges) else: charges = fit_processor.get_pixel_charges(plot_pixel) p_fit.plot_from_fitter(fitter, charges) if not output_path: name = '_spe_fit_p{}.pdf'.format(plot_pixel) if len(input_paths) == 1: output_path = input_paths[0].replace('_dl1.h5', name) else: output_dir = os.path.dirname(input_paths[0]) output_path = os.path.join(output_dir, name) p_fit.save(output_path) exit() # fit_processor.process() fit_processor.multiprocess() if not output_path: if len(input_paths) == 1: output_path = input_paths[0].replace('_dl1.h5', '_spe.h5') else: output_dir = os.path.dirname(input_paths[0]) output_path = os.path.join(output_dir, "spe.h5") output_dir = os.path.dirname(output_path) if not os.path.exists(output_dir): os.makedirs(output_dir) print("Created directory: {}".format(output_dir)) if os.path.exists(output_path): os.remove(output_path) print("Created HDFStore file: {}".format(output_path)) with pd.HDFStore(output_path) as store: df_coeff, df_initial, df_array = fit_processor.get_df_result() store['coeff_pixel'] = df_coeff store['initial_pixel'] = df_initial with warnings.catch_warnings(): warnings.simplefilter('ignore', PerformanceWarning) store['array_pixel'] = df_array df_coeff, df_initial, df_array = fit_processor.get_df_result_camera() store['coeff_camera'] = df_coeff store['initial_camera'] = df_initial with warnings.catch_warnings(): warnings.simplefilter('ignore', PerformanceWarning) store['array_camera'] = df_array metadata = dict(files=input_paths, fitter=fitter.__class__.__name__, n_illuminations=fit_processor.n_readers, n_pixels=fit_processor.n_pixels) store['metadata'] = pd.DataFrame() store.get_storer('metadata').attrs.metadata = metadata store['mapping'] = readers[0].mapping mapping_meta = readers[0].mapping.metadata store.get_storer('mapping').attrs.metadata = mapping_meta
def poisson(k, lamb): """poisson pdf, parameter lamb is the fit parameter""" return (lamb**k / factorial(k)) * np.exp(-lamb) def negLogLikelihood(params, data): """ the negative log-Likelohood-Function""" lnl = -np.sum(np.log(poisson(data, params[0]))) return lnl # get poisson deviated random numbers # data = np.random.poisson(2, 1000) r = DL1Reader( "/Volumes/gct-jason/mc_checs/dynamic_range_firstRun/sim_tel/Run43516_dl1.h5" ) data = r.select_column('mc_true').values # minimize the negative log-Likelihood result = minimize( negLogLikelihood, # function to minimize x0=np.ones(1), # start value args=(data, ), # additional arguments for function method='Powell', # minimization method, see docs ) # result is a scipy optimize result object, the fit parameters # are stored in result.x print(result)
def obtain_readers(files): return [DL1Reader(fp) for fp in files]