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 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()
