class CHECMCCameraEventContainer(Container):
"""
Storage of mc data for a single telescope that change per event
"""
reference_pulse_shape = Field(None, ("reference pulse shape for each "
"channel"))
time_slice = Field(0, "width of time slice", unit=u.ns)
class DRS4CalibrationContainer(Container):
baseline_mean = Field(
None,
"Mean baseline of each capacitor, shape (N_GAINS, N_PIXELS, N_CAPACITORS_PIXEL)",
dtype=np.uint16,
ndim=3,
)
baseline_std = Field(
None,
"Std Dev. of the baseline calculation, shape (N_GAINS, N_PIXELS, N_CAPACITORS_PIXEL)",
dtype=np.uint16,
ndim=3,
)
baseline_counts = Field(
None,
"Number of events used for the baseline calculation, shape (N_GAINS, N_PIXELS, N_CAPACITORS_PIXEL)",
dtype=np.uint16,
ndim=3,
)
spike_height = Field(
None,
"Mean spike height for each pixel, shape (N_GAINS, N_PIXELS, 3)",
ndim=3,
dtype=np.uint16,
)
class DL1CameraContainer(Container):
"""Storage of output of camera calibration e.g the final calibrated
image in intensity units and other per-event calculated
calibration information.
"""
image = Field(None, "np array of camera image", unit=u.electron)
extracted_samples = Field(
None,
("numpy array of bools indicating which samples were included in the "
"charge extraction as a result of the charge extractor chosen. "
"Shape=(nchan, npix, nsamples)."))
peakpos = Field(
None,
("numpy array containing position of the peak as determined by the "
"peak-finding algorithm for each pixel and channel"))
cleaned = Field(None, "numpy array containing the waveform after cleaning")
pe_samples = Field(
ndarray, "numpy array containing data volume reduced p.e. \
samples (n_channels x n_pixels)")
cleaning_mask = Field(ndarray, "mask for clean pixels")
time_bin = Field(ndarray,
"numpy array containing the bin of maximum (n_pixels)")
pe_samples_trace = Field(
ndarray, "numpy array containing data volume reduced p.e. \
samples (n_channels x n_pixels, n_samples)")
on_border = Field(
bool, "Boolean telling if the shower touches the camera \
border or not")
time_spread = Field(float, 'Time elongation of the shower')
class LSTDataContainer(DataContainer):
"""
Data container including LST and monitoring information
"""
lst = Field(LSTContainer(), "LST specific Information")
mon = Field(MonitoringContainer(),
"container for LST monitoring data (MON)")
class ExtraImageInfo(Container):
""" attach the tel_id """
tel_id = Field(0, "Telescope ID")
trigger_type = Field(None, "trigger type")
trigger_time = Field(None, "trigger time")
num_trig_pix = Field(None, "Number of trigger groups (sectors) listed")
trig_pix_id = Field(None, "pixels involved in the camera trigger")
class LSTCameraContainer(Container):
"""
Container for Fields that are specific to each LST camera
"""
evt = Field(LSTEventContainer(), "LST specific event Information")
svc = Field(LSTServiceContainer(),
"LST specific camera_config Information")
class MetaData(Container):
"""
Some metadata
"""
SOURCE_FILENAMES = Field([], "filename of the source file")
LSTCHAIN_VERSION = Field(None, "version of lstchain")
CTAPIPE_VERSION = Field(None, "version of ctapipe")
CONTACT = Field(None, "Person or institution responsible for this data product")
class LSTContainer(Container):
"""
Storage for the LSTCameraContainer for each telescope
"""
tels_with_data = Field([], "list of telescopes with data")
# create the camera container
tel = Field(Map(LSTCameraContainer), "map of tel_id to LSTTelContainer")
class DL1MonitoringEventIndexContainer(Container):
"""
Container with the calibration coefficients
"""
tel_id = Field(1, 'Index of telescope')
calibration_id = Field(-1, 'Index of calibration event for DL1 file')
pedestal_id = Field(-1, 'Index of pedestal event for DL1 file')
flatfield_id = Field(-1, 'Index of flat-field event for DL1 file')
class MonitoringCameraContainer(Container):
"""
Container for camera monitoring data
"""
flatfield = Field(FlatFieldContainer(), "Relative flat field data")
pedestal = Field(PedestalContainer(), "Pedestal data")
pixel_status = Field(PixelStatusContainer(),
"Container of masks with pixel status")
class NectarCAMCameraContainer(Container):
"""
Container for Fields that are specific to each NectarCAM camera
"""
evt = Field(NectarCAMEventContainer(),
"NectarCAM specific event Information")
svc = Field(NectarCAMServiceContainer(),
"NectarCAM specific camera_config "
"Information")
class R1Container(Container):
"""
Storage of a r1 calibrated Data Event
"""
run_id = Field(-1, "run id number")
event_id = Field(-1, "event id number")
tels_with_data = Field([], "list of telescopes with data")
tel = Field(Map(R1CameraContainer), "map of tel_id to R1CameraContainer")
class DL0Container(Container):
"""
Storage of a data volume reduced Event
"""
run_id = Field(-1, "run id number")
event_id = Field(-1, "event id number")
tels_with_data = Field([], "list of telescopes with data")
tel = Field(Map(DL0CameraContainer), "map of tel_id to DL0CameraContainer")
class ReconstructedContainer(Container):
""" collect reconstructed shower info from multiple algorithms """
shower = Field(Map(ReconstructedShowerContainer),
"Map of algorithm name to shower info")
energy = Field(Map(ReconstructedEnergyContainer),
"Map of algorithm name to energy info")
classification = Field(Map(ParticleClassificationContainer),
"Map of algorithm name to classification info")
class NectarCAMContainer(Container):
"""
Storage for the NectarCAMCameraContainer for each telescope
"""
tels_with_data = Field([], "list of telescopes with data")
# create the camera container
tel = Field(Map(NectarCAMCameraContainer),
"map of tel_id to NectarCAMCameraContainer")
class TelescopePointingContainer(Container):
'''
Container holding pointing information for a single telescope
after all necessary correction and calibration steps.
These values should be used in the reconstruction to transform
between camera and sky coordinates.
'''
azimuth = Field(nan * u.rad, 'Azimuth, measured N->E', unit=u.rad)
altitude = Field(nan * u.rad, 'Altitude', unit=u.rad)
class MetaData(Container):
"""
Some metadata
"""
LSTCHAIN_VERSION = Field(None, "version of lstchain")
CTAPIPE_VERSION = Field(None, "version of ctapipe")
CTAPIPE_IO_LST_VERSION = Field(None, "version of ctapipe_io_lst")
CONTACT = Field(None,
"Person or institution responsible for this data product")
class R0Container(Container):
"""
Storage of a Merged Raw Data Event
"""
run_id = Field(-1, "run id number")
event_id = Field(-1, "event id number")
tels_with_data = Field([], "list of telescopes with data")
tel = Field(Map(R0CameraContainer), "map of tel_id to R0CameraContainer")
class R1CameraContainer(Container):
"""
Storage of r1 calibrated data from a single telescope
"""
adc_samples = Field(ndarray, "baseline subtracted ADCs, (n_pixels, \
n_samples)")
nsb = Field(ndarray, "nsb rate in GHz")
pde = Field(ndarray, "Photo Detection Efficiency at given NSB")
gain_drop = Field(ndarray, "gain drop")
class MonitoringContainer(Container):
"""
Root container for monitoring data (MON)
"""
tels_with_data = Field([], "list of telescopes with data")
# create the camera container
tel = Field(Map(MonitoringCameraContainer),
"map of tel_id to MonitoringCameraContainer")
class MCCameraEventContainer(Container):
"""
Storage of mc data for a single telescope that change per event
"""
photo_electron_image = Field(
Map(), "reference image in pure photoelectrons, with no noise"
)
reference_pulse_shape = Field(
None, "reference pulse shape for each channel"
)
time_slice = Field(0, "width of time slice", unit=u.ns)
dc_to_pe = Field(None, "DC/PE calibration arrays from MC file")
pedestal = Field(None, "pedestal calibration arrays from MC file")
azimuth_raw = Field(
0, "Raw azimuth angle [radians from N->E] for the telescope"
)
altitude_raw = Field(0, "Raw altitude angle [radians] for the telescope")
azimuth_cor = Field(
0, "the tracking Azimuth corrected for pointing errors for \
the telescope"
)
altitude_cor = Field(
0, "the tracking Altitude corrected for pointing \
errors for the telescope"
)
class ReconstructedEnergyContainer(Container):
"""
Standard output of algorithms estimating energy
"""
energy = Field(-1.0, 'reconstructed energy', unit=u.TeV)
energy_uncert = Field(-1.0, 'reconstructed energy uncertainty', unit=u.TeV)
is_valid = Field(False, ('energy reconstruction validity flag. True if '
'the energy was properly reconstructed by the '
'algorithm'))
tel_ids = Field([], ('array containing the telescope ids used in the'
' reconstruction of the shower'))
goodness_of_fit = Field(0.0, 'goodness of the algorithm fit')
class R1CameraContainer(Container):
"""
Storage of r1 calibrated data from a single telescope
"""
pe_samples = Field(None, ("numpy array containing p.e. samples"
"(n_channels x n_pixels, n_samples)"))
adc_samples = Field(ndarray,
"baseline subtracted ADCs, (n_pixels, n_samples)")
nsb = Field(ndarray, "nsb rate in GHz")
pde = Field(ndarray, "Photo Detection Efficiency at given NSB")
gain_drop = Field(ndarray, "gain drop")
class MonitoringCameraContainer(Container):
"""
Container for camera monitoring data
"""
flatfield = Field(FlatFieldContainer(),
"Data from flat-field event distributions")
pedestal = Field(PedestalContainer(),
"Data from pedestal event distributions")
pixel_status = Field(PixelStatusContainer(),
"Container for masks with pixel status")
calibration = Field(WaveformCalibrationContainer(),
"Container for calibration coefficients")
class ParticleClassificationContainer(Container):
"""
Standard output of gamma/hadron classification algorithms
"""
prediction = Field(0.0, ('prediction of the classifier, defined between '
'[0,1], where values close to 0 are more '
'gamma-like, and values close to 1 more '
'hadron-like'))
is_valid = Field(False, ('classificator validity flag. True if the '
'predition was successful within the algorithm '
'validity range'))
goodness_of_fit = Field(0.0, 'goodness of the algorithm fit')
class PixelStatusContainer(Container):
"""
Container for pixel status information
It contains masks obtained by several data analysis steps
At r0 level only the hardware_mask is initialized
"""
hardware_mask = Field(None,
"Mask from the hardware pixel status data (N_pix)")
pedestal_mask = Field(None, "Mask from the pedestal data analysis (N_pix)")
flatfield_mask = Field(None,
"Mask from the flat-flield data analysis (N_pix)")
class HillasParametersContainer(Container):
intensity = Field(0.0, 'total intensity (size)')
x = Field(0.0, 'centroid x coordinate')
y = Field(0.0, 'centroid x coordinate')
r = Field(0.0, 'radial coordinate of centroid')
phi = Field(0.0, 'polar coordinate of centroid', unit=u.deg)
length = Field(0.0, 'RMS spread along the major-axis')
width = Field(0.0, 'RMS spread along the minor-axis')
psi = Field(0.0, 'rotation angle of ellipse', unit=u.deg)
skewness = Field(0.0, 'measure of the asymmetry')
kurtosis = Field(0.0, 'measure of the tailedness')
class CHECDataContainer(Container):
""" Top-level container for all waveforms information """
r0 = Field(CHECR0Container(), "Raw Data")
r1 = Field(R1Container(), "R1 Calibrated Data")
dl0 = Field(DL0Container(), "DL0 Data Volume Reduced Data")
dl1 = Field(DL1Container(), "DL1 Calibrated image")
dl2 = Field(ReconstructedContainer(), "Reconstructed Shower Information")
trig = Field(CentralTriggerContainer(), "central trigger information")
count = Field(0, "number of events processed")
inst = Field(InstrumentContainer(), "instrumental information (deprecated")
mc = Field(CHECMCEventContainer(), "Monte-Carlo data")
class SST1MCameraContainer(Container):
pixel_flags = Field(None, 'numpy array containing pixel flags')
digicam_baseline = Field(None, 'Baseline computed by DigiCam')
local_camera_clock = Field(float, "camera timestamp")
gps_time = Field(float, "gps timestamp")
camera_event_type = Field(int, "camera event type")
array_event_type = Field(int, "array event type")
trigger_input_traces = Field(None, "trigger patch trace (n_patches)")
trigger_output_patch7 = Field(
None, "trigger 7 patch cluster trace (n_clusters)")
trigger_output_patch19 = Field(
None, "trigger 19 patch cluster trace (n_clusters)")
class DL0CameraContainer(Container):
"""
Storage of data volume reduced dl0 data from a single telescope
"""
pe_samples = Field(None, ("numpy array containing data volume reduced "
"p.e. samples"
"(n_channels x n_pixels, n_samples)"))