MEvent/Module.h

Go to the documentation of this file.

#ifndef _mevt_Module_h_
#define _mevt_Module_h_

#include <evt/ComponentGroup.h>

#include <mevt/Scintillator.h>
#include <mevt/Channel.h>
#include <mevt/ModuleSimData.h>
#include <mevt/ModuleRecData.h>

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


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

namespace mevt {

  //This is temporary until we integrate the calibration in CDAS
  struct CalibrationData{
      long UTC;
      double chargeA;
      double chargeB;
      double noiseA;
      double noiseB;
  };


  class Module {

    /*
     * On the detector level the hierarchy was split in
     * Module->FrontEnd->Channel
     * Module->PMT->Pixel
     * because there was some common information at the
     * PMT or FrontEnd level.
     * In the event level having a PMT or FrontEnd doesn't
     * seem worth (or even proper) because the data
     * will have to be associated a the Channel or Pixel level.
     *
     * So we cut corners and hold the Channels here without
     * the circumlocution of the FrontEnd. In any case,
     * if in the future the FrontEnd need arises, these methods
     * here accesing the Channel will be a shorcut to those
     * in the FrontEnd.
     */
    typedef evt::ComponentGroup<Scintillator> InternalScintillatorCollection;
    typedef evt::ComponentGroup<Channel> InternalChannelCollection;

  public:
    typedef InternalChannelCollection::ComponentConstIterator ChannelConstIterator;
    typedef InternalChannelCollection::ComponentIterator ChannelIterator;

    utl::TraceUSI& GetDynodeTrace();
    const utl::TraceUSI& GetDynodeTrace() const;
    void MakeDynodeTrace();
    bool HasDynodeTrace() const;

    /*
     * Integrator traces for SiPMs electronics
     * */

    utl::TraceUSI& GetIntegratorATrace();
    const utl::TraceUSI& GetIntegratorATrace() const;
    void MakeIntegratorATrace();
    bool HasIntegratorATrace() const;

    utl::TraceUSI& GetIntegratorBTrace();
    const utl::TraceUSI& GetIntegratorBTrace() const;
    void MakeIntegratorBTrace();
    bool HasIntegratorBTrace() const;

    const std::vector<CalibrationData> GetCalibrationData() { return fCalibrationData; }

    Channel& GetChannel(const int cId) { return fChannels.Get(cId); }
    const Channel& GetChannel(const int cId) const { return fChannels.Get(cId); }
    void MakeChannel(const int cId) { fChannels.Make(cId); }
    bool HasChannel(const int cId) const { return fChannels.Has(cId); }
    int GetNumberOfChannels() const { return fChannels.GetNumberOf(); }
    ChannelConstIterator ChannelsBegin() const { return fChannels.Begin(); }
    ChannelConstIterator ChannelsEnd() const { return fChannels.End(); }
    ChannelIterator ChannelsBegin() { return fChannels.Begin(); }
    ChannelIterator ChannelsEnd() { return fChannels.End(); }

    typedef InternalScintillatorCollection::ComponentConstIterator ScintillatorConstIterator;
    typedef InternalScintillatorCollection::ComponentIterator ScintillatorIterator;

    Scintillator& GetScintillator(const int sId) { return fScintillators.Get(sId); }
    const Scintillator& GetScintillator(const int sId) const { return fScintillators.Get(sId); }
    void MakeScintillator(const int sId) { fScintillators.Make(sId); }
    bool HasScintillator(const int sId) const { return fScintillators.Has(sId); }
    int GetNumberOfScintillators() const { return fScintillators.GetNumberOf(); }
    ScintillatorConstIterator ScintillatorsBegin() const { return fScintillators.Begin(); }
    ScintillatorConstIterator ScintillatorsEnd() const { return fScintillators.End(); }
    ScintillatorIterator ScintillatorsBegin() { return fScintillators.Begin(); }
    ScintillatorIterator ScintillatorsEnd() { return fScintillators.End(); }

    ModuleSimData& GetSimData() { return *fSimData; }
    const ModuleSimData& GetSimData() const { return *fSimData; }
    void MakeSimData();
    bool HasSimData() const { return bool(fSimData); }



    void SetCandidate() { fRecStatus = eCandidate; }
    bool IsCandidate() const { return fRecStatus == eCandidate; }

    void SetSilent() { fRecStatus = eSilent; }
    bool IsSilent() const { return fRecStatus == eSilent; }

    void SetRejected(const std::string& reason = "")
    { fRecStatus = eRejected; fRejectionReason = reason; }
    bool IsRejected() const { return fRecStatus == eRejected; }
    std::string GetRejectionReason() const { return fRejectionReason; }

    void SetChannelMask(const std::bitset<64>& mask) { fChannelMask = mask; }
    size_t GetNumberOfActiveChannels() const { return fChannelMask.size() - fChannelMask.count(); }


    ModuleRecData& GetRecData() { return *fRecData; }
    const ModuleRecData& GetRecData() const { return *fRecData; }
    void MakeRecData();
    bool HasRecData() const { return bool(fRecData); }
    //@
    int GetId() const { return fId; }

    // Implicit ones.
    //Module(const Module& module);
    //Module& operator=(const Module& module);

  private:
    enum ModuleReconstructionStatus {
      eUndefined = 0,
      eCandidate,
      eSilent,
      eRejected
    };

    //Module() { }

    Module(const int mId) : fId(mId) { fRecStatus = eUndefined; }

    ~Module() { }

    friend class evt::ComponentGroup<Module>;

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

    friend class io::Module_ROOT;

    void SetRecStatus(const int s) { fRecStatus = static_cast<ModuleReconstructionStatus>(s); }

    int fId = -1;
    ModuleReconstructionStatus fRecStatus = eUndefined;
    std::string fRejectionReason;
    InternalScintillatorCollection fScintillators;
    InternalChannelCollection fChannels;

    utl::ShadowPtr<ModuleSimData> fSimData;
    utl::ShadowPtr<ModuleRecData> fRecData;
    utl::ShadowPtr<utl::TraceUSI> fDynodeTrace;
    utl::ShadowPtr<utl::TraceUSI> fIntegratorATrace;
    utl::ShadowPtr<utl::TraceUSI> fIntegratorBTrace;

    std::vector<CalibrationData> fCalibrationData;

    std::bitset<64> fChannelMask;  // mask of working channels 0 = working, 1 = not working

  };

}


#endif