MEvent/Counter.h

Go to the documentation of this file.

#ifndef _mevt_Counter_h_
#define _mevt_Counter_h_

#include <evt/ComponentGroup.h>
#include <mevt/Module.h>
#include <mevt/CounterSimData.h>
#include <utl/ShadowPtr.h>
#include <utl/ConsecutiveEnumFactory.h>


// forward declaration used for friendship
namespace io {
  class Counter_ROOT;
}


namespace mevt {

  class Counter {

  private:
    typedef evt::ComponentGroup<Module> InternalModuleCollection;

  public:
    typedef InternalModuleCollection::ComponentConstIterator ModuleConstIterator;
    typedef InternalModuleCollection::ComponentIterator ModuleIterator;

    Module& GetModule(const int mId) { return fModules.Get(mId); }

    const Module& GetModule(const int mId) const { return fModules.Get(mId); }

    void MakeModule(const int mId) { fModules.Make(mId); }

    bool HasModule(const int mId) const { return fModules.Has(mId); }

    int GetNumberOfModules() const { return fModules.GetNumberOf(); }

    ModuleConstIterator ModulesBegin() const { return fModules.Begin(); }

    ModuleConstIterator ModulesEnd() const { return fModules.End(); }

    ModuleIterator ModulesBegin() { return fModules.Begin(); }

    ModuleIterator ModulesEnd() { return fModules.End(); }


    CounterSimData& GetSimData() { return *fSimData; }

    const CounterSimData& GetSimData() const { return *fSimData; }

    void MakeSimData();

    bool HasSimData() const { return bool(fSimData); }

    // Counter reconstructed data
    bool HasRecData() const;


    int GetId() const { return fId; }

    // Rely on implicit ones.
    //Counter(const Counter& counter);
    //Counter& operator=(const Counter& counter);



    bool IsCandidate() const;

    bool IsRejected() const;

    bool IsSilent() const;

    bool IsSaturated() const;
    bool IsADCCalibratedLG() const;
    bool IsADCCalibratedHG() const;

    void SetRejected(const std::string& reason = "");

    void SetSilent();

    void SetT1(const double t1) { fT1 = t1; }

    double GetT1() { return fT1; }

    double GetNumberOfEstimatedMuons() const;
    double GetNumberOfMuonsErrorHigh() const;
    double GetNumberOfMuonsErrorLow() const;

    double GetMeanMuons() const;
    double GetMeanMuonsErrorHigh() const;
    double GetMeanMuonsErrorLow() const;

    double GetNumberOfEstimatedMuonsLG() const;
    double GetNumberOfMuonsErrorHighLG() const;
    double GetNumberOfMuonsErrorLowLG() const;

    double GetNumberOfEstimatedMuonsHG() const;
    double GetNumberOfMuonsErrorHighHG() const;
    double GetNumberOfMuonsErrorLowHG() const;

    double GetNumberOfMuonsLowLimit() const;
    double GetMeanMuonsLowLimit() const;

    double GetActiveArea() const;

    double GetActiveAreaLG() const;
    double GetActiveAreaHG() const;

    double GetMuonDensity() const;
    double GetMuonDensityErrorHigh() const;
    double GetMuonDensityErrorLow() const;

    double GetMeanMuonDensity() const;
    double GetMeanMuonDensityErrorHigh() const;
    double GetMeanMuonDensityErrorLow() const;

    double GetMuonDensityLG() const;
    double GetMuonDensityErrorHighLG() const;
    double GetMuonDensityErrorLowLG() const;

    double GetMuonDensityHG() const;
    double GetMuonDensityErrorHighHG() const;
    double GetMuonDensityErrorLowHG() const;

    unsigned int GetNumberOfChannelsOn() const;

    bool IsEmpty() const { return !GetNumberOfChannelsOn(); }

    double GetLDFResidual() const;

    double GetTimeResidual() const { return fTimeResidual; }
    void SetTimeResidual(const double residual) { fTimeResidual = residual; }

    double GetPlaneFrontDelay() const { return fPlaneFrontDelay; }
    void SetPlaneFrontDelay(const double c) { fPlaneFrontDelay = c; }

    bool HasT50() const { return fHasT50; }
    utl::TimeStamp GetSignalT50() const { return fSignalT50; }
    void SetSignalT50(const utl::TimeStamp& time) { fSignalT50 = time; fHasT50 = true; }

    double GetT50Error() const { return fT50Error; }  // error in nanoseconds
    void SetT50Error(const double e) { fT50Error = e; }

    double GetT502SdStart() const { return fT502SdStart; }
    void SetT502SdStart(const double c) { fT502SdStart = c; }

    // Implicit ones.
    //Counter(const Counter& counter);
    //Counter& operator=(const Counter& counter);

  private:
    Counter(const int cId) : fId(cId), fT1(0), fHasT50(false) { }

    //Counter() { }

    ~Counter() { }

    friend class evt::ComponentGroup<Counter>;

    template<class T>
    friend void boost::checked_delete(T*) BOOST_NOEXCEPT;

    /*
     * XXX Up to now, no refactor on Sim + Rec + id pattern for evt classes;
     * keep the current usage: there could be a superclass for rec, sim,
     * calib: but that seems too much and not worth (would lead to multiple
     * virtual inhertance).
     * Another posibility is to define a
     * a wrapper (to ShadowPtr) in order
     * to put there this logic (make/has/get) for single values, but that
     * would be the only logic but there.
     */

    size_t CountCandidateModules() const;

    size_t CountSilentModules() const;

    size_t CountRejectedModules() const;

    int fId = -1;
    double fT1 = 0;
    InternalModuleCollection fModules;
    utl::ShadowPtr<CounterSimData> fSimData;

    bool fHasT50 = false;
    utl::TimeStamp fSignalT50;
    double fT50Error = 0;

    double fTimeResidual = 0;
    double fPlaneFrontDelay = 0;
    double fT502SdStart = 0;

  };

}


#endif