def draw_camera(self, tel, data, axes=None): """ Draw a camera image using the correct geometry. Parameters ---------- tel : int The telescope you want drawn. data : `np.array` 1D array with length equal to npix. axes : `matplotlib.axes.Axes` A matplotlib axes object to plot on, or None to create a new one. Returns ------- `ctapipe.visualization.CameraDisplay` """ geom = self.get_geometry(tel) axes = axes if axes is not None else plt.gca() camera = CameraDisplay(geom, ax=axes) camera.image = data camera.cmap = plt.cm.viridis # camera.add_colorbar(ax=axes, label="Amplitude (ADC)") # camera.set_limits_percent(95) # autoscale return camera
def display_event(event, geoms): """an extremely inefficient display. It creates new instances of CameraDisplay for every event and every camera, and also new axes for each event. It's hacked, but it works """ print("Displaying... please wait (this is an inefficient implementation)") global fig ntels = len(event.r0.tels_with_data) fig.clear() plt.suptitle("EVENT {}".format(event.r0.event_id)) disps = [] for ii, tel_id in enumerate(event.r0.tels_with_data): print("\t draw cam {}...".format(tel_id)) nn = int(ceil(sqrt(ntels))) ax = plt.subplot(nn, nn, ii + 1) x, y = event.inst.pixel_pos[tel_id] geom = geoms[tel_id] disp = CameraDisplay(geom, ax=ax, title="CT{0}".format(tel_id)) disp.pixels.set_antialiaseds(False) disp.autoupdate = False disp.cmap = 'afmhot' chan = 0 signals = event.r0.tel[tel_id].adc_sums[chan].astype(float) signals -= signals.mean() disp.image = signals disp.set_limits_percent(95) disp.add_colorbar() disps.append(disp) return disps
def draw_several_cams(geom, ncams=4): cmaps = ['jet', 'afmhot', 'terrain', 'autumn'] fig, axs = plt.subplots( 1, ncams, figsize=(15, 4), ) for ii in range(ncams): disp = CameraDisplay( geom, ax=axs[ii], title="CT{}".format(ii + 1), ) disp.cmap = cmaps[ii] model = toymodel.generate_2d_shower_model( centroid=(0.2 - ii * 0.1, -ii * 0.05), width=0.05 + 0.001 * ii, length=0.15 + 0.05 * ii, psi=ii * 20 * u.deg, ) image, sig, bg = toymodel.make_toymodel_shower_image( geom, model.pdf, intensity=1500, nsb_level_pe=5, ) mask = tailcuts_clean( geom, image, picture_thresh=6 * image.mean(), boundary_thresh=4 * image.mean() ) cleaned = image.copy() cleaned[~mask] = 0 hillas = hillas_parameters(geom, cleaned) disp.image = image disp.add_colorbar(ax=axs[ii]) disp.set_limits_percent(95) disp.overlay_moments(hillas, linewidth=3, color='blue')
def plot_camera_display(self, image, input_file, noise_pixels_id_list, alive_ped_ev, sum_ped_ev): fig, ax = plt.subplots(figsize=(10, 8)) geom = CameraGeometry.from_name('LSTCam-003') disp0 = CameraDisplay(geom, ax=ax) disp0.image = image disp0.highlight_pixels(noise_pixels_id_list, linewidth=3) disp0.add_colorbar(ax=ax, label="N times signal remain after cleaning [%]") disp0.cmap = 'gnuplot2' ax.set_title("{} \n {}/{}".format( input_file.split("/")[-1][8:21], alive_ped_ev, sum_ped_ev), fontsize=25) print("{}/{}".format(alive_ped_ev, sum_ped_ev)) ax.set_xlabel(" ") ax.set_ylabel(" ") plt.tight_layout() plt.show()
def draw_several_cams(geom, ncams=4): cmaps = ['jet', 'afmhot', 'terrain', 'autumn'] fig, axs = plt.subplots(1, ncams, figsize=(15, 4), sharey=True, sharex=True) for ii in range(ncams): disp = CameraDisplay( geom, ax=axs[ii], title="CT{}".format(ii + 1), ) disp.cmap = cmaps[ii] model = toymodel.generate_2d_shower_model( centroid=(0.2 - ii * 0.1, -ii * 0.05), width=0.005 + 0.001 * ii, length=0.1 + 0.05 * ii, psi=ii * 20 * u.deg, ) image, sig, bg = toymodel.make_toymodel_shower_image( geom, model.pdf, intensity=50, nsb_level_pe=1000, ) mask = tailcuts_clean(geom, image, picture_thresh=6*image.mean(), boundary_thresh=4*image.mean()) cleaned = image.copy() cleaned[~mask] = 0 hillas = hillas_parameters(geom, cleaned) disp.image = image disp.add_colorbar(ax=axs[ii]) disp.set_limits_percent(95) disp.overlay_moments(hillas, linewidth=3, color='blue')
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 start(self): geom = None imsum = None disp = None for data in hessio_event_source(self.infile, allowed_tels=self._selected_tels, max_events=self.max_events): self.calibrator.calibrate(data) if geom is None: x, y = data.inst.pixel_pos[self._base_tel] flen = data.inst.optical_foclen[self._base_tel] geom = CameraGeometry.guess(x, y, flen) imsum = np.zeros(shape=x.shape, dtype=np.float) disp = CameraDisplay(geom, title=geom.cam_id) disp.add_colorbar() disp.cmap = 'viridis' if len(data.dl0.tels_with_data) <= 2: continue imsum[:] = 0 for telid in data.dl0.tels_with_data: imsum += data.dl1.tel[telid].image[0] self.log.info("event={} ntels={} energy={}" \ .format(data.r0.event_id, len(data.dl0.tels_with_data), data.mc.energy)) disp.image = imsum plt.pause(0.1) if self.output_suffix is not "": filename = "{:020d}{}".format(data.r0.event_id, self.output_suffix) self.log.info("saving: '{}'".format(filename)) plt.savefig(filename)
def start(self): geom = None imsum = None disp = None for event in self.reader: self.calibrator.calibrate(event) if geom is None: geom = event.inst.subarray.tel[self._base_tel].camera imsum = np.zeros(shape=geom.pix_x.shape, dtype=np.float) disp = CameraDisplay(geom, title=geom.cam_id) disp.add_colorbar() disp.cmap = 'viridis' if len(event.dl0.tels_with_data) <= 2: continue imsum[:] = 0 for telid in event.dl0.tels_with_data: imsum += event.dl1.tel[telid].image[0] self.log.info( "event={} ntels={} energy={}".format( event.r0.event_id, len(event.dl0.tels_with_data), event.mc.energy ) ) disp.image = imsum plt.pause(0.1) if self.output_suffix is not "": filename = "{:020d}{}".format( event.r0.event_id, self.output_suffix ) self.log.info(f"saving: '{filename}'") plt.savefig(filename)
def start(self): geom = None imsum = None disp = None for event in self.reader: self.calibrator(event) if geom is None: geom = event.inst.subarray.tel[self._base_tel].camera imsum = np.zeros(shape=geom.pix_x.shape, dtype=np.float) disp = CameraDisplay(geom, title=geom.cam_id) disp.add_colorbar() disp.cmap = 'viridis' if len(event.dl0.tels_with_data) <= 2: continue imsum[:] = 0 for telid in event.dl0.tels_with_data: imsum += event.dl1.tel[telid].image[0] self.log.info( "event={} ntels={} energy={}".format( event.r0.event_id, len(event.dl0.tels_with_data), event.mc.energy ) ) disp.image = imsum plt.pause(0.1) if self.output_suffix is not "": filename = "{:020d}{}".format( event.r0.event_id, self.output_suffix ) self.log.info(f"saving: '{filename}'") plt.savefig(filename)
def start(self): geom = None imsum = None disp = None for event in self.reader: self.calibrator(event) if geom is None: geom = self.reader.subarray.tel[self._base_tel].camera.geometry imsum = np.zeros(shape=geom.pix_x.shape, dtype=np.float64) disp = CameraDisplay(geom, title=geom.camera_name) disp.add_colorbar() disp.cmap = "viridis" if len(event.dl0.tel.keys()) <= 2: continue imsum[:] = 0 for telid in event.dl0.tel.keys(): imsum += event.dl1.tel[telid].image self.log.info( "event={} ntels={} energy={}".format( event.index.event_id, len(event.dl0.tel.keys()), event.simulation.shower.energy, ) ) disp.image = imsum plt.pause(0.1) if self.output_suffix != "": filename = "{:020d}{}".format(event.index.event_id, self.output_suffix) self.log.info(f"saving: '{filename}'") plt.savefig(filename)
def plot_allparam_map(df): nc = 4 nr = 2 f,axs = plt.subplots(ncols=nc,nrows=nr,figsize=(12,6)) # ~ table = Table.read('./NewNectarCam.camgeom.fits.gz') # ~ geom = CameraGeometry.from_table(table) # ~ geom.rotate(10.3*u.deg) geom = CameraGeometry.from_name("NectarCam-002") for ii,key in enumerate(df): # ~ for ii,key in enumerate(['Light I', 'ped mean', 'ped width', 'res', 'Mu2', 'gain']): ax = axs[ii%nr,ii//nr%nc] blankam = np.zeros(1855) blankam[pix_ids]=df[key] disp = CameraDisplay(geom,title=key,ax=ax) disp.add_colorbar(ax=ax) disp.set_limits_minmax(zmin=np.min(df[key])*.99,zmax=np.max(df[key])*1.01) disp.image = blankam ax.set_ylim(-0.8,0.8) ax.set_xlim(-0.5,0.4) plt.show() return
psi='35d') image, sig, bg = toymodel.make_toymodel_shower_image(geom, model.pdf, intensity=50, nsb_level_pe=1000) # Apply image cleaning cleanmask = tailcuts_clean(geom, image, picture_thresh=200, boundary_thresh=100) clean = image.copy() clean[~cleanmask] = 0.0 # Calculate image parameters hillas = hillas_parameters(geom.pix_x, geom.pix_y, clean) print(hillas) # Show the camera image and overlay Hillas ellipse and clean pixels disp.image = image disp.cmap = 'PuOr' disp.highlight_pixels(cleanmask, color='black') disp.overlay_moments(hillas, color='cyan', linewidth=3) # Draw the neighbors of pixel 100 in red, and the neighbor-neighbors in # green for ii in geom.neighbors[130]: draw_neighbors(geom, ii, color='green') draw_neighbors(geom, 130, color='cyan', lw=2) plt.show()
def main(): args = parser.parse_args() event_generator = fact_event_generator( args.inputfile, args.drsfile, allowed_triggers={4}, ) fig = plt.figure(figsize=(12, 6)) ax1 = fig.add_axes([0, 0, 0.4, 1]) ax1.set_axis_off() divider = make_axes_locatable(ax1) cax1 = divider.append_axes('right', size="5%", pad=0.05) ax2 = fig.add_axes([0.5, 0.0, 0.4, 1]) ax2.set_axis_off() divider = make_axes_locatable(ax2) cax2 = divider.append_axes('right', size="5%", pad=0.05) geom = CameraGeometry.from_name('FACT') disp1 = CameraDisplay(geom, ax=ax1) disp1.add_colorbar(cax=cax1, label='Photons') disp2 = CameraDisplay(geom, ax=ax2) disp2.add_colorbar(cax=cax2, label='ArrivalTime') ax1.set_title('Photons') ax2.set_title('Peak Position') for e in event_generator: dl1_calibrator.calibrate(e) image = e.dl1.tel[0].image[0] cleaning_mask = tailcuts_clean(geom, image, 5, 3.5) if sum(cleaning_mask) < 15: continue hillas_container = hillas_parameters( geom.pix_x[cleaning_mask], geom.pix_y[cleaning_mask], image[cleaning_mask], ) disp1.overlay_moments(hillas_container, linewidth=1.5, color='c', with_label=False) disp1.highlight_pixels(cleaning_mask) disp1.image = e.dl1.tel[0].image[0] disp2.image = e.dl1.tel[0].peakpos[0] for disp in (disp1, disp2): disp.highlight_pixels(cleaning_mask, color='r', linewidth=1.5) fig.suptitle('FACT Event {}'.format(e.trig.gps_time.iso)) plt.pause(0.01) input('Press enter for next event')
def nsb_rate( files, aux_basepath, dark_histo_file, param_file, template_filename, output=None, plot="show", plot_nsb_range=None, norm="log", plot_baselines=False, disable_bar=False, max_events=None, n_skip=10, stars=True, bias_resistance=1e4 * u.Ohm, cell_capacitance=5e-14 * u.Farad ): files = np.atleast_1d(files) if len(files) == 1 and not files[0].endswith('.fz'): table = Table.read(files[0])[:max_events] data = dict(table) data['nsb_rate'] = np.array(data['nsb_rate']) * u.GHz else: dark_histo = Histogram1D.load(dark_histo_file) n_pixel = len(DigiCam.geometry.neighbors) pixels = np.arange(n_pixel, dtype=int) with open(param_file) as file: pulse_template = NormalizedPulseTemplate.load(template_filename) pulse_area = pulse_template.integral() * u.ns charge_to_amplitude = pulse_template.compute_charge_amplitude_ratio(7, 4) calibration_parameters = yaml.load(file) gain_integral = np.array(calibration_parameters['gain']) gain_amplitude = gain_integral * charge_to_amplitude crosstalk = np.array(calibration_parameters['mu_xt']) events = calibration_event_stream(files, max_events=max_events, disable_bar=disable_bar) events = add_slow_data_calibration( events, basepath=aux_basepath, aux_services=('DriveSystem', ) ) data = { "baseline": [], "nsb_rate": [], "good_pixels_mask": [], "timestamp": [], "event_id": [], "az": [], "el": [], } bad_pixels = get_bad_pixels( calib_file=param_file, nsigma_gain=5, nsigma_elecnoise=5, dark_histo=dark_histo_file, nsigma_dark=8, plot=None, output=None ) events_skipped = 0 for event in events: if event.event_type.INTERNAL not in event.event_type: continue events_skipped += 1 if events_skipped < n_skip: continue events_skipped = 0 data['baseline'].append(event.data.digicam_baseline) baseline_shift = event.data.digicam_baseline - dark_histo.mean() rate = _compute_nsb_rate( baseline_shift=baseline_shift, gain=gain_amplitude, pulse_area=pulse_area, crosstalk=crosstalk, bias_resistance=bias_resistance, cell_capacitance=cell_capacitance ) bad_pixels_event = np.unique(np.hstack( ( bad_pixels, pixels[rate < 0], pixels[rate > 5 * u.GHz] ) )) avg_matrix = _get_average_matrix_bad_pixels( DigiCam.geometry, bad_pixels_event ) good_pixels_mask = np.ones(n_pixel, dtype=bool) good_pixels_mask[bad_pixels_event] = False good_pixels = pixels[good_pixels_mask] rate[bad_pixels_event] = avg_matrix[bad_pixels_event, :].dot( rate[good_pixels] ) data['good_pixels_mask'].append(good_pixels_mask) data['timestamp'].append(event.data.local_time) data['event_id'].append(event.event_id) data['nsb_rate'].append(rate) data['az'].append(event.slow_data.DriveSystem.current_position_az) data['el'].append(event.slow_data.DriveSystem.current_position_el) data['nsb_rate'] = np.array(data['nsb_rate']) * u.GHz if output is not None: table = Table(data) if os.path.isfile(output): os.remove(output) table.write(output, format='fits') time_obs = Time( np.array(data['timestamp'], dtype=np.float64) * 1e-9, format='unix' ) if plot_baselines: fig2, (ax1, ax2) = plt.subplots(2, 1, figsize=(16, 8), dpi=50) baseline_std = np.std(data['baseline'], axis=0) ax1.hist(baseline_std, 100) ax1.set_xlabel('std(baseline) [LSB]') # pixels_shown = np.arange(len(baseline_std))[baseline_std > 10] pixels_shown = [834,] ax2.plot_date( time_obs.to_datetime(), data['baseline'][:, pixels_shown], '-' ) ax2.set_xlabel('time') ax2.set_ylabel('baseline [LSB]') plt.tight_layout() plt.show() plt.close(fig2) az_obs = np.array(data['az']) * u.deg el_obs = np.array(data['el']) * u.deg n_event = len(data['timestamp']) fig1, ax = plt.subplots(1, 1, figsize=(16, 12), dpi=50) date = datetime.fromtimestamp(data['timestamp'][0]*1e-9) date_str = date.strftime("%H:%M:%S") display = CameraDisplay( DigiCam.geometry, ax=ax, norm=norm, title='NSB rate [GHz], t=' + date_str ) rate_ghz = np.array(data['nsb_rate'][0].to(u.GHz).value) display.image = rate_ghz if plot_nsb_range is None: min_range_rate = np.max([np.min(rate_ghz), 50e-3]) plot_nsb_range = (min_range_rate, np.max(rate_ghz)) display.set_limits_minmax(*plot_nsb_range) display.add_colorbar(ax=ax) bad_pixels = np.arange( len(data['good_pixels_mask'][0]) )[~data['good_pixels_mask'][0]] display.highlight_pixels(bad_pixels, color='r', linewidth=2) display.axes.set_xlim([-500., 500.]) display.axes.set_ylim([-500., 500.]) plt.tight_layout() if stars is True: stars_az, stars_alt, stars_pmag = get_stars_in_fov( az_obs[0], el_obs[0], time_obs ) stars_x, stars_y = transform_azel_to_xy( stars_az, stars_alt, az_obs, el_obs ) point_stars = [] for index_star in range(len(stars_pmag)): point_star, = ax.plot( stars_x[index_star, 0], stars_y[index_star, 0], 'ok', ms=20-2*stars_pmag[index_star], mew=3, mfc='None' ) point_stars.append(point_star) def update(i, display): print('frame', i, '/', len(data['timestamp'])) display.image = data['nsb_rate'][i].to(u.GHz).value date = datetime.fromtimestamp(data['timestamp'][i] * 1e-9) date_str = date.strftime("%H:%M:%S") display.axes.set_title('NSB rate [GHz], t=' + date_str) bad_pixels = np.arange( len(data['good_pixels_mask'][i]) )[~data['good_pixels_mask'][i]] display.highlight_pixels( bad_pixels, color='r', linewidth=2 ) if stars is True: for index_star in range(len(stars_pmag)): point_stars[index_star].set_xdata( stars_x[index_star, i] ) point_stars[index_star].set_ydata( stars_y[index_star, i] ) anim = FuncAnimation( fig1, update, frames=len(data['timestamp']), interval=20, fargs=(display, ) ) Writer = animation.writers['ffmpeg'] writer = Writer(fps=50, metadata=dict(artist='Y. Renier'), bitrate=4000, codec='h263p') output_path = os.path.dirname(plot) if plot == "show" or \ (output_path != "" and 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') display.enable_pixel_picker() plt.show() else: anim.save(plot, writer=writer) print(plot, 'created') plt.close(fig1)
import numpy as np from matplotlib import pyplot as plt from ctapipe.instrument import CameraDescription, CameraGeometry from ctapipe.visualization import CameraDisplay if __name__ == "__main__": plt.style.use("bmh") camera_names = CameraDescription.get_known_camera_names() n_tels = len(camera_names) n_rows = np.trunc(np.sqrt(n_tels)).astype(int) n_cols = np.ceil(n_tels / n_rows).astype(int) plt.figure(figsize=(15, 6)) for ii, name in enumerate(sorted(camera_names)): print("plotting", name) geom = CameraGeometry.from_name(name) ax = plt.subplot(n_rows, n_cols, ii + 1) disp = CameraDisplay(geom) disp.image = np.random.uniform(size=geom.pix_id.shape) disp.cmap = "viridis" plt.xlabel("") plt.ylabel("") plt.tight_layout() plt.show()
def start(self): disp = None for event in tqdm( self.event_source, desc=f"Tel{self.tel}", total=self.event_source.max_events, disable=~self.progress, ): self.log.debug(event.trigger) self.log.debug(f"Energy: {event.simulation.shower.energy}") self.calibrator(event) if disp is None: geom = self.event_source.subarray.tel[self.tel].camera.geometry self.log.info(geom) disp = CameraDisplay(geom) # disp.enable_pixel_picker() disp.add_colorbar() if self.display: plt.show(block=False) # display the event disp.axes.set_title("CT{:03d} ({}), event {:06d}".format( self.tel, geom.camera_name, event.index.event_id)) if self.samples: # display time-varying event data = event.dl0.tel[self.tel].waveform for ii in range(data.shape[1]): disp.image = data[:, ii] disp.set_limits_percent(70) plt.suptitle(f"Sample {ii:03d}") if self.display: plt.pause(self.delay) if self.write: plt.savefig( f"CT{self.tel:03d}_EV{event.index.event_id:10d}" f"_S{ii:02d}.png") else: # display integrated event: im = event.dl1.tel[self.tel].image if self.clean: mask = tailcuts_clean(geom, im, picture_thresh=10, boundary_thresh=7) im[~mask] = 0.0 disp.image = im if self.hillas: try: ellipses = disp.axes.findobj(Ellipse) if len(ellipses) > 0: ellipses[0].remove() params = hillas_parameters(geom, image=im) disp.overlay_moments(params, color="pink", lw=3, with_label=False) except HillasParameterizationError: pass if self.display: plt.pause(self.delay) if self.write: plt.savefig( f"CT{self.tel:03d}_EV{event.index.event_id:010d}.png") self.log.info("FINISHED READING DATA FILE") if disp is None: self.log.warning( "No events for tel {} were found in {}. Try a " "different EventIO file or another telescope".format( self.tel, self.infile))
def check_interleave_pedestal_cleaning(path_list, calib_time_file, calib_file, max_events=10000): signal_place_after_clean = np.zeros(1855) sum_ped_ev = 0 alive_ped_ev = 0 for path in path_list: print(path) r0_r1_calibrator = LSTR0Corrections(pedestal_path=None, r1_sample_start=3, r1_sample_end=39) r1_dl1_calibrator = LSTCameraCalibrator(calibration_path=calib_file, time_calibration_path=calib_time_file, extractor_product="LocalPeakWindowSum", config=charge_config, allowed_tels=[1]) reader = LSTEventSource(input_url=path, max_events=max_events) for i, ev in enumerate(reader): r0_r1_calibrator.calibrate(ev) if i%10000 == 0: print(ev.r0.event_id) if ev.lst.tel[1].evt.tib_masked_trigger == 32: sum_ped_ev += 1 r1_dl1_calibrator(ev) img = ev.dl1.tel[1].image geom = ev.inst.subarray.tel[1].camera clean = tailcuts_clean( geom, img, picture_thresh=6, boundary_thresh=3, min_number_picture_neighbors=1, keep_isolated_pixels=False ) cleaned = img.copy() cleaned[~clean] = 0.0 signal_place_after_clean[np.where(clean == True)] += 1 if np.sum(cleaned>0) > 0: alive_ped_ev += 1 fig, ax = plt.subplots(figsize=(8, 8)) geom = ev.inst.subarray.tel[1].camera disp0 = CameraDisplay(geom, ax=ax) disp0.image = signal_place_after_clean/sum_ped_ev disp0.add_colorbar(ax=ax, label="N times signal remain after cleaning") disp0.cmap = 'gnuplot2' ax.set_title("{} \n {}/{}".format(path.split("/")[-1][8:21], alive_ped_ev, sum_ped_ev)) print(path.split("/")[-1][8:21]) print("{}/{}".format(alive_ped_ev, sum_ped_ev)) ax.set_xlabel(" ") ax.set_ylabel(" ") plt.tight_layout() plt.show() return signal_place_after_clean, sum_ped_ev
def plot(event, telid, chan, extractor_name): # Extract required images dl0 = event.dl0.tel[telid].waveform[chan] t_pe = event.mc.tel[telid].photo_electron_image dl1 = event.dl1.tel[telid].image[chan] max_time = np.unravel_index(np.argmax(dl0), dl0.shape)[1] max_charges = np.max(dl0, axis=1) max_pix = int(np.argmax(max_charges)) min_pix = int(np.argmin(max_charges)) geom = event.inst.subarray.tel[telid].camera nei = geom.neighbors # Get Neighbours max_pixel_nei = nei[max_pix] min_pixel_nei = nei[min_pix] # Draw figures ax_max_nei = {} ax_min_nei = {} fig_waveforms = plt.figure(figsize=(18, 9)) fig_waveforms.subplots_adjust(hspace=.5) fig_camera = plt.figure(figsize=(15, 12)) ax_max_pix = fig_waveforms.add_subplot(4, 2, 1) ax_min_pix = fig_waveforms.add_subplot(4, 2, 2) ax_max_nei[0] = fig_waveforms.add_subplot(4, 2, 3) ax_min_nei[0] = fig_waveforms.add_subplot(4, 2, 4) ax_max_nei[1] = fig_waveforms.add_subplot(4, 2, 5) ax_min_nei[1] = fig_waveforms.add_subplot(4, 2, 6) ax_max_nei[2] = fig_waveforms.add_subplot(4, 2, 7) ax_min_nei[2] = fig_waveforms.add_subplot(4, 2, 8) ax_img_nei = fig_camera.add_subplot(2, 2, 1) ax_img_max = fig_camera.add_subplot(2, 2, 2) ax_img_true = fig_camera.add_subplot(2, 2, 3) ax_img_cal = fig_camera.add_subplot(2, 2, 4) # Draw max pixel traces ax_max_pix.plot(dl0[max_pix]) ax_max_pix.set_xlabel("Time (ns)") ax_max_pix.set_ylabel("DL0 Samples (ADC)") ax_max_pix.set_title( f'(Max) Pixel: {max_pix}, True: {t_pe[max_pix]}, ' f'Measured = {dl1[max_pix]:.3f}' ) max_ylim = ax_max_pix.get_ylim() for i, ax in ax_max_nei.items(): if len(max_pixel_nei) > i: pix = max_pixel_nei[i] ax.plot(dl0[pix]) ax.set_xlabel("Time (ns)") ax.set_ylabel("DL0 Samples (ADC)") ax.set_title( "(Max Nei) Pixel: {}, True: {}, Measured = {:.3f}" .format(pix, t_pe[pix], dl1[pix]) ) ax.set_ylim(max_ylim) # Draw min pixel traces ax_min_pix.plot(dl0[min_pix]) ax_min_pix.set_xlabel("Time (ns)") ax_min_pix.set_ylabel("DL0 Samples (ADC)") ax_min_pix.set_title( f'(Min) Pixel: {min_pix}, True: {t_pe[min_pix]}, ' f'Measured = {dl1[min_pix]:.3f}' ) ax_min_pix.set_ylim(max_ylim) for i, ax in ax_min_nei.items(): if len(min_pixel_nei) > i: pix = min_pixel_nei[i] ax.plot(dl0[pix]) ax.set_xlabel("Time (ns)") ax.set_ylabel("DL0 Samples (ADC)") ax.set_title( f'(Min Nei) Pixel: {pix}, True: {t_pe[pix]}, ' f'Measured = {dl1[pix]:.3f}' ) ax.set_ylim(max_ylim) # Draw cameras nei_camera = np.zeros_like(max_charges, dtype=np.int) nei_camera[min_pixel_nei] = 2 nei_camera[min_pix] = 1 nei_camera[max_pixel_nei] = 3 nei_camera[max_pix] = 4 camera = CameraDisplay(geom, ax=ax_img_nei) camera.image = nei_camera ax_img_nei.set_title("Neighbour Map") ax_img_nei.annotate( f"Pixel: {max_pix}", xy=(geom.pix_x.value[max_pix], geom.pix_y.value[max_pix]), xycoords='data', xytext=(0.05, 0.98), textcoords='axes fraction', arrowprops=dict(facecolor='red', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top' ) ax_img_nei.annotate( f"Pixel: {min_pix}", xy=(geom.pix_x.value[min_pix], geom.pix_y.value[min_pix]), xycoords='data', xytext=(0.05, 0.94), textcoords='axes fraction', arrowprops=dict(facecolor='orange', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top' ) camera = CameraDisplay(geom, ax=ax_img_max) camera.image = dl0[:, max_time] camera.add_colorbar(ax=ax_img_max, label="DL0 Samples (ADC)") ax_img_max.set_title(f"Max Timeslice (T = {max_time})") ax_img_max.annotate( f"Pixel: {max_pix}", xy=(geom.pix_x.value[max_pix], geom.pix_y.value[max_pix]), xycoords='data', xytext=(0.05, 0.98), textcoords='axes fraction', arrowprops=dict(facecolor='red', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top' ) ax_img_max.annotate( f"Pixel: {min_pix}", xy=(geom.pix_x.value[min_pix], geom.pix_y.value[min_pix]), xycoords='data', xytext=(0.05, 0.94), textcoords='axes fraction', arrowprops=dict(facecolor='orange', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top' ) camera = CameraDisplay(geom, ax=ax_img_true) camera.image = t_pe camera.add_colorbar(ax=ax_img_true, label="True Charge (p.e.)") ax_img_true.set_title("True Charge") ax_img_true.annotate( f"Pixel: {max_pix}", xy=(geom.pix_x.value[max_pix], geom.pix_y.value[max_pix]), xycoords='data', xytext=(0.05, 0.98), textcoords='axes fraction', arrowprops=dict(facecolor='red', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top' ) ax_img_true.annotate( f"Pixel: {min_pix}", xy=(geom.pix_x.value[min_pix], geom.pix_y.value[min_pix]), xycoords='data', xytext=(0.05, 0.94), textcoords='axes fraction', arrowprops=dict(facecolor='orange', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top' ) camera = CameraDisplay(geom, ax=ax_img_cal) camera.image = dl1 camera.add_colorbar(ax=ax_img_cal, label="Calib Charge (Photo-electrons)") ax_img_cal.set_title(f"Charge (integrator={extractor_name})") ax_img_cal.annotate( f"Pixel: {max_pix}", xy=(geom.pix_x.value[max_pix], geom.pix_y.value[max_pix]), xycoords='data', xytext=(0.05, 0.98), textcoords='axes fraction', arrowprops=dict(facecolor='red', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top' ) ax_img_cal.annotate( f"Pixel: {min_pix}", xy=(geom.pix_x.value[min_pix], geom.pix_y.value[min_pix]), xycoords='data', xytext=(0.05, 0.94), textcoords='axes fraction', arrowprops=dict(facecolor='orange', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top' ) fig_waveforms.suptitle(f"Integrator = {extractor_name}") fig_camera.suptitle(f"Camera = {geom.cam_id}") plt.show()
def plot(self, input_file, event, telid, chan, extractor_name, nei): # Extract required images dl0 = event.dl0.tel[telid].adc_samples[chan] t_pe = event.mc.tel[telid].photo_electron_image dl1 = event.dl1.tel[telid].image[chan] max_time = np.unravel_index(np.argmax(dl0), dl0.shape)[1] max_charges = np.max(dl0, axis=1) max_pix = int(np.argmax(max_charges)) min_pix = int(np.argmin(max_charges)) geom = CameraGeometry.guess(*event.inst.pixel_pos[telid], event.inst.optical_foclen[telid]) # Get Neighbours max_pixel_nei = nei[max_pix] min_pixel_nei = nei[min_pix] # Get Windows windows = event.dl1.tel[telid].extracted_samples[chan] length = np.sum(windows, axis=1) start = np.argmax(windows, axis=1) end = start + length # Draw figures ax_max_nei = {} ax_min_nei = {} fig_waveforms = plt.figure(figsize=(18, 9)) fig_waveforms.subplots_adjust(hspace=.5) fig_camera = plt.figure(figsize=(15, 12)) ax_max_pix = fig_waveforms.add_subplot(4, 2, 1) ax_min_pix = fig_waveforms.add_subplot(4, 2, 2) ax_max_nei[0] = fig_waveforms.add_subplot(4, 2, 3) ax_min_nei[0] = fig_waveforms.add_subplot(4, 2, 4) ax_max_nei[1] = fig_waveforms.add_subplot(4, 2, 5) ax_min_nei[1] = fig_waveforms.add_subplot(4, 2, 6) ax_max_nei[2] = fig_waveforms.add_subplot(4, 2, 7) ax_min_nei[2] = fig_waveforms.add_subplot(4, 2, 8) ax_img_nei = fig_camera.add_subplot(2, 2, 1) ax_img_max = fig_camera.add_subplot(2, 2, 2) ax_img_true = fig_camera.add_subplot(2, 2, 3) ax_img_cal = fig_camera.add_subplot(2, 2, 4) # Draw max pixel traces ax_max_pix.plot(dl0[max_pix]) ax_max_pix.set_xlabel("Time (ns)") ax_max_pix.set_ylabel("DL0 Samples (ADC)") ax_max_pix.set_title("(Max) Pixel: {}, True: {}, Measured = {:.3f}" .format(max_pix, t_pe[max_pix], dl1[max_pix])) max_ylim = ax_max_pix.get_ylim() ax_max_pix.plot([start[max_pix], start[max_pix]], ax_max_pix.get_ylim(), color='r', alpha=1) ax_max_pix.plot([end[max_pix], end[max_pix]], ax_max_pix.get_ylim(), color='r', alpha=1) for i, ax in ax_max_nei.items(): if len(max_pixel_nei) > i: pix = max_pixel_nei[i] ax.plot(dl0[pix]) ax.set_xlabel("Time (ns)") ax.set_ylabel("DL0 Samples (ADC)") ax.set_title("(Max Nei) Pixel: {}, True: {}, Measured = {:.3f}" .format(pix, t_pe[pix], dl1[pix])) ax.set_ylim(max_ylim) ax.plot([start[pix], start[pix]], ax.get_ylim(), color='r', alpha=1) ax.plot([end[pix], end[pix]], ax.get_ylim(), color='r', alpha=1) # Draw min pixel traces ax_min_pix.plot(dl0[min_pix]) ax_min_pix.set_xlabel("Time (ns)") ax_min_pix.set_ylabel("DL0 Samples (ADC)") ax_min_pix.set_title("(Min) Pixel: {}, True: {}, Measured = {:.3f}" .format(min_pix, t_pe[min_pix], dl1[min_pix])) ax_min_pix.set_ylim(max_ylim) ax_min_pix.plot([start[min_pix], start[min_pix]], ax_min_pix.get_ylim(), color='r', alpha=1) ax_min_pix.plot([end[min_pix], end[min_pix]], ax_min_pix.get_ylim(), color='r', alpha=1) for i, ax in ax_min_nei.items(): if len(min_pixel_nei) > i: pix = min_pixel_nei[i] ax.plot(dl0[pix]) ax.set_xlabel("Time (ns)") ax.set_ylabel("DL0 Samples (ADC)") ax.set_title("(Min Nei) Pixel: {}, True: {}, Measured = {:.3f}" .format(pix, t_pe[pix], dl1[pix])) ax.set_ylim(max_ylim) ax.plot([start[pix], start[pix]], ax.get_ylim(), color='r', alpha=1) ax.plot([end[pix], end[pix]], ax.get_ylim(), color='r', alpha=1) # Draw cameras nei_camera = np.zeros_like(max_charges, dtype=np.int) nei_camera[min_pixel_nei] = 2 nei_camera[min_pix] = 1 nei_camera[max_pixel_nei] = 3 nei_camera[max_pix] = 4 camera = CameraDisplay(geom, ax=ax_img_nei) camera.image = nei_camera camera.cmap = plt.cm.viridis ax_img_nei.set_title("Neighbour Map") ax_img_nei.annotate("Pixel: {}".format(max_pix), xy=(geom.pix_x.value[max_pix], geom.pix_y.value[max_pix]), xycoords='data', xytext=(0.05, 0.98), textcoords='axes fraction', arrowprops=dict(facecolor='red', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top') ax_img_nei.annotate("Pixel: {}".format(min_pix), xy=(geom.pix_x.value[min_pix], geom.pix_y.value[min_pix]), xycoords='data', xytext=(0.05, 0.94), textcoords='axes fraction', arrowprops=dict(facecolor='orange', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top') camera = CameraDisplay(geom, ax=ax_img_max) camera.image = dl0[:, max_time] camera.cmap = plt.cm.viridis camera.add_colorbar(ax=ax_img_max, label="DL0 Samples (ADC)") ax_img_max.set_title("Max Timeslice (T = {})".format(max_time)) ax_img_max.annotate("Pixel: {}".format(max_pix), xy=(geom.pix_x.value[max_pix], geom.pix_y.value[max_pix]), xycoords='data', xytext=(0.05, 0.98), textcoords='axes fraction', arrowprops=dict(facecolor='red', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top') ax_img_max.annotate("Pixel: {}".format(min_pix), xy=(geom.pix_x.value[min_pix], geom.pix_y.value[min_pix]), xycoords='data', xytext=(0.05, 0.94), textcoords='axes fraction', arrowprops=dict(facecolor='orange', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top') camera = CameraDisplay(geom, ax=ax_img_true) camera.image = t_pe camera.cmap = plt.cm.viridis camera.add_colorbar(ax=ax_img_true, label="True Charge (p.e.)") ax_img_true.set_title("True Charge") ax_img_true.annotate("Pixel: {}".format(max_pix), xy=(geom.pix_x.value[max_pix], geom.pix_y.value[max_pix]), xycoords='data', xytext=(0.05, 0.98), textcoords='axes fraction', arrowprops=dict(facecolor='red', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top') ax_img_true.annotate("Pixel: {}".format(min_pix), xy=(geom.pix_x.value[min_pix], geom.pix_y.value[min_pix]), xycoords='data', xytext=(0.05, 0.94), textcoords='axes fraction', arrowprops=dict(facecolor='orange', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top') camera = CameraDisplay(geom, ax=ax_img_cal) camera.image = dl1 camera.cmap = plt.cm.viridis camera.add_colorbar(ax=ax_img_cal, label="Calib Charge (Photo-electrons)") ax_img_cal.set_title("Charge (integrator={})".format(extractor_name)) ax_img_cal.annotate("Pixel: {}".format(max_pix), xy=(geom.pix_x.value[max_pix], geom.pix_y.value[max_pix]), xycoords='data', xytext=(0.05, 0.98), textcoords='axes fraction', arrowprops=dict(facecolor='red', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top') ax_img_cal.annotate("Pixel: {}".format(min_pix), xy=(geom.pix_x.value[min_pix], geom.pix_y.value[min_pix]), xycoords='data', xytext=(0.05, 0.94), textcoords='axes fraction', arrowprops=dict(facecolor='orange', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top') fig_waveforms.suptitle("Integrator = {}".format(extractor_name)) fig_camera.suptitle("Camera = {}".format(geom.cam_id)) waveform_output_name = "e{}_t{}_c{}_extractor{}_waveform.pdf"\ .format(event.count, telid, chan, extractor_name) camera_output_name = "e{}_t{}_c{}_extractor{}_camera.pdf"\ .format(event.count, telid, chan, extractor_name) output_dir = self.output_dir if output_dir is None: output_dir = input_file.output_directory output_dir = os.path.join(output_dir, self.name) if not os.path.exists(output_dir): self.log.info("Creating directory: {}".format(output_dir)) os.makedirs(output_dir) waveform_output_path = os.path.join(output_dir, waveform_output_name) self.log.info("Saving: {}".format(waveform_output_path)) fig_waveforms.savefig(waveform_output_path, format='pdf', bbox_inches='tight') camera_output_path = os.path.join(output_dir, camera_output_name) self.log.info("Saving: {}".format(camera_output_path)) fig_camera.savefig(camera_output_path, format='pdf', bbox_inches='tight')
from ctapipe.instrument import CameraGeometry from ctapipe.visualization import CameraDisplay if __name__ == '__main__': plt.style.use('ggplot') fig = plt.figure(figsize=(12, 8)) ax = fig.add_subplot(1, 1, 1) geom = CameraGeometry.from_name('NectarCam') disp = CameraDisplay(geom, ax=ax) disp.add_colorbar() model = toymodel.generate_2d_shower_model(centroid=(0.05, 0.0), width=0.005, length=0.025, psi='35d') image, sig, bg = toymodel.make_toymodel_shower_image(geom, model.pdf, intensity=50, nsb_level_pe=20) disp.image = image mask = disp.image > 15 disp.highlight_pixels(mask, linewidth=3) plt.show()
def start(self): disp = None for event in tqdm(self.event_source, desc='Tel{}'.format(self.tel), total=self.event_source.max_events, disable=~self.progress): self.log.debug(event.trig) self.log.debug("Energy: {}".format(event.mc.energy)) self.calibrator.calibrate(event) if disp is None: geom = event.inst.subarray.tel[self.tel].camera self.log.info(geom) disp = CameraDisplay(geom) # disp.enable_pixel_picker() disp.add_colorbar() if self.display: plt.show(block=False) # display the event disp.axes.set_title('CT{:03d} ({}), event {:06d}'.format( self.tel, geom.cam_id, event.r0.event_id)) if self.samples: # display time-varying event data = event.dl0.tel[self.tel].pe_samples[self.channel] for ii in range(data.shape[1]): disp.image = data[:, ii] disp.set_limits_percent(70) plt.suptitle("Sample {:03d}".format(ii)) if self.display: plt.pause(self.delay) if self.write: plt.savefig('CT{:03d}_EV{:10d}_S{:02d}.png'.format( self.tel, event.r0.event_id, ii)) else: # display integrated event: im = event.dl1.tel[self.tel].image[self.channel] if self.clean: mask = tailcuts_clean(geom, im, picture_thresh=10, boundary_thresh=7) im[~mask] = 0.0 disp.image = im if self.hillas: try: ellipses = disp.axes.findobj(Ellipse) if len(ellipses) > 0: ellipses[0].remove() params = hillas_parameters(geom, image=im) disp.overlay_moments(params, color='pink', lw=3, with_label=False) except HillasParameterizationError: pass if self.display: plt.pause(self.delay) if self.write: plt.savefig('CT{:03d}_EV{:010d}.png'.format( self.tel, event.r0.event_id)) self.log.info("FINISHED READING DATA FILE") if disp is None: self.log.warning( 'No events for tel {} were found in {}. Try a ' 'different EventIO file or another telescope'.format( self.tel, self.infile), ) pass
def plot_pedestals(data_file, pedestal_file, run=0, plot_file=None, tel_id=1, offset_value=400, sample_size=1000): """ plot pedestal quantities quantities Parameters ---------- data_file: pedestal run pedestal_file: file with drs4 corrections run: run number of data to be corrected plot_file: name of output pdf file tel_id: id of the telescope offset_value: baseline off_set """ config = { "LSTEventSource": { "allowed_tels": [1], "LSTR0Corrections": { "drs4_pedestal_path": pedestal_file, }, } } # event_reader reader = EventSource(data_file, config=Config(config), max_events=None) t = np.linspace(2, 37, 36) # configuration for the charge integrator charge_config = Config( { "FixedWindowSum": { "window_shift": 6, "window_width": 12, "peak_index": 18, } } ) # declare the pedestal component pedestal = PedestalIntegrator( tel_id=tel_id, time_sampling_correction_path=None, sample_size=sample_size, sample_duration=1000000, charge_median_cut_outliers=[-10, 10], charge_std_cut_outliers=[-10, 10], charge_product="FixedWindowSum", config=charge_config, subarray=reader.subarray, ) for i, event in enumerate(reader): if tel_id != event.trigger.tels_with_trigger[0]: raise Exception( f"Given wrong telescope id {tel_id}, files has id {event.trigger.tels_with_trigger[0]}" ) are_pedestals_calculated = pedestal.calculate_pedestals(event) if are_pedestals_calculated: ped_data = event.mon.tel[tel_id].pedestal break camera_geometry = reader.subarray.tels[tel_id].camera.geometry camera_geometry = camera_geometry.transform_to(EngineeringCameraFrame()) if are_pedestals_calculated and plot_file is not None: with PdfPages(plot_file) as pdf: plt.rc("font", size=15) # first figure fig = plt.figure(1, figsize=(12, 24)) plt.tight_layout() n_samples = charge_config["FixedWindowSum"]["window_width"] fig.suptitle(f"Run {run}, integration on {n_samples} samples", fontsize=25) pad = 420 image = ped_data.charge_median mask = ped_data.charge_median_outliers for chan in np.arange(2): pad += 1 plt.subplot(pad) plt.tight_layout() disp = CameraDisplay(camera_geometry) mymin = np.median(image[chan]) - 2 * np.std(image[chan]) mymax = np.median(image[chan]) + 2 * np.std(image[chan]) disp.set_limits_minmax(mymin, mymax) disp.highlight_pixels(mask[chan], linewidth=2) disp.image = image[chan] disp.cmap = plt.cm.coolwarm # disp.axes.text(lposx, 0, f'{channel[chan]} pedestal [ADC]', rotation=90) plt.title(f"{channel[chan]} pedestal [ADC]") disp.add_colorbar() image = ped_data.charge_std mask = ped_data.charge_std_outliers for chan in np.arange(2): pad += 1 plt.subplot(pad) plt.tight_layout() disp = CameraDisplay(camera_geometry) mymin = np.median(image[chan]) - 2 * np.std(image[chan]) mymax = np.median(image[chan]) + 2 * np.std(image[chan]) disp.set_limits_minmax(mymin, mymax) disp.highlight_pixels(mask[chan], linewidth=2) disp.image = image[chan] disp.cmap = plt.cm.coolwarm # disp.axes.text(lposx, 0, f'{channel[chan]} pedestal std [ADC]', rotation=90) plt.title(f"{channel[chan]} pedestal std [ADC]") disp.add_colorbar() # histograms for chan in np.arange(2): mean_ped = ped_data.charge_mean[chan] ped_std = ped_data.charge_std[chan] # select good pixels select = np.logical_not(mask[chan]) # fig.suptitle(f"Run {run} channel: {channel[chan]}", fontsize=25) pad += 1 # pedestal charge plt.subplot(pad) plt.tight_layout() plt.ylabel("pixels") plt.xlabel(f"{channel[chan]} pedestal") median = np.median(mean_ped[select]) rms = np.std(mean_ped[select]) label = f"{channel[chan]} Median {median:3.2f}, std {rms:3.2f}" plt.hist(mean_ped[select], bins=50, label=label) plt.legend() pad += 1 # pedestal std plt.subplot(pad) plt.ylabel("pixels") plt.xlabel(f"{channel[chan]} pedestal std") median = np.median(ped_std[select]) rms = np.std(ped_std[select]) label = f" Median {median:3.2f}, std {rms:3.2f}" plt.hist(ped_std[select], bins=50, label=label) plt.legend() plt.subplots_adjust(top=0.94, bottom=0.04, right=0.96) pdf.savefig() plt.close() # event_reader # reader = EventSource(data_file, config=Config(config), max_events=1000) pix = 0 pad = 420 offset_value = reader.r0_r1_calibrator.offset.tel[tel_id] # plot corrected waveforms of first 8 events for i, ev in enumerate(reader): for chan in np.arange(2): if pad == 420: # new figure fig = plt.figure(ev.index.event_id * 1000, figsize=(12, 24)) fig.suptitle(f"Run {run}, pixel {pix}", fontsize=25) plt.tight_layout() pad += 1 plt.subplot(pad) # remove samples at beginning / end of waveform start = reader.r0_r1_calibrator.r1_sample_start.tel[tel_id] end = reader.r0_r1_calibrator.r1_sample_end.tel[tel_id] plt.subplots_adjust(top=0.92) label = f"event {ev.index.event_id}, {channel[chan]}: R0" plt.step( t, ev.r0.tel[tel_id].waveform[chan, pix, start:end], color="blue", label=label, ) label = "baseline correction \n + dt corr + interp. spikes" plt.step( t, ev.r1.tel[tel_id].waveform[chan, pix] + offset_value, alpha=0.5, color="green", label=label, ) plt.plot([0, 40], [offset_value, offset_value], "k--", label="offset") plt.xlabel("time sample [ns]") plt.ylabel("counts [ADC]") plt.legend() plt.ylim(200, 600) if pad == 428: pad = 420 plt.subplots_adjust(top=0.92) pdf.savefig() plt.close() if i == 8: break elif not are_pedestals_calculated: log.error("Not able to calculate pedestals or output pdf file not especified.") elif plot_file is None: log.warning("Not PDF outputfile specified.")
def finish(self): """ write fit results in h5 file and the check-plots in pdf file """ gain = np.ma.array(self.fit_parameters.T[0], mask=self.fit_error.T) quadratic_term = np.ma.array(self.fit_parameters.T[1], mask=self.fit_error.T) # give to the badly fitted pixel a median value for the B term median_quadratic_term = np.ma.median(quadratic_term, axis=0) fill_array = np.ones((constants.N_PIXELS, constants.N_GAINS)) * median_quadratic_term quadratic_term_corrected = np.ma.filled(quadratic_term, fill_array) with h5py.File(self.output_path, 'w') as hf: hf.create_dataset('gain', data=gain.T) hf.create_dataset('B_term', data=quadratic_term_corrected.T) hf.create_dataset('covariance_matrix', data=self.fit_cov_matrix) hf.create_dataset('bad_fit_mask', data=self.fit_error) # remember the camera median and the variance per run channel = ["HG", "LG"] for chan in [0, 1]: if self.signal[chan] is not None: hf.create_dataset(f'median_signal_{channel[chan]}', data=np.median(self.signal[chan], axis=0)) hf.create_dataset(f'median_variance_{channel[chan]}', data=np.median(self.variance[chan], axis=0)) hf.create_dataset(f'runs_{channel[chan]}', data=self.selected_runs[chan]) hf.create_dataset('runs', data=self.run_list) hf.create_dataset('sub_run', data=self.sub_run) # plot open pdf with PdfPages(self.plot_path) as pdf: plt.rc("font", size=15) for chan in self.gain_channels: # plot the used runs and their median camera charge fig = plt.figure((chan + 1), figsize=(8, 20)) fig.suptitle(f"{channel[chan]} channel", fontsize=25) ax = plt.subplot(2, 1, 1) ax.grid(True) ax.yaxis.set_major_locator(MaxNLocator(integer=True)) ax.xaxis.set_major_locator(MaxNLocator(integer=True)) ax.yaxis.set_major_locator(plt.MultipleLocator(1)) plt.plot(np.median(self.signal[chan], axis=0), self.selected_runs[chan], "o") plt.xlabel(r'$\mathrm{\overline{Q}-\overline{ped}}$ [ADC]') plt.ylabel(r'Runs used in the fit') plt.subplot(2, 1, 2) camera = load_camera_geometry() camera = camera.transform_to(EngineeringCameraFrame()) disp = CameraDisplay(camera) image = self.fit_parameters.T[1].T * 100 mymin = np.median(image[chan]) - 3 * np.std(image[chan]) mymax = np.median(image[chan]) + 3 * np.std(image[chan]) disp.set_limits_minmax(mymin, mymax) mask = np.where(self.fit_error[chan] == 1)[0] disp.highlight_pixels(mask, linewidth=2.5, color="green") disp.image = image[chan] disp.cmap = plt.cm.coolwarm plt.title(f"{channel[chan]} Fitted B values [%]") disp.add_colorbar() plt.tight_layout() pdf.savefig() # plot the fit results and residuals for four arbitrary pixels fig = plt.figure((chan + 1) * 10, figsize=(11, 22)) fig.suptitle(f"{channel[chan]} channel", fontsize=25) pad = 0 for pix in [0, 600, 1200, 1800]: pad += 1 plt.subplot(4, 2, pad) plt.grid(which='minor') mask = self.unusable_pixels[chan][pix] sig = np.ma.array(self.signal[chan][pix], mask=mask).compressed() var = np.ma.array(self.variance[chan][pix], mask=mask).compressed() popt = self.fit_parameters[chan, pix] # plot points plt.plot(sig, var, 'o', color="C0") # plot fit min_x = min(1000, np.min(sig) * 0.9) max_x = max(10000, np.max(sig) * 1.1) x = np.arange(np.min(sig), np.max(sig)) plt.plot(x, quadratic_fit(x, *popt), '--', color="C1", label=f'Pixel {pix}:\ng={popt[0]:5.2f} [ADC/pe] , B={popt[1]:5.3f}') plt.xlim(min_x, max_x) plt.xlabel('Q-ped [ADC]') plt.ylabel(r'$\mathrm{\sigma_Q^2-\sigma_{ped}^2}$ [$ADC^2$]') plt.xscale('log') plt.yscale('log') plt.legend() # plot residuals pad += 1 plt.subplot(4, 2, pad) plt.grid(which='both', axis='both') popt = self.fit_parameters[chan, pix] plt.plot(sig, (quadratic_fit(sig, *popt) - var) / var * 100, 'o', color="C0") plt.xlim(min_x, max_x) plt.xscale('log') plt.ylabel('fit residuals %') plt.xlabel('Q-ped [ADC]') plt.hlines(0, 0, np.max(sig), linestyle='dashed', color="black") plt.tight_layout() pdf.savefig()
def plot(event, telid, chan, extractor_name): # Extract required images dl0 = event.dl0.tel[telid].pe_samples[chan] t_pe = event.mc.tel[telid].photo_electron_image dl1 = event.dl1.tel[telid].image[chan] max_time = np.unravel_index(np.argmax(dl0), dl0.shape)[1] max_charges = np.max(dl0, axis=1) max_pix = int(np.argmax(max_charges)) min_pix = int(np.argmin(max_charges)) geom = event.inst.subarray.tel[telid].camera nei = geom.neighbors # Get Neighbours max_pixel_nei = nei[max_pix] min_pixel_nei = nei[min_pix] # Get Windows windows = event.dl1.tel[telid].extracted_samples[chan] length = np.sum(windows, axis=1) start = np.argmax(windows, axis=1) end = start + length - 1 # Draw figures ax_max_nei = {} ax_min_nei = {} fig_waveforms = plt.figure(figsize=(18, 9)) fig_waveforms.subplots_adjust(hspace=.5) fig_camera = plt.figure(figsize=(15, 12)) ax_max_pix = fig_waveforms.add_subplot(4, 2, 1) ax_min_pix = fig_waveforms.add_subplot(4, 2, 2) ax_max_nei[0] = fig_waveforms.add_subplot(4, 2, 3) ax_min_nei[0] = fig_waveforms.add_subplot(4, 2, 4) ax_max_nei[1] = fig_waveforms.add_subplot(4, 2, 5) ax_min_nei[1] = fig_waveforms.add_subplot(4, 2, 6) ax_max_nei[2] = fig_waveforms.add_subplot(4, 2, 7) ax_min_nei[2] = fig_waveforms.add_subplot(4, 2, 8) ax_img_nei = fig_camera.add_subplot(2, 2, 1) ax_img_max = fig_camera.add_subplot(2, 2, 2) ax_img_true = fig_camera.add_subplot(2, 2, 3) ax_img_cal = fig_camera.add_subplot(2, 2, 4) # Draw max pixel traces ax_max_pix.plot(dl0[max_pix]) ax_max_pix.set_xlabel("Time (ns)") ax_max_pix.set_ylabel("DL0 Samples (ADC)") ax_max_pix.set_title("(Max) Pixel: {}, True: {}, Measured = {:.3f}" .format(max_pix, t_pe[max_pix], dl1[max_pix])) max_ylim = ax_max_pix.get_ylim() ax_max_pix.plot([start[max_pix], start[max_pix]], ax_max_pix.get_ylim(), color='r', alpha=1) ax_max_pix.plot([end[max_pix], end[max_pix]], ax_max_pix.get_ylim(), color='r', alpha=1) for i, ax in ax_max_nei.items(): if len(max_pixel_nei) > i: pix = max_pixel_nei[i] ax.plot(dl0[pix]) ax.set_xlabel("Time (ns)") ax.set_ylabel("DL0 Samples (ADC)") ax.set_title("(Max Nei) Pixel: {}, True: {}, Measured = {:.3f}" .format(pix, t_pe[pix], dl1[pix])) ax.set_ylim(max_ylim) ax.plot([start[pix], start[pix]], ax.get_ylim(), color='r', alpha=1) ax.plot([end[pix], end[pix]], ax.get_ylim(), color='r', alpha=1) # Draw min pixel traces ax_min_pix.plot(dl0[min_pix]) ax_min_pix.set_xlabel("Time (ns)") ax_min_pix.set_ylabel("DL0 Samples (ADC)") ax_min_pix.set_title("(Min) Pixel: {}, True: {}, Measured = {:.3f}" .format(min_pix, t_pe[min_pix], dl1[min_pix])) ax_min_pix.set_ylim(max_ylim) ax_min_pix.plot([start[min_pix], start[min_pix]], ax_min_pix.get_ylim(), color='r', alpha=1) ax_min_pix.plot([end[min_pix], end[min_pix]], ax_min_pix.get_ylim(), color='r', alpha=1) for i, ax in ax_min_nei.items(): if len(min_pixel_nei) > i: pix = min_pixel_nei[i] ax.plot(dl0[pix]) ax.set_xlabel("Time (ns)") ax.set_ylabel("DL0 Samples (ADC)") ax.set_title("(Min Nei) Pixel: {}, True: {}, Measured = {:.3f}" .format(pix, t_pe[pix], dl1[pix])) ax.set_ylim(max_ylim) ax.plot([start[pix], start[pix]], ax.get_ylim(), color='r', alpha=1) ax.plot([end[pix], end[pix]], ax.get_ylim(), color='r', alpha=1) # Draw cameras nei_camera = np.zeros_like(max_charges, dtype=np.int) nei_camera[min_pixel_nei] = 2 nei_camera[min_pix] = 1 nei_camera[max_pixel_nei] = 3 nei_camera[max_pix] = 4 camera = CameraDisplay(geom, ax=ax_img_nei) camera.image = nei_camera ax_img_nei.set_title("Neighbour Map") ax_img_nei.annotate("Pixel: {}".format(max_pix), xy=(geom.pix_x.value[max_pix], geom.pix_y.value[max_pix]), xycoords='data', xytext=(0.05, 0.98), textcoords='axes fraction', arrowprops=dict(facecolor='red', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top') ax_img_nei.annotate("Pixel: {}".format(min_pix), xy=(geom.pix_x.value[min_pix], geom.pix_y.value[min_pix]), xycoords='data', xytext=(0.05, 0.94), textcoords='axes fraction', arrowprops=dict(facecolor='orange', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top') camera = CameraDisplay(geom, ax=ax_img_max) camera.image = dl0[:, max_time] camera.add_colorbar(ax=ax_img_max, label="DL0 Samples (ADC)") ax_img_max.set_title("Max Timeslice (T = {})".format(max_time)) ax_img_max.annotate("Pixel: {}".format(max_pix), xy=(geom.pix_x.value[max_pix], geom.pix_y.value[max_pix]), xycoords='data', xytext=(0.05, 0.98), textcoords='axes fraction', arrowprops=dict(facecolor='red', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top') ax_img_max.annotate("Pixel: {}".format(min_pix), xy=(geom.pix_x.value[min_pix], geom.pix_y.value[min_pix]), xycoords='data', xytext=(0.05, 0.94), textcoords='axes fraction', arrowprops=dict(facecolor='orange', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top') camera = CameraDisplay(geom, ax=ax_img_true) camera.image = t_pe camera.add_colorbar(ax=ax_img_true, label="True Charge (p.e.)") ax_img_true.set_title("True Charge") ax_img_true.annotate("Pixel: {}".format(max_pix), xy=(geom.pix_x.value[max_pix], geom.pix_y.value[max_pix]), xycoords='data', xytext=(0.05, 0.98), textcoords='axes fraction', arrowprops=dict(facecolor='red', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top') ax_img_true.annotate("Pixel: {}".format(min_pix), xy=(geom.pix_x.value[min_pix], geom.pix_y.value[min_pix]), xycoords='data', xytext=(0.05, 0.94), textcoords='axes fraction', arrowprops=dict(facecolor='orange', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top') camera = CameraDisplay(geom, ax=ax_img_cal) camera.image = dl1 camera.add_colorbar(ax=ax_img_cal, label="Calib Charge (Photo-electrons)") ax_img_cal.set_title("Charge (integrator={})".format(extractor_name)) ax_img_cal.annotate("Pixel: {}".format(max_pix), xy=(geom.pix_x.value[max_pix], geom.pix_y.value[max_pix]), xycoords='data', xytext=(0.05, 0.98), textcoords='axes fraction', arrowprops=dict(facecolor='red', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top') ax_img_cal.annotate("Pixel: {}".format(min_pix), xy=(geom.pix_x.value[min_pix], geom.pix_y.value[min_pix]), xycoords='data', xytext=(0.05, 0.94), textcoords='axes fraction', arrowprops=dict(facecolor='orange', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top') fig_waveforms.suptitle("Integrator = {}".format(extractor_name)) fig_camera.suptitle("Camera = {}".format(geom.cam_id)) plt.show()
# just to directly get the cam geom subarray = SimTelEventSource(input_url=path).subarray geom = subarray.tel[1].camera.geometry fig, ax = plt.subplots() im_disp = CameraDisplay(geom, ax=ax) fig.show() im_disp.add_colorbar() for e in SimTelFile(path).iter_mc_events(): true_pe = e['photoelectrons'].get(0) if true_pe is not None: mc_shower = e['mc_shower'] energy = mc_shower['energy'] event_id = e['event_id'] pe = true_pe['photoelectrons'] time = np.empty(1440) time[true_pe['pixel_id']] = true_pe['time'] max_pe = int(np.max(pe)) im_disp.axes.set_title(f'{event_id}: {energy:.2f} TeV') im_disp.image = pe if max_pe >= 100 and max_pe < 1000: plt.savefig(f"build/true_pe_{max_pe:03d}.png", dpi=500) plt.savefig("build/true_pe.png", dpi=500)
def plot_pedestals(data_file, pedestal_file, run=0, plot_file="none", tel_id=1, offset_value=400): """ plot pedestal quantities quantities Parameters ---------- data_file: pedestal run pedestal_file: file with drs4 corrections run: run number of data to be corrected plot_file: name of output pdf file tel_id: id of the telescope offset_value: baseline off_set """ # plot open pdf if plot_file != "none": pp = PdfPages(plot_file) plt.rc('font', size=15) # r0 calibrator r0_calib = LSTR0Corrections(pedestal_path=pedestal_file, offset=offset_value, tel_id=tel_id) # event_reader reader = event_source(data_file, max_events=1000) t = np.linspace(2, 37, 36) # configuration for the charge integrator charge_config = Config( {"FixedWindowSum": { "window_start": 12, "window_width": 12, }}) # declare the pedestal component pedestal = PedestalIntegrator(tel_id=tel_id, sample_size=1000, sample_duration=1000000, charge_median_cut_outliers=[-10, 10], charge_std_cut_outliers=[-10, 10], charge_product="FixedWindowSum", config=charge_config, subarray=reader.subarray) for i, event in enumerate(reader): if tel_id != event.r0.tels_with_data[0]: raise Exception( f"Given wrong telescope id {tel_id}, files has id {event.r0.tels_with_data[0]}" ) # move from R0 to R1 r0_calib.calibrate(event) ok = pedestal.calculate_pedestals(event) if ok: ped_data = event.mon.tel[tel_id].pedestal break camera_geometry = reader.subarray.tels[tel_id].camera.geometry camera_geometry = camera_geometry.transform_to(EngineeringCameraFrame()) # plot open pdf if plot_file != "none": pp = PdfPages(plot_file) plt.rc('font', size=15) ### first figure fig = plt.figure(1, figsize=(12, 24)) plt.tight_layout() n_samples = charge_config["FixedWindowSum"]['window_width'] fig.suptitle(f"Run {run}, integration on {n_samples} samples", fontsize=25) pad = 420 image = ped_data.charge_median mask = ped_data.charge_median_outliers for chan in (np.arange(2)): pad += 1 plt.subplot(pad) plt.tight_layout() disp = CameraDisplay(camera_geometry) mymin = np.median(image[chan]) - 2 * np.std(image[chan]) mymax = np.median(image[chan]) + 2 * np.std(image[chan]) disp.set_limits_minmax(mymin, mymax) disp.highlight_pixels(mask[chan], linewidth=2) disp.image = image[chan] disp.cmap = plt.cm.coolwarm # disp.axes.text(lposx, 0, f'{channel[chan]} pedestal [ADC]', rotation=90) plt.title(f'{channel[chan]} pedestal [ADC]') disp.add_colorbar() image = ped_data.charge_std mask = ped_data.charge_std_outliers for chan in (np.arange(2)): pad += 1 plt.subplot(pad) plt.tight_layout() disp = CameraDisplay(camera_geometry) mymin = np.median(image[chan]) - 2 * np.std(image[chan]) mymax = np.median(image[chan]) + 2 * np.std(image[chan]) disp.set_limits_minmax(mymin, mymax) disp.highlight_pixels(mask[chan], linewidth=2) disp.image = image[chan] disp.cmap = plt.cm.coolwarm # disp.axes.text(lposx, 0, f'{channel[chan]} pedestal std [ADC]', rotation=90) plt.title(f'{channel[chan]} pedestal std [ADC]') disp.add_colorbar() ### histograms for chan in np.arange(2): mean_ped = ped_data.charge_mean[chan] ped_std = ped_data.charge_std[chan] # select good pixels select = np.logical_not(mask[chan]) #fig.suptitle(f"Run {run} channel: {channel[chan]}", fontsize=25) pad += 1 # pedestal charge plt.subplot(pad) plt.tight_layout() plt.ylabel('pixels') plt.xlabel(f'{channel[chan]} pedestal') median = np.median(mean_ped[select]) rms = np.std(mean_ped[select]) label = f"{channel[chan]} Median {median:3.2f}, std {rms:3.2f}" plt.hist(mean_ped[select], bins=50, label=label) plt.legend() pad += 1 # pedestal std plt.subplot(pad) plt.ylabel('pixels') plt.xlabel(f'{channel[chan]} pedestal std') median = np.median(ped_std[select]) rms = np.std(ped_std[select]) label = f" Median {median:3.2f}, std {rms:3.2f}" plt.hist(ped_std[select], bins=50, label=label) plt.legend() plt.subplots_adjust(top=0.94) if plot_file != "none": pp.savefig() pix = 0 pad = 420 # plot corrected waveforms of first 8 events for i, ev in enumerate(reader): for chan in np.arange(2): if pad == 420: # new figure fig = plt.figure(ev.index.event_id, figsize=(12, 24)) fig.suptitle(f"Run {run}, pixel {pix}", fontsize=25) plt.tight_layout() pad += 1 plt.subplot(pad) plt.subplots_adjust(top=0.92) label = f"event {ev.index.event_id}, {channel[chan]}: R0" plt.step(t, ev.r0.tel[tel_id].waveform[chan, pix, 2:38], color="blue", label=label) r0_calib.subtract_pedestal(ev, tel_id) label = "+ pedestal substraction" plt.step(t, ev.r1.tel[tel_id].waveform[chan, pix, 2:38], color="red", alpha=0.5, label=label) r0_calib.time_lapse_corr(ev, tel_id) r0_calib.interpolate_spikes(ev, tel_id) label = "+ dt corr + interp. spikes" plt.step(t, ev.r1.tel[tel_id].waveform[chan, pix, 2:38], alpha=0.5, color="green", label=label) plt.plot([0, 40], [offset_value, offset_value], 'k--', label="offset") plt.xlabel("time sample [ns]") plt.ylabel("counts [ADC]") plt.legend() plt.ylim([-50, 500]) if plot_file != "none" and pad == 428: pad = 420 plt.subplots_adjust(top=0.92) pp.savefig() if i == 8: break if plot_file != "none": pp.close()
################## f,axs = plt.subplots(ncols=2,figsize=(12,6)) blankam1 = np.zeros(1855) blankam2 = np.zeros(1855) blankam2[pix_ids]=gains_2g # ~ blankam1[pix_ids]=res_2g.T[0] # ~ blankam2[pix_ids]=res_2g.T[1] disp2 = CameraDisplay(geom,title="gains (2 gauss mes)",ax=axs[1]) disp2.add_colorbar(ax=axs[1]) disp2.set_limits_minmax(zmin=gains_2g.min()-5,zmax=gains_2g.max()+5) disp2.image = blankam2 # ~ pix_HVs = get_pixs_HV( get_config_xml2(file_path) ) d= {param_names[0] : res_2g.T[0], \ param_names[1] : res_2g.T[1], \ param_names[2] : res_2g.T[2], \ param_names[3] : res_2g.T[3], \ param_names[4] : res_2g.T[4], \ 'gain' : gains_2g , \ 'pix_num' : modpix } df = pd.DataFrame(d) sns.set() disp_p = 0
p2 = -5.0e-3 p4 = -1.25e-7 p6 = -6.25e-12 p8 = -3.90625e-16 p10 = -2.734375e-20 return (p2 * x ** 2 + p4 * x ** 4 + p6 * x ** 6 + p8 * x ** 8 + p10 * x ** 10) pixel_dat = np.loadtxt('CHEC-S_camera_full_19-02-2018-1.dat', unpack=True) z_focalplane = [] z_diff = [] for n, i in enumerate(pixel_dat[0]): xi = i/10 yi = pixel_dat[1][n]/10 zi = focal_plane(np.sqrt(xi ** 2 + yi ** 2)) z_focalplane.append(zi) z_diff.append(zi-pixel_dat[2][n]/10) print(max(z_diff)) geom = CameraGeometry.from_name("CHEC") disp = CameraDisplay(geom) # disp.set_limits_minmax(0, 300) cb = disp.add_colorbar() print(cb) disp.image = z_diff fig2= plt.figure(2) plt.hist(z_diff) plt.show()
def plot(self, input_file, event, telid, chan, extractor_name, nei): # Extract required images dl0 = event.dl0.tel[telid].adc_samples[chan] t_pe = event.mc.tel[telid].photo_electron_image dl1 = event.dl1.tel[telid].image[chan] max_time = np.unravel_index(np.argmax(dl0), dl0.shape)[1] max_charges = np.max(dl0, axis=1) max_pix = int(np.argmax(max_charges)) min_pix = int(np.argmin(max_charges)) geom = CameraGeometry.guess(*event.inst.pixel_pos[telid], event.inst.optical_foclen[telid]) # Get Neighbours max_pixel_nei = nei[max_pix] min_pixel_nei = nei[min_pix] # Get Windows windows = event.dl1.tel[telid].extracted_samples[chan] length = np.sum(windows, axis=1) start = np.argmax(windows, axis=1) end = start + length # Draw figures ax_max_nei = {} ax_min_nei = {} fig_waveforms = plt.figure(figsize=(18, 9)) fig_waveforms.subplots_adjust(hspace=.5) fig_camera = plt.figure(figsize=(15, 12)) ax_max_pix = fig_waveforms.add_subplot(4, 2, 1) ax_min_pix = fig_waveforms.add_subplot(4, 2, 2) ax_max_nei[0] = fig_waveforms.add_subplot(4, 2, 3) ax_min_nei[0] = fig_waveforms.add_subplot(4, 2, 4) ax_max_nei[1] = fig_waveforms.add_subplot(4, 2, 5) ax_min_nei[1] = fig_waveforms.add_subplot(4, 2, 6) ax_max_nei[2] = fig_waveforms.add_subplot(4, 2, 7) ax_min_nei[2] = fig_waveforms.add_subplot(4, 2, 8) ax_img_nei = fig_camera.add_subplot(2, 2, 1) ax_img_max = fig_camera.add_subplot(2, 2, 2) ax_img_true = fig_camera.add_subplot(2, 2, 3) ax_img_cal = fig_camera.add_subplot(2, 2, 4) # Draw max pixel traces ax_max_pix.plot(dl0[max_pix]) ax_max_pix.set_xlabel("Time (ns)") ax_max_pix.set_ylabel("DL0 Samples (ADC)") ax_max_pix.set_title( "(Max) Pixel: {}, True: {}, Measured = {:.3f}".format( max_pix, t_pe[max_pix], dl1[max_pix])) max_ylim = ax_max_pix.get_ylim() ax_max_pix.plot([start[max_pix], start[max_pix]], ax_max_pix.get_ylim(), color='r', alpha=1) ax_max_pix.plot([end[max_pix], end[max_pix]], ax_max_pix.get_ylim(), color='r', alpha=1) for i, ax in ax_max_nei.items(): if len(max_pixel_nei) > i: pix = max_pixel_nei[i] ax.plot(dl0[pix]) ax.set_xlabel("Time (ns)") ax.set_ylabel("DL0 Samples (ADC)") ax.set_title( "(Max Nei) Pixel: {}, True: {}, Measured = {:.3f}".format( pix, t_pe[pix], dl1[pix])) ax.set_ylim(max_ylim) ax.plot([start[pix], start[pix]], ax.get_ylim(), color='r', alpha=1) ax.plot([end[pix], end[pix]], ax.get_ylim(), color='r', alpha=1) # Draw min pixel traces ax_min_pix.plot(dl0[min_pix]) ax_min_pix.set_xlabel("Time (ns)") ax_min_pix.set_ylabel("DL0 Samples (ADC)") ax_min_pix.set_title( "(Min) Pixel: {}, True: {}, Measured = {:.3f}".format( min_pix, t_pe[min_pix], dl1[min_pix])) ax_min_pix.set_ylim(max_ylim) ax_min_pix.plot([start[min_pix], start[min_pix]], ax_min_pix.get_ylim(), color='r', alpha=1) ax_min_pix.plot([end[min_pix], end[min_pix]], ax_min_pix.get_ylim(), color='r', alpha=1) for i, ax in ax_min_nei.items(): if len(min_pixel_nei) > i: pix = min_pixel_nei[i] ax.plot(dl0[pix]) ax.set_xlabel("Time (ns)") ax.set_ylabel("DL0 Samples (ADC)") ax.set_title( "(Min Nei) Pixel: {}, True: {}, Measured = {:.3f}".format( pix, t_pe[pix], dl1[pix])) ax.set_ylim(max_ylim) ax.plot([start[pix], start[pix]], ax.get_ylim(), color='r', alpha=1) ax.plot([end[pix], end[pix]], ax.get_ylim(), color='r', alpha=1) # Draw cameras nei_camera = np.zeros_like(max_charges, dtype=np.int) nei_camera[min_pixel_nei] = 2 nei_camera[min_pix] = 1 nei_camera[max_pixel_nei] = 3 nei_camera[max_pix] = 4 camera = CameraDisplay(geom, ax=ax_img_nei) camera.image = nei_camera camera.cmap = plt.cm.viridis ax_img_nei.set_title("Neighbour Map") ax_img_nei.annotate("Pixel: {}".format(max_pix), xy=(geom.pix_x.value[max_pix], geom.pix_y.value[max_pix]), xycoords='data', xytext=(0.05, 0.98), textcoords='axes fraction', arrowprops=dict(facecolor='red', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top') ax_img_nei.annotate("Pixel: {}".format(min_pix), xy=(geom.pix_x.value[min_pix], geom.pix_y.value[min_pix]), xycoords='data', xytext=(0.05, 0.94), textcoords='axes fraction', arrowprops=dict(facecolor='orange', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top') camera = CameraDisplay(geom, ax=ax_img_max) camera.image = dl0[:, max_time] camera.cmap = plt.cm.viridis camera.add_colorbar(ax=ax_img_max, label="DL0 Samples (ADC)") ax_img_max.set_title("Max Timeslice (T = {})".format(max_time)) ax_img_max.annotate("Pixel: {}".format(max_pix), xy=(geom.pix_x.value[max_pix], geom.pix_y.value[max_pix]), xycoords='data', xytext=(0.05, 0.98), textcoords='axes fraction', arrowprops=dict(facecolor='red', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top') ax_img_max.annotate("Pixel: {}".format(min_pix), xy=(geom.pix_x.value[min_pix], geom.pix_y.value[min_pix]), xycoords='data', xytext=(0.05, 0.94), textcoords='axes fraction', arrowprops=dict(facecolor='orange', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top') camera = CameraDisplay(geom, ax=ax_img_true) camera.image = t_pe camera.cmap = plt.cm.viridis camera.add_colorbar(ax=ax_img_true, label="True Charge (p.e.)") ax_img_true.set_title("True Charge") ax_img_true.annotate("Pixel: {}".format(max_pix), xy=(geom.pix_x.value[max_pix], geom.pix_y.value[max_pix]), xycoords='data', xytext=(0.05, 0.98), textcoords='axes fraction', arrowprops=dict(facecolor='red', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top') ax_img_true.annotate("Pixel: {}".format(min_pix), xy=(geom.pix_x.value[min_pix], geom.pix_y.value[min_pix]), xycoords='data', xytext=(0.05, 0.94), textcoords='axes fraction', arrowprops=dict(facecolor='orange', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top') camera = CameraDisplay(geom, ax=ax_img_cal) camera.image = dl1 camera.cmap = plt.cm.viridis camera.add_colorbar(ax=ax_img_cal, label="Calib Charge (Photo-electrons)") ax_img_cal.set_title("Charge (integrator={})".format(extractor_name)) ax_img_cal.annotate("Pixel: {}".format(max_pix), xy=(geom.pix_x.value[max_pix], geom.pix_y.value[max_pix]), xycoords='data', xytext=(0.05, 0.98), textcoords='axes fraction', arrowprops=dict(facecolor='red', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top') ax_img_cal.annotate("Pixel: {}".format(min_pix), xy=(geom.pix_x.value[min_pix], geom.pix_y.value[min_pix]), xycoords='data', xytext=(0.05, 0.94), textcoords='axes fraction', arrowprops=dict(facecolor='orange', width=2, alpha=0.4), horizontalalignment='left', verticalalignment='top') fig_waveforms.suptitle("Integrator = {}".format(extractor_name)) fig_camera.suptitle("Camera = {}".format(geom.cam_id)) waveform_output_name = "e{}_t{}_c{}_extractor{}_waveform.pdf"\ .format(event.count, telid, chan, extractor_name) camera_output_name = "e{}_t{}_c{}_extractor{}_camera.pdf"\ .format(event.count, telid, chan, extractor_name) output_dir = self.output_dir if output_dir is None: output_dir = input_file.output_directory output_dir = os.path.join(output_dir, self.name) if not os.path.exists(output_dir): self.log.info("Creating directory: {}".format(output_dir)) os.makedirs(output_dir) waveform_output_path = os.path.join(output_dir, waveform_output_name) self.log.info("Saving: {}".format(waveform_output_path)) fig_waveforms.savefig(waveform_output_path, format='pdf', bbox_inches='tight') camera_output_path = os.path.join(output_dir, camera_output_name) self.log.info("Saving: {}".format(camera_output_path)) fig_camera.savefig(camera_output_path, format='pdf', bbox_inches='tight')
inferno = plt.get_cmap('inferno') inferno.set_bad('gray') rdbu = plt.get_cmap('RdBu_r') rdbu.set_bad('gray') for i in range(2): fig, axs = plt.subplots(1, 2, figsize=(5, 2), constrained_layout=True) if i == 1: clean = tailcuts_clean(cam, img, 9, 3) img[~clean] = np.nan time[~clean] = np.nan disp = CameraDisplay(cam, ax=axs[0]) disp.image = img disp.cmap = inferno disp.add_colorbar(ax=axs[0]) disp.set_limits_minmax(0, 45) disp.pixels.set_rasterized(True) disp2 = CameraDisplay(cam, ax=axs[1]) disp2.image = time disp2.cmap = rdbu disp2.set_limits_minmax(10, 40) disp2.add_colorbar(ax=axs[1]) disp2.pixels.set_rasterized(True) axs[0].set_title('\# Photons') axs[1].set_title('Time / ns')
def plot_all(ped_data, ff_data, calib_data, run=0, plot_file="none"): """ plot camera calibration quantities Parameters ---------- ped_data: pedestal container PedestalContainer() ff_data: flat-field container FlatFieldContainer() calib_data: calibration container WaveformCalibrationContainer() """ camera = CameraGeometry.from_name("LSTCam", 2) # plot open pdf if plot_file != "none": pp = PdfPages(plot_file) plt.rc('font', size=15) ### first figure fig = plt.figure(1, figsize=(12, 24)) plt.tight_layout() fig.suptitle(f"Run {run}", fontsize=25) pad = 420 image = ff_data.charge_median mask = ff_data.charge_median_outliers for chan in (np.arange(2)): pad += 1 plt.subplot(pad) plt.tight_layout() disp = CameraDisplay(camera) mymin = np.median(image[chan]) - 2 * np.std(image[chan]) mymax = np.median(image[chan]) + 2 * np.std(image[chan]) disp.set_limits_minmax(mymin, mymax) disp.highlight_pixels(mask[chan], linewidth=2) disp.image = image[chan] disp.cmap = plt.cm.coolwarm #disp.axes.text(lposx, 0, f'{channel[chan]} signal charge (ADC)', rotation=90) plt.title(f'{channel[chan]} signal charge [ADC]') disp.add_colorbar() image = ff_data.charge_std mask = ff_data.charge_std_outliers for chan in (np.arange(2)): pad += 1 plt.subplot(pad) plt.tight_layout() disp = CameraDisplay(camera) mymin = np.median(image[chan]) - 2 * np.std(image[chan]) mymax = np.median(image[chan]) + 2 * np.std(image[chan]) disp.set_limits_minmax(mymin, mymax) disp.highlight_pixels(mask[chan], linewidth=2) disp.image = image[chan] disp.cmap = plt.cm.coolwarm #disp.axes.text(lposx, 0, f'{channel[chan]} signal std [ADC]', rotation=90) plt.title(f'{channel[chan]} signal std [ADC]') disp.add_colorbar() image = ped_data.charge_median mask = ped_data.charge_median_outliers for chan in (np.arange(2)): pad += 1 plt.subplot(pad) plt.tight_layout() disp = CameraDisplay(camera) mymin = np.median(image[chan]) - 2 * np.std(image[chan]) mymax = np.median(image[chan]) + 2 * np.std(image[chan]) disp.set_limits_minmax(mymin, mymax) disp.highlight_pixels(mask[chan], linewidth=2) disp.image = image[chan] disp.cmap = plt.cm.coolwarm #disp.axes.text(lposx, 0, f'{channel[chan]} pedestal [ADC]', rotation=90) plt.title(f'{channel[chan]} pedestal [ADC]') disp.add_colorbar() image = ped_data.charge_std mask = ped_data.charge_std_outliers for chan in (np.arange(2)): pad += 1 plt.subplot(pad) plt.tight_layout() disp = CameraDisplay(camera) mymin = np.median(image[chan]) - 2 * np.std(image[chan]) mymax = np.median(image[chan]) + 2 * np.std(image[chan]) disp.set_limits_minmax(mymin, mymax) disp.highlight_pixels(mask[chan], linewidth=2) disp.image = image[chan] disp.cmap = plt.cm.coolwarm #disp.axes.text(lposx, 0, f'{channel[chan]} pedestal std [ADC]', rotation=90) plt.title(f'{channel[chan]} pedestal std [ADC]') disp.add_colorbar() plt.subplots_adjust(top=0.92) if plot_file != "none": pp.savefig() ### second figure fig = plt.figure(2, figsize=(12, 24)) plt.tight_layout() fig.suptitle(f"Run {run}", fontsize=25) pad = 420 # time image = ff_data.time_median mask = ff_data.time_median_outliers for chan in (np.arange(2)): pad += 1 plt.subplot(pad) plt.tight_layout() disp = CameraDisplay(camera) disp.highlight_pixels(mask[chan], linewidth=2) disp.image = image[chan] disp.cmap = plt.cm.coolwarm #disp.axes.text(lposx, 0, f'{channel[chan]} time', rotation=90) plt.title(f'{channel[chan]} time') disp.add_colorbar() image = ff_data.relative_gain_median mask = calib_data.unusable_pixels for chan in (np.arange(2)): pad += 1 plt.subplot(pad) plt.tight_layout() disp = CameraDisplay(camera) disp.highlight_pixels(mask[chan], linewidth=2) mymin = np.median(image[chan]) - 2 * np.std(image[chan]) mymax = np.median(image[chan]) + 2 * np.std(image[chan]) disp.set_limits_minmax(mymin, mymax) disp.image = image[chan] disp.cmap = plt.cm.coolwarm disp.set_limits_minmax(0.7, 1.3) plt.title(f'{channel[chan]} relative gain') #disp.axes.text(lposx, 0, f'{channel[chan]} relative gain', rotation=90) disp.add_colorbar() # pe image = calib_data.n_pe mask = calib_data.unusable_pixels image = np.where(np.isnan(image), 0, image) for chan in (np.arange(2)): pad += 1 plt.subplot(pad) plt.tight_layout() disp = CameraDisplay(camera) disp.highlight_pixels(mask[chan], linewidth=2) disp.image = image[chan] mymin = np.median(image[chan]) - 2 * np.std(image[chan]) mymax = np.median(image[chan]) + 2 * np.std(image[chan]) disp.set_limits_minmax(mymin, mymax) disp.cmap = plt.cm.coolwarm plt.title(f'{channel[chan]} photon-electrons') #disp.axes.text(lposx, 0, f'{channel[chan]} photon-electrons', rotation=90) disp.add_colorbar() # pe histogram pad += 1 plt.subplot(pad) plt.tight_layout() for chan in np.arange(2): n_pe = calib_data.n_pe[chan] # select good pixels select = np.logical_not(mask[chan]) median = int(np.median(n_pe[select])) rms = np.std(n_pe[select]) mymin = median - 4 * rms mymax = median + 4 * rms label = f"{channel[chan]} Median {median:3.2f}, std {rms:5.2f}" plt.hist(n_pe[select], label=label, histtype='step', range=(mymin, mymax), bins=50, stacked=True, alpha=0.5, fill=True) plt.legend() plt.xlabel(f'pe', fontsize=20) plt.ylabel('pixels', fontsize=20) # pe scatter plot pad += 1 plt.subplot(pad) plt.tight_layout() HG = calib_data.n_pe[0] LG = calib_data.n_pe[1] HG = np.where(np.isnan(HG), 0, HG) LG = np.where(np.isnan(LG), 0, LG) mymin = np.median(LG) - 2 * np.std(LG) mymax = np.median(LG) + 2 * np.std(LG) plt.hist2d(LG, HG, bins=[100, 100]) plt.xlabel("LG", fontsize=20) plt.ylabel("HG", fontsize=20) x = np.arange(mymin, mymax) plt.plot(x, x) plt.ylim(mymin, mymax) plt.xlim(mymin, mymax) plt.subplots_adjust(top=0.92) if plot_file != "none": pp.savefig() ### figures 3 and 4 : histograms for chan in np.arange(2): n_pe = calib_data.n_pe[chan] gain_median = ff_data.relative_gain_median[chan] #charge_median = ff_data.charge_median[chan] charge_mean = ff_data.charge_mean[chan] charge_std = ff_data.charge_std[chan] #median_ped = ped_data.charge_median[chan] mean_ped = ped_data.charge_mean[chan] ped_std = ped_data.charge_std[chan] # select good pixels select = np.logical_not(mask[chan]) fig = plt.figure(chan + 10, figsize=(12, 18)) fig.tight_layout(rect=[0, 0.03, 1, 0.95]) fig.suptitle(f"Run {run} channel: {channel[chan]}", fontsize=25) # charge plt.subplot(321) plt.tight_layout() median = int(np.median(charge_mean[select])) rms = np.std(charge_mean[select]) label = f"Median {median:3.2f}, std {rms:5.0f}" plt.xlabel('charge (ADC)', fontsize=20) plt.ylabel('pixels', fontsize=20) plt.hist(charge_mean[select], bins=50, label=label) plt.legend() plt.subplot(322) plt.tight_layout() plt.ylabel('pixels', fontsize=20) plt.xlabel('charge std', fontsize=20) median = np.median(charge_std[select]) rms = np.std(charge_std[select]) label = f"Median {median:3.2f}, std {rms:3.2f}" plt.hist(charge_std[select], bins=50, label=label) plt.legend() # pedestal charge plt.subplot(323) plt.tight_layout() plt.ylabel('pixels', fontsize=20) plt.xlabel('pedestal', fontsize=20) median = np.median(mean_ped[select]) rms = np.std(mean_ped[select]) label = f"Median {median:3.2f}, std {rms:3.2f}" plt.hist(mean_ped[select], bins=50, label=label) plt.legend() # pedestal std plt.subplot(324) plt.ylabel('pixels', fontsize=20) plt.xlabel('pedestal std', fontsize=20) median = np.median(ped_std[select]) rms = np.std(ped_std[select]) label = f"Median {median:3.2f}, std {rms:3.2f}" plt.hist(ped_std[select], bins=50, label=label) plt.legend() # relative gain plt.subplot(325) plt.tight_layout() plt.ylabel('pixels', fontsize=20) plt.xlabel('relative gain', fontsize=20) median = np.median(gain_median[select]) rms = np.std(gain_median[select]) label = f"Relative gain {median:3.2f}, std {rms:5.2f}" plt.hist(gain_median[select], bins=50, label=label) plt.legend() # photon electrons plt.subplot(326) plt.tight_layout() plt.ylabel('pixels', fontsize=20) plt.xlabel('pe', fontsize=20) median = np.median(n_pe[select]) rms = np.std(n_pe[select]) label = f"Median {median:3.2f}, std {rms:3.2f}" plt.hist(n_pe[select], bins=50, label=label) plt.legend() plt.subplots_adjust(top=0.92) if plot_file != "none": pp.savefig(plt.gcf()) if plot_file != "none": pp.close()
disp = CameraDisplay(geom, title='CT%d' % args.tel) #disp.enable_pixel_picker() disp.add_colorbar() plt.show(block=False) # display the event disp.axes.set_title('CT{:03d}, event {:010d}'.format( args.tel, event.r0.event_id)) if args.show_samples: # display time-varying event data = event.r0.tel[args.tel].adc_samples[args.channel] if args.calibrate: peds, gains = get_mc_calibration_coeffs(event, args.tel) data = apply_mc_calibration(data, peds, gains, args.tel) for ii in range(data.shape[1]): disp.image = data[:, ii] disp.set_limits_percent(70) plt.suptitle("Sample {:03d}".format(ii)) plt.pause(0.01) if args.write: plt.savefig('CT{:03d}_EV{:010d}_S{:02d}.png'.format( args.tel, event.r0.event_id, ii)) else: # display integrated event: im = event.r0.tel[args.tel].adc_sums[args.channel] peds, gains = get_mc_calibration_coeffs(event, args.tel) im = apply_mc_calibration(im, peds, gains, args.tel) disp.image = im plt.pause(1.0) if args.write:
def start(self): disp = None for event in tqdm(self.source, desc='Tel{}'.format(self.tel), total=self.reader.max_events, disable=~self.progress): self.log.debug(event.trig) self.log.debug("Energy: {}".format(event.mc.energy)) self.calibrator.calibrate(event) if disp is None: x, y = event.inst.pixel_pos[self.tel] focal_len = event.inst.optical_foclen[self.tel] geom = CameraGeometry.guess(x, y, focal_len) self.log.info(geom) disp = CameraDisplay(geom) # disp.enable_pixel_picker() disp.add_colorbar() if self.display: plt.show(block=False) # display the event disp.axes.set_title('CT{:03d} ({}), event {:06d}'.format( self.tel, geom.cam_id, event.r0.event_id) ) if self.samples: # display time-varying event data = event.dl0.tel[self.tel].pe_samples[self.channel] for ii in range(data.shape[1]): disp.image = data[:, ii] disp.set_limits_percent(70) plt.suptitle("Sample {:03d}".format(ii)) if self.display: plt.pause(self.delay) if self.write: plt.savefig('CT{:03d}_EV{:10d}_S{:02d}.png' .format(self.tel, event.r0.event_id, ii)) else: # display integrated event: im = event.dl1.tel[self.tel].image[self.channel] if self.clean: mask = tailcuts_clean(geom, im, picture_thresh=10, boundary_thresh=7) im[~mask] = 0.0 disp.image = im if self.hillas: try: ellipses = disp.axes.findobj(Ellipse) if len(ellipses) > 0: ellipses[0].remove() params = hillas_parameters(pix_x=geom.pix_x, pix_y=geom.pix_y, image=im) disp.overlay_moments(params, color='pink', lw=3, with_label=False) except HillasParameterizationError: pass if self.display: plt.pause(self.delay) if self.write: plt.savefig('CT{:03d}_EV{:010d}.png' .format(self.tel, event.r0.event_id)) self.log.info("FINISHED READING DATA FILE") if disp is None: self.log.warning('No events for tel {} were found in {}. Try a ' 'different EventIO file or another telescope' .format(self.tel, self.infile), ) pass
#Calculate source position mcAlt = hdu_list[1].data.field(4)[i] mcAz = hdu_list[1].data.field(5)[i] mcAlttel = hdu_list[1].data.field(19)[i] mcAztel = hdu_list[1].data.field(20)[i] srcpos = Disp.calc_CamSourcePos([mcAlt], [mcAz], [mcAlttel], [mcAztel], focal_length) Source_X = srcpos[0] Source_Y = srcpos[1] cen_x = hdu_list[1].data.field(16)[i] cen_y = hdu_list[1].data.field(17)[i] disp = Disp.calc_DISP(Source_X, Source_Y, cen_x, cen_y) display = CameraDisplay(geom) display.add_colorbar() image = hdu_list[2].data[i] display.image = image display.cmap = 'CMRmap' plt.plot([Source_X], [Source_Y], marker='o', markersize=10, color="green") plt.plot([cen_x], [cen_y], marker='x', markersize=10, color="blue") plt.plot([Source_X, cen_x], [Source_Y, cen_y], '-', color="red") plt.show()
def nsb_rate( baseline_histo_file, dark_histo_file, param_file, template_filename, plot="show", plot_nsb_range=None, norm="log", bias_resistance=1e4 * u.Ohm, cell_capacitance=5e-14 * u.Farad ): baseline_histo = Histogram1D.load(baseline_histo_file) dark_histo = Histogram1D.load(dark_histo_file) baseline_shift = baseline_histo.mean()-dark_histo.mean() n_pixel = len(DigiCam.geometry.neighbors) pixels = np.arange(n_pixel, dtype=int) with open(param_file) as file: pulse_template = NormalizedPulseTemplate.load(template_filename) pulse_area = pulse_template.integral() * u.ns charge_to_amplitude = pulse_template.compute_charge_amplitude_ratio(7, 4) calibration_parameters = yaml.load(file) gain_integral = np.array(calibration_parameters['gain']) gain_amplitude = gain_integral * charge_to_amplitude crosstalk = np.array(calibration_parameters['mu_xt']) rate = _compute_nsb_rate( baseline_shift=baseline_shift, gain=gain_amplitude, pulse_area=pulse_area, crosstalk=crosstalk, bias_resistance=bias_resistance, cell_capacitance=cell_capacitance ) bad_pixels = get_bad_pixels( calib_file=param_file, nsigma_gain=5, nsigma_elecnoise=5, dark_histo=dark_histo_file, nsigma_dark=8, plot=None, output=None ) bad_pixels = np.unique(np.hstack( ( bad_pixels, pixels[rate < 0], pixels[rate > 5 * u.GHz] ) )) avg_matrix = _get_average_matrix_bad_pixels(DigiCam.geometry, bad_pixels) good_pixels_mask = np.ones(n_pixel, dtype=bool) good_pixels_mask[bad_pixels] = False good_pixels = pixels[good_pixels_mask] rate[bad_pixels] = avg_matrix[bad_pixels, :].dot(rate[good_pixels]) if plot is None: return rate fig1, ax = plt.subplots(1, 1) display = CameraDisplay(DigiCam.geometry, ax=ax, norm=norm, title='NSB rate [GHz]') rate_ghz = rate.to(u.GHz).value display.image = rate_ghz if plot_nsb_range is None: plot_nsb_range = (np.min(rate_ghz), np.max(rate_ghz)) display.set_limits_minmax(*plot_nsb_range) display.add_colorbar(ax=ax) display.highlight_pixels(bad_pixels, color='r', linewidth=2) plt.tight_layout() output_path = os.path.dirname(plot) if plot == "show" or \ (output_path != "" and 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) print(plot, 'created') plt.close(fig1) return rate
def start(self): run_list = np.loadtxt('%s/runlist.txt' % self.input_path, unpack=True) plot_cam = False plot_delay = 0.5 disp = None if debug: fig=plt.figure(1) ax=fig.add_subplot(111) for n, run in enumerate(run_list[0]): # TODO remove need for hardcoded file name if self.calibrator == "TargetIOR1Calibrator": file_name = "%s/Run%s_r1.tio" % (self.input_path, int(run)) print(file_name) elif self.calibrator == "HESSIOR1Calibrator": file_name = "%s/sim_tel/run%s.simtel.gz" % (self.input_path, int(run)) print(file_name) try: source = EventSourceFactory.produce(input_url =file_name, max_events=self.max_events) true_pe = [] # lab_pe = [] for event in tqdm(source): self.cal.calibrate(event) self.dl0.reduce(event) self.dl1.calibrate(event) input_pe = run_list[3][n] if self.plot_cam == True: if disp is None: geom = event.inst.subarray.tel[self.telescopes].camera disp = CameraDisplay(geom) disp.add_colorbar() plt.show(block=False) im = event.dl1.tel[self.telescopes].image[0] disp.image = im plt.pause(plot_delay) true_charge_mc = event.mc.tel[self.telescopes].photo_electron_image measured_charge = event.dl1.tel[self.telescopes].image[0] true_charge_lab = np.asarray([input_pe]*len(measured_charge)) true_pe.append(true_charge_mc) if self.use_true_pe: true_charge=true_charge_mc else: true_charge=true_charge_lab.astype(int) self.calculator.add_charges(true_charge, measured_charge) if debug: plt.errorbar(input_pe, np.mean(true_pe), np.std(true_pe),color='k') except FileNotFoundError: stop=0 print('file_not_found') if debug: plt.xscale('log') plt.yscale('log') plt.plot([0,1000],[0,1000], 'k:') plt.xlabel('Input p.e.') plt.ylabel('True mc p.e.') plt.show()
for event in event_source: calibrator(event) for telescope_id, dl1 in event.dl1.tel.items(): image = dl1.image peakpos = dl1.pulse_time camera = event.inst.subarray.tels[telescope_id].camera # display dl1 images fig, axs = plt.subplots(1, 1, figsize=(6, 3)) d1 = CameraDisplay(camera, ax=axs) axs.set_title('Image ' + camera.cam_id) d1.image = dl1.image plt.show() plt.close(fig) # cleaning boundary, picture, min_neighbors = cleaning_level[camera.cam_id] start = datetime.datetime.now() clean1 = fact_image_cleaning(camera, image, peakpos, boundary_threshold=boundary, picture_threshold=picture, min_number_neighbors=min_neighbors)
def plot(event, telid, chan, extractor_name): # Extract required images dl0 = event.dl0.tel[telid].waveform t_pe = event.mc.tel[telid].photo_electron_image dl1 = event.dl1.tel[telid].image max_time = np.unravel_index(np.argmax(dl0), dl0.shape)[1] max_charges = np.max(dl0, axis=1) max_pix = int(np.argmax(max_charges)) min_pix = int(np.argmin(max_charges)) geom = event.inst.subarray.tel[telid].camera nei = geom.neighbors # Get Neighbours max_pixel_nei = nei[max_pix] min_pixel_nei = nei[min_pix] # Draw figures ax_max_nei = {} ax_min_nei = {} fig_waveforms = plt.figure(figsize=(18, 9)) fig_waveforms.subplots_adjust(hspace=0.5) fig_camera = plt.figure(figsize=(15, 12)) ax_max_pix = fig_waveforms.add_subplot(4, 2, 1) ax_min_pix = fig_waveforms.add_subplot(4, 2, 2) ax_max_nei[0] = fig_waveforms.add_subplot(4, 2, 3) ax_min_nei[0] = fig_waveforms.add_subplot(4, 2, 4) ax_max_nei[1] = fig_waveforms.add_subplot(4, 2, 5) ax_min_nei[1] = fig_waveforms.add_subplot(4, 2, 6) ax_max_nei[2] = fig_waveforms.add_subplot(4, 2, 7) ax_min_nei[2] = fig_waveforms.add_subplot(4, 2, 8) ax_img_nei = fig_camera.add_subplot(2, 2, 1) ax_img_max = fig_camera.add_subplot(2, 2, 2) ax_img_true = fig_camera.add_subplot(2, 2, 3) ax_img_cal = fig_camera.add_subplot(2, 2, 4) # Draw max pixel traces ax_max_pix.plot(dl0[max_pix]) ax_max_pix.set_xlabel("Time (ns)") ax_max_pix.set_ylabel("DL0 Samples (ADC)") ax_max_pix.set_title(f"(Max) Pixel: {max_pix}, True: {t_pe[max_pix]}, " f"Measured = {dl1[max_pix]:.3f}") max_ylim = ax_max_pix.get_ylim() for i, ax in ax_max_nei.items(): if len(max_pixel_nei) > i: pix = max_pixel_nei[i] ax.plot(dl0[pix]) ax.set_xlabel("Time (ns)") ax.set_ylabel("DL0 Samples (ADC)") ax.set_title( "(Max Nei) Pixel: {}, True: {}, Measured = {:.3f}".format( pix, t_pe[pix], dl1[pix])) ax.set_ylim(max_ylim) # Draw min pixel traces ax_min_pix.plot(dl0[min_pix]) ax_min_pix.set_xlabel("Time (ns)") ax_min_pix.set_ylabel("DL0 Samples (ADC)") ax_min_pix.set_title(f"(Min) Pixel: {min_pix}, True: {t_pe[min_pix]}, " f"Measured = {dl1[min_pix]:.3f}") ax_min_pix.set_ylim(max_ylim) for i, ax in ax_min_nei.items(): if len(min_pixel_nei) > i: pix = min_pixel_nei[i] ax.plot(dl0[pix]) ax.set_xlabel("Time (ns)") ax.set_ylabel("DL0 Samples (ADC)") ax.set_title(f"(Min Nei) Pixel: {pix}, True: {t_pe[pix]}, " f"Measured = {dl1[pix]:.3f}") ax.set_ylim(max_ylim) # Draw cameras nei_camera = np.zeros_like(max_charges, dtype=np.int) nei_camera[min_pixel_nei] = 2 nei_camera[min_pix] = 1 nei_camera[max_pixel_nei] = 3 nei_camera[max_pix] = 4 camera = CameraDisplay(geom, ax=ax_img_nei) camera.image = nei_camera ax_img_nei.set_title("Neighbour Map") ax_img_nei.annotate( f"Pixel: {max_pix}", xy=(geom.pix_x.value[max_pix], geom.pix_y.value[max_pix]), xycoords="data", xytext=(0.05, 0.98), textcoords="axes fraction", arrowprops=dict(facecolor="red", width=2, alpha=0.4), horizontalalignment="left", verticalalignment="top", ) ax_img_nei.annotate( f"Pixel: {min_pix}", xy=(geom.pix_x.value[min_pix], geom.pix_y.value[min_pix]), xycoords="data", xytext=(0.05, 0.94), textcoords="axes fraction", arrowprops=dict(facecolor="orange", width=2, alpha=0.4), horizontalalignment="left", verticalalignment="top", ) camera = CameraDisplay(geom, ax=ax_img_max) camera.image = dl0[:, max_time] camera.add_colorbar(ax=ax_img_max, label="DL0 Samples (ADC)") ax_img_max.set_title(f"Max Timeslice (T = {max_time})") ax_img_max.annotate( f"Pixel: {max_pix}", xy=(geom.pix_x.value[max_pix], geom.pix_y.value[max_pix]), xycoords="data", xytext=(0.05, 0.98), textcoords="axes fraction", arrowprops=dict(facecolor="red", width=2, alpha=0.4), horizontalalignment="left", verticalalignment="top", ) ax_img_max.annotate( f"Pixel: {min_pix}", xy=(geom.pix_x.value[min_pix], geom.pix_y.value[min_pix]), xycoords="data", xytext=(0.05, 0.94), textcoords="axes fraction", arrowprops=dict(facecolor="orange", width=2, alpha=0.4), horizontalalignment="left", verticalalignment="top", ) camera = CameraDisplay(geom, ax=ax_img_true) camera.image = t_pe camera.add_colorbar(ax=ax_img_true, label="True Charge (p.e.)") ax_img_true.set_title("True Charge") ax_img_true.annotate( f"Pixel: {max_pix}", xy=(geom.pix_x.value[max_pix], geom.pix_y.value[max_pix]), xycoords="data", xytext=(0.05, 0.98), textcoords="axes fraction", arrowprops=dict(facecolor="red", width=2, alpha=0.4), horizontalalignment="left", verticalalignment="top", ) ax_img_true.annotate( f"Pixel: {min_pix}", xy=(geom.pix_x.value[min_pix], geom.pix_y.value[min_pix]), xycoords="data", xytext=(0.05, 0.94), textcoords="axes fraction", arrowprops=dict(facecolor="orange", width=2, alpha=0.4), horizontalalignment="left", verticalalignment="top", ) camera = CameraDisplay(geom, ax=ax_img_cal) camera.image = dl1 camera.add_colorbar(ax=ax_img_cal, label="Calib Charge (Photo-electrons)") ax_img_cal.set_title(f"Charge (integrator={extractor_name})") ax_img_cal.annotate( f"Pixel: {max_pix}", xy=(geom.pix_x.value[max_pix], geom.pix_y.value[max_pix]), xycoords="data", xytext=(0.05, 0.98), textcoords="axes fraction", arrowprops=dict(facecolor="red", width=2, alpha=0.4), horizontalalignment="left", verticalalignment="top", ) ax_img_cal.annotate( f"Pixel: {min_pix}", xy=(geom.pix_x.value[min_pix], geom.pix_y.value[min_pix]), xycoords="data", xytext=(0.05, 0.94), textcoords="axes fraction", arrowprops=dict(facecolor="orange", width=2, alpha=0.4), horizontalalignment="left", verticalalignment="top", ) fig_waveforms.suptitle(f"Integrator = {extractor_name}") fig_camera.suptitle(f"Camera = {geom.cam_id}") plt.show()