コード例 #1
0
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)
コード例 #2
0
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,
    )
コード例 #3
0
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')
コード例 #4
0
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)")
コード例 #5
0
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")
コード例 #6
0
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")
コード例 #7
0
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")
コード例 #8
0
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")
コード例 #9
0
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')
コード例 #10
0
ファイル: containers.py プロジェクト: olgbalsa/cta-lstchain
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")
コード例 #11
0
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")
コード例 #12
0
ファイル: containers.py プロジェクト: ndeangel/digicampipe
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")
コード例 #13
0
ファイル: containers.py プロジェクト: ndeangel/digicampipe
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")
コード例 #14
0
ファイル: containers.py プロジェクト: ndeangel/digicampipe
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")
コード例 #15
0
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")
コード例 #16
0
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)
コード例 #17
0
ファイル: lstcontainers.py プロジェクト: Hckjs/cta-lstchain
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")
コード例 #18
0
ファイル: containers.py プロジェクト: ndeangel/digicampipe
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")
コード例 #19
0
ファイル: containers.py プロジェクト: ndeangel/digicampipe
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")
コード例 #20
0
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")
コード例 #21
0
ファイル: containers.py プロジェクト: ndeangel/digicampipe
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"
    )
コード例 #22
0
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')
コード例 #23
0
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")
コード例 #24
0
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")
コード例 #25
0
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')
コード例 #26
0
ファイル: containers.py プロジェクト: olgbalsa/cta-lstchain
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)")
コード例 #27
0
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')
コード例 #28
0
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")
コード例 #29
0
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)")
コード例 #30
0
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)"))