ModuleRecData.h

Go to the documentation of this file.

#ifndef _mevt_ModuleRecData_h_
#define _mevt_ModuleRecData_h_

#include <utl/ErrorLogger.h>
#include <utl/Trace.h>
#include <utl/TimeStamp.h>
#include <utl/ShadowPtr.h>


namespace mevt {

  class Module;


  class ModuleRecData {

  public:
    utl::TraceUI& GetChannelsOn();
    const utl::TraceUI& GetChannelsOn() const;

    void MakeChannelsOn();
    bool HasChannelsOn() const;

    /*
     * GetNumberOfChannelsOn() takes into account inhibition windows (ie it can be greater than 64)
     * GetTotalNumberOfChannelsOn() yields the number of channels with at least one muon pattern
     * (i.e. is never greater than 64)
     */
    unsigned int GetNumberOfChannelsOn() const;
    unsigned int GetTotalNumberOfChannelsOn() const { return fTotalNumberOfChannelsOn; }
    unsigned int GetMaxChannelsOn() const;

    utl::TraceUI& GetChannelsInhibited();
    const utl::TraceUI& GetChannelsInhibited() const;

    void MakeChannelsInhibited();
    bool HasChannelsInhibited() const;

    unsigned int GetNumberOfChannelsInhibited() const;

    utl::TraceD& GetMeanMuonsVsTime();
    const utl::TraceD& GetMeanMuonsVsTime() const;

    void MakeMeanMuonsVsTime();
    bool HasMeanMuonsVsTime() const;

    utl::TraceD& GetNumberOfMuonsVsTime();
    const utl::TraceD& GetNumberOfMuonsVsTime() const;

    void MakeNumberOfMuonsVsTime();
    bool HasNumberOfMuonsVsTime() const;



    bool IsEmpty() const { return !GetMaxChannelsOn(); }
    bool IsGood() const { return 0 < GetMaxChannelsOn() && GetMaxChannelsOn() < fSegmentation; }

    bool IsADCCalibratedLG() const { return fMeanChargeMuonLG > 0; }
    bool IsADCCalibratedHG() const { return fMeanChargeMuonHG > 0; }

    void SetSaturated(const bool sat) {fSaturated = sat; }
    bool IsSaturated() const { return fSaturated; }
    void SetSaturationFlag(const bool satFlag) { fSaturationFlag = satFlag; }
    bool SaturationFlag() const { return fSaturationFlag; }

    utl::TimeStamp GetChannelsOnStartTime() const { return *fChannelsOnStartTime; }
    void SetChannelsOnStartTime(const utl::TimeStamp& t) { fChannelsOnStartTime = new utl::TimeStamp(t); }
    bool HasChannelsOnStartTime() const { return bool(fChannelsOnStartTime); }

    void SetTotalNumberOfChannelsOn(const unsigned int n) { fTotalNumberOfChannelsOn = n; }
    void SetNumberOfEstimatedMuons(const double m) { fNumberOfEstimatedMuons = m; }
    double GetNumberOfEstimatedMuons() const { return fNumberOfEstimatedMuons; }

    void SetNumberOfMuonsErrorHigh(const double e) { fNumberOfMuonsErrorHigh = e; }
    double GetNumberOfMuonsErrorHigh() const { return fNumberOfMuonsErrorHigh; }

    void SetNumberOfMuonsErrorLow(const double e) { fNumberOfMuonsErrorLow = e; }
    double GetNumberOfMuonsErrorLow() const { return fNumberOfMuonsErrorLow; }

    void SetMeanMuons(const double m) { fMeanMuons = m; }
    double GetMeanMuons() const { return fMeanMuons; }

    void SetMeanMuonsErrorHigh(const double e) { fMeanMuonsErrorHigh = e; }
    double GetMeanMuonsErrorHigh() const { return fMeanMuonsErrorHigh; }

    void SetMeanMuonsErrorLow(const double e) { fMeanMuonsErrorLow = e; }
    double GetMeanMuonsErrorLow() const { return fMeanMuonsErrorLow; }

