FrontEndSiPM.h

Go to the documentation of this file.

#ifndef _mdet_FrontEndSiPM_h
#define _mdet_FrontEndSiPM_h

#include <mdet/MComponentGroup.h>
#include <mdet/MDetectorComponent.h>
#include <mdet/ChannelSiPM.h>
//#include <mdet/BackEndSiPM.h>

#include <utl/ShadowPtr_fwd.h> // just forward it, to declare friendship.
#include <utl/Validated.h>

#include <Rtypes.h> // allow the use of ULong64_t

namespace det {
  struct ComponentUpdater; 
}

namespace mdet {

  class Module;

  class FrontEndSiPM :
    public MDetectorComponent<FrontEndSiPM>::Type {
  private:
    typedef MComponentGroup<FrontEndSiPM, ChannelSiPM, det::ParentCreator>::Type
      ChannelGroup;
  public:
    class Sampler {
    public:
      bool operator()(double v);
    private:
      friend class FrontEndSiPM;
      Sampler(const FrontEndSiPM& fe);
      bool fLastSample;
      const FrontEndSiPM& fFrontEndSiPM;
    };  

    static const char* const kComponentName;

    static const char* const kComponentId;
    
    typedef std::vector<int> BrokenChannelContainer;
    typedef ChannelGroup::ConstIterator ChannelConstIterator;

    ChannelConstIterator ChannelsBegin()  const {
      return fChannels.Begin();
    }
    ChannelConstIterator ChannelsEnd() const {
      return fChannels.End();
    }
    double GetMeanSampleRatePeriod() const;
    unsigned int GetPreT1BufferLength() const; 
    unsigned int GetPostT1BufferLength() const;
    unsigned int GetBufferLength() const { 
      return GetPreT1BufferLength()+GetPostT1BufferLength(); 
    }
//    unsigned int GetExternalMemoryBufferLength() const;
    ULong64_t GetMask() const;

    const BrokenChannelContainer& GetBrokenChannels() const;
    const Module& GetModule() const;
    Sampler MakeSampler() const;

    double GetSampleTimeADC() const;
    double GetDelayBinaryADC() const;
    unsigned short GetADCBaseLineFluctuationLG() const;
    unsigned short GetADCBaseLineFluctuationHG() const;

    unsigned short GetADCBaseLineOffsetLG() const;
    unsigned short GetADCBaseLineOffsetHG() const;

    short GetInjectDigitalNoiseBin() const;
    unsigned short GetInjectDigitalNoiseWidth() const;
    unsigned short GetInjectDigitalNoiseChannel() const;

    //const BackEndSiPM& GetBackEndSiPM() const;
    unsigned short GetADCCounts(double value) const;

  private:
    void Update(bool invalidateData, bool invalidateComponents);
    double GetTrueRangeLowThreshold() const;
    double GetFalseRangeHiThreshold() const;

    double GetDelayBinaryADCMean() const;
    double GetDelayBinaryADCSigma() const;
    
    double GetStepADC() const;


    double GetBaseLineFluctuationLG() const;
    double GetBaseLineFluctuationHG() const;

    double GetDigitalBackGroundProbability() const;
    double GetDigitalBackGroundWidthMean() const;
    double GetDigitalBackGroundWidthStdDev() const;

    FrontEndSiPM(int fId, const det::VManager::IndexMap& parentMap, const Module& parent);
    ~FrontEndSiPM() { }
    const ChannelGroup& GetChannels() const {
      return fChannels;
    }
    friend class Module;

    //friend class BackEndSiPM;
    friend class utl::ShadowPtr<FrontEndSiPM>;
    template<class A1, class A2, class A3, class A4>
    friend class det::ComponentGroup;

    ChannelGroup fChannels;

    mutable utl::Validated<double> fMeanSampleRatePeriod;

    /*
     * Note that managers do not provide unsigned retrievers.
     * So use internally a signed one, and do a cast at the
     * accesor: the interface is kept unsigned as I think
     * that should be (this is the number of bins, no sense to
     * be negative).
     */ 
    mutable utl::Validated<int> fPreT1BufferLength;
    // See fPreT1BufferLength.
    mutable utl::Validated<int> fPostT1BufferLength;
    // See fPreT1BufferLength.
    mutable utl::Validated<int> fExternalMemoryBufferLength;
  
    mutable utl::Validated<double> fTrueRangeLowThreshold;

    mutable utl::Validated<double> fFalseRangeHiThreshold;

    mutable utl::ShadowPtr<BrokenChannelContainer> fBrokenChannels;

    mutable utl::Validated<double> fSampleTimeADC;
    mutable utl::Validated<double> fStepADC;
    mutable utl::Validated<double> fDelayBinaryADCMean;
    mutable utl::Validated<double> fDelayBinaryADCSigma;

    /****************************************************
     *                                                                                                  *
     *                                  Noise Injection                                 *
     *                                                                                                  *
     ****************************************************/
    mutable utl::Validated<double> fBaseLineFluctuationLG;
    mutable utl::Validated<double> fBaseLineFluctuationHG;

    mutable utl::Validated<double> fDigitalBackGroundProbability;
    mutable utl::Validated<double> fDigitalBackGroundWidthMean;
    mutable utl::Validated<double> fDigitalBackGroundWidthStdDev;

    const Module& fModule;
    //const BackEndSiPM& fBackEndSiPM;
  };

}

#endif // _mdet_FrontEndSiPM_h