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 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 LSTContainer(Container):
"""
Storage for the LSTCameraContainer for each telescope
"""
# create the camera container
tel = Field(Map(LSTCameraContainer), "map of tel_id to LSTTelContainer")
class TargetIOContainer(Container):
"""
Storage for the TargetIOCameraContainer for each telescope
"""
tel = Field(Map(TargetIOCameraContainer),
"map of tel_id to TargetIOCameraContainer")
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 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 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 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 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 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 MCEventContainer(Container):
"""
Monte-Carlo
"""
energy = Field(0.0, "Monte-Carlo Energy", unit=u.TeV)
alt = Field(0.0, "Monte-carlo altitude", unit=u.deg)
az = Field(0.0, "Monte-Carlo azimuth", unit=u.deg)
core_x = Field(0.0, "MC core position", unit=u.m)
core_y = Field(0.0, "MC core position", unit=u.m)
h_first_int = Field(0.0, "Height of first interaction")
tel = Field(Map(MCCameraEventContainer),
"map of tel_id to MCCameraEventContainer")
mc_event_offset_fov = Field(
Map(ndarray), "offset of pointing direction in camera \
f.o.v. divided by focal length, i.e. \
converted to radians: [0] = Camera x \
(downwards in normal pointing, i.e. \
increasing Alt) [1] = Camera y -> Az.")
class DataContainer(Container):
""" Top-level container for all event information """
r0 = Field(R0Container(), "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")
mc = Field(MCEventContainer(), "Monte-Carlo data")
mcheader = Field(MCHeaderContainer(), "Monte-Carlo run header data")
trig = Field(CentralTriggerContainer(), "central trigger information")
count = Field(0, "number of events processed")
inst = Field(InstrumentContainer(), "instrumental information (deprecated")
pointing = Field(Map(TelescopePointingContainer),
'Telescope pointing positions')
class InstrumentContainer(Container):
"""Storage of header info that does not change with event. This is a
temporary hack until the Instrument module and database is fully
implemented. Eventually static information like this will not be
part of the data stream, but be loaded and accessed from
functions.
"""
subarray = Field(SubarrayDescription("MonteCarloArray"),
"SubarrayDescription from the instrument module")
optical_foclen = Field(Map(ndarray), "map of tel_id to focal length")
tel_pos = Field(Map(ndarray), "map of tel_id to telescope position")
pixel_pos = Field(Map(ndarray), "map of tel_id to pixel positions")
telescope_ids = Field([], "list of IDs of telescopes used in the run")
num_pixels = Field(Map(int), "map of tel_id to number of pixels in camera")
num_channels = Field(Map(int), "map of tel_id to number of channels")
num_samples = Field(Map(int), "map of tel_id to number of samples")
geom = Field(Map(None), 'map of tel_if to CameraGeometry')
cam = Field(Map(None), 'map of tel_id to Camera')
optics = Field(Map(None), 'map of tel_id to CameraOptics')
cluster_matrix_7 = Field(Map(ndarray), 'map of tel_id of cluster 7 matrix')
cluster_matrix_19 = Field(
Map(ndarray),
'map of tel_id of cluster 19 matrix'
)
patch_matrix = Field(Map(ndarray), 'map of tel_id of patch matrix')
mirror_dish_area = Field(Map(float),
"map of tel_id to the area of the mirror dish",
unit=u.m ** 2)
mirror_numtiles = Field(Map(int),
"map of tel_id to the number of \
tiles for the mirror")
class SST1MContainer(Container):
tels_with_data = Field([], "list of telescopes with data")
tel = Field(Map(SST1MCameraContainer),
"map of tel_id to SST1MCameraContainer")
class DL1Container(Container):
""" DL1 Calibrated Camera Images and associated data"""
tel = Field(Map(DL1CameraContainer), "map of tel_id to DL1CameraContainer")
class ParentContainer(Container):
x = Field(0, "some value")
children = Field(Map(), "map of tel_id to child")
class CHECMCEventContainer(Container):
"""
Monte-Carlo
"""
tel = Field(Map(CHECMCCameraEventContainer),
"map of tel_id to MCCameraEventContainer")