    double GetMeanChargeMuonLG() const { return fMeanChargeMuonLG; }
    void SetMeanChargeMuonLG(const double charge){ fMeanChargeMuonLG = charge; }
    double GetStdDevChargeMuonLG() const { return fStdDevChargeMuonLG; }
    void SetStdDevChargeMuonLG(const double charge){ fStdDevChargeMuonLG = charge; }

    double GetMeanChargeMuonHG() const { return fMeanChargeMuonHG; }
    void SetMeanChargeMuonHG(const double charge){ fMeanChargeMuonHG = charge; }
    double GetStdDevChargeMuonHG() const { return fStdDevChargeMuonHG; }
    void SetStdDevChargeMuonHG(const double charge){ fStdDevChargeMuonHG = charge; }

    void SetTotalChargeLG(const double charge) { fTotalChargeLG = charge; }
    double GetTotalChargeLG() const { return fTotalChargeLG; }

    void SetTotalChargeHG(const double charge) { fTotalChargeHG = charge; }
    double GetTotalChargeHG() const { return fTotalChargeHG; }


    void SetNumberOfEstimatedMuonsADCLG(const double m) { fNumberOfEstimatedMuonsADCLG = m; }
    double GetNumberOfEstimatedMuonsADCLG() const { return fNumberOfEstimatedMuonsADCLG; }

    void SetNumberOfMuonsADCErrorHighLG(const double e) { fNumberOfMuonsADCErrorHighLG = e; }
    double GetNumberOfMuonsADCErrorHighLG() const { return fNumberOfMuonsADCErrorHighLG; }

    void SetNumberOfMuonsADCErrorLowLG(const double e) { fNumberOfMuonsADCErrorLowLG = e; }
    double GetNumberOfMuonsADCErrorLowLG() const { return fNumberOfMuonsADCErrorLowLG; }

    void SetNumberOfEstimatedMuonsADCHG(const double m) { fNumberOfEstimatedMuonsADCHG = m; }
    double GetNumberOfEstimatedMuonsADCHG() const { return fNumberOfEstimatedMuonsADCHG; }

    void SetNumberOfMuonsADCErrorHighHG(const double e) { fNumberOfMuonsADCErrorHighHG = e; }
    double GetNumberOfMuonsADCErrorHighHG() const { return fNumberOfMuonsADCErrorHighHG; }

    void SetNumberOfMuonsADCErrorLowHG(const double e) { fNumberOfMuonsADCErrorLowHG = e; }
    double GetNumberOfMuonsADCErrorLowHG() const { return fNumberOfMuonsADCErrorLowHG; }

    void SetNumberOfMuonsLowLimit(const double e) { fNumberOfMuonsLowLimit = e; }
    double GetNumberOfMuonsLowLimit() const { return fNumberOfMuonsLowLimit; }

    void SetMeanMuonsLowLimit(const double e) { fMeanMuonsLowLimit = e; }
    double GetMeanMuonsLowLimit() const { return fMeanMuonsLowLimit; }

    // Get and set active area

    void SetActiveArea(const double area) { fActiveArea = area; }
    double GetActiveArea() const { return fActiveArea; }

    double GetMuonDensity() const { return fNumberOfEstimatedMuons / fActiveArea; }
    double GetMuonDensityErrorHigh() const { return fNumberOfMuonsErrorHigh / fActiveArea; }
    double GetMuonDensityErrorLow() const { return fNumberOfMuonsErrorLow / fActiveArea; }

    double GetMeanMuonDensity() const { return fMeanMuons / fActiveArea; }
    double GetMeanMuonDensityErrorHigh() const { return fMeanMuonsErrorHigh / fActiveArea; }
    double GetMeanMuonDensityErrorLow() const { return fMeanMuonsErrorLow / fActiveArea; }

    double GetMuonDensityLG() const { return fNumberOfEstimatedMuonsADCLG / fActiveArea; }
    double GetMuonDensityErrorHighLG() const { return fNumberOfMuonsADCErrorHighLG / fActiveArea; }
    double GetMuonDensityErrorLowLG() const { return fNumberOfMuonsADCErrorLowLG / fActiveArea; }

    double GetMuonDensityHG() const { return fNumberOfEstimatedMuonsADCHG / fActiveArea; }
    double GetMuonDensityErrorHighHG() const { return fNumberOfMuonsADCErrorHighHG / fActiveArea; }
    double GetMuonDensityErrorLowHG() const { return fNumberOfMuonsADCErrorLowHG / fActiveArea; }

    void SetSegmentation(const size_t nm) { fSegmentation = nm; }
    size_t GetSegmentation() const { return fSegmentation; }

    void SetWindowSize(const unsigned int ws) { fWindowSize = ws; }
    unsigned int GetWindowSize() const { return fWindowSize; }

    void SetLDFResidual(const double ldfResidual) { fLDFResidual = ldfResidual; }
    double GetLDFResidual() const { return fLDFResidual; }

    // Methods to access the pattern matches vector
    const std::vector<double>& GetPatternMatchTimes() const { return fPatternMatchTimes; }
    std::vector<double>& GetPatternMatchTimes() { return fPatternMatchTimes; }
    void AddPatternMatchTime(const double t) { fPatternMatchTimes.push_back(t); }

    void SetCornerClippingProbability(const double p) { fCornerClippingProbability = p; }
    double GetCornerClippingProbability() const { return fCornerClippingProbability; }

    void SetSPDistance(const double r) { fSPDistance = r; }
    double GetSPDistance() const { return fSPDistance; }


  private:
    ModuleRecData() { }
    ~ModuleRecData() { }

    double fActiveArea = 0;
    /*
     *   Number of scintillator with a signal per time window
     *   from this field the numbers of windows on and estimated muons are calculated
     */
    utl::ShadowPtr<utl::TraceUI> fChannelsOn;
    utl::ShadowPtr<utl::TraceUI> fChannelsInhibited;
    utl::ShadowPtr<utl::TraceD> fMeanMuonsVsTime;
    utl::ShadowPtr<utl::TraceD> fNumberOfMuonsVsTime;
    utl::ShadowPtr<utl::TimeStamp> fChannelsOnStartTime;

    std::vector<double> fPatternMatchTimes;

    // Number of active channels
    size_t fSegmentation = 0;
    // Length of the inhibition window in number of bins of a channel trace
    unsigned int fWindowSize = 0;
    double fLDFResidual = 0;
    bool fSaturated = false;
    bool fSaturationFlag = false;

    // The estimated parameter "mu" of a Poisson distribution, a parameter of the shower
    // See GAP2022_001 for more details
    double fMeanMuons = 0;
    double fMeanMuonsErrorHigh = 0;
    double fMeanMuonsErrorLow = 0;
    double fMeanMuonsLowLimit = 0;

    // The estimated number of muons at the module
    // See GAP2022_001 for more details
    double fNumberOfEstimatedMuons = 0;
    double fNumberOfMuonsErrorHigh = 0;
    double fNumberOfMuonsErrorLow = 0;
    double fNumberOfMuonsLowLimit = 0;

    double fNumberOfEstimatedMuonsADCHG = 0;
    double fNumberOfMuonsADCErrorHighHG = 0;
    double fNumberOfMuonsADCErrorLowHG = 0;

    double fNumberOfEstimatedMuonsADCLG = 0;
    double fNumberOfMuonsADCErrorHighLG = 0;
    double fNumberOfMuonsADCErrorLowLG = 0;

    double fMeanChargeMuonLG = 0;
    double fStdDevChargeMuonLG = 0;
    double fMeanChargeMuonHG = 0;
    double fStdDevChargeMuonHG = 0;

    double fTotalChargeLG = 0;
    double fTotalChargeHG = 0;

    unsigned int fTotalNumberOfChannelsOn = 0;
    double fCornerClippingProbability = 0;

    double fSPDistance = 0;

    friend class Module;

    friend class utl::ShadowPtr<ModuleRecData>;

  };

}


#endif