FrontEndSiPM.cc

Go to the documentation of this file.

#include <mdet/FrontEndSiPM.h>

#include <mdet/SiPM.h>
#include <mdet/MHierarchyInfo.h>
#include <fwk/RandomEngineRegistry.h>
#include <CLHEP/Random/RandGauss.h>
#include <CLHEP/Random/RandFlat.h>

#include <sstream>
#include <iostream>
#include <bitset> 
#include <iomanip>

using std::endl;
using std::cout;

namespace mdet {

  const char* const 
  FrontEndSiPM::kComponentName = MHierarchyInfo::kComponentsNames[8];

  const char* const  
  FrontEndSiPM::kComponentId   = MHierarchyInfo::kComponentsIds[8];

  FrontEndSiPM::FrontEndSiPM
    (int fId, const det::VManager::IndexMap& parentMap, const Module& parent) :
      MDetectorComponent<FrontEndSiPM>::Type(fId, parentMap),
      fChannels(*this),
      fModule(parent)
  {
    Register(fMeanSampleRatePeriod);
    Register(fPreT1BufferLength);
    Register(fPostT1BufferLength);
    Register(fTrueRangeLowThreshold);
    Register(fFalseRangeHiThreshold);
    Register(fSampleTimeADC);
    Register(fStepADC);
    Register(fBaseLineFluctuationLG);
    Register(fBaseLineFluctuationHG);
    Register(fDelayBinaryADCMean);
    Register(fDelayBinaryADCSigma);
    fChannels.Update(GetIdsMap());
  }

  const Module&
  FrontEndSiPM::GetModule()
    const
  {
    return fModule;
  }
  
  double 
  FrontEndSiPM::GetMeanSampleRatePeriod()
    const 
  {
    return GetData(fMeanSampleRatePeriod, "meanSampleRatePeriod");
  }


  unsigned int 
  FrontEndSiPM::GetPreT1BufferLength()
    const 
  {
 
    return GetData(fPreT1BufferLength, "preT1BufferLength");
  }

  unsigned int 
  FrontEndSiPM::GetPostT1BufferLength()
    const
  {
    return GetData(fPostT1BufferLength, "postT1BufferLength");
  }

  double 
  FrontEndSiPM::GetTrueRangeLowThreshold()
    const
  {
    return GetData(fTrueRangeLowThreshold, "trueRangeLowThreshold");
  }
  
  double 
  FrontEndSiPM::GetFalseRangeHiThreshold()
    const
  {
    return GetData(fFalseRangeHiThreshold, "falseRangeHiThreshold");
  }

  double
  FrontEndSiPM::GetSampleTimeADC()
    const
  {
    return GetData(fSampleTimeADC, "sampleTimeADC");
  }

  double
  FrontEndSiPM::GetStepADC()
    const
  {
    return GetData(fStepADC, "stepADC");
  }

  double
  FrontEndSiPM::GetDelayBinaryADCMean()
    const
  {
    return GetData(fDelayBinaryADCMean, "delayBinaryADCMean");
  }

  double
  FrontEndSiPM::GetDelayBinaryADCSigma()
    const
  {
    return GetData(fDelayBinaryADCSigma, "delayBinaryADCSigma");
  }

  double
  FrontEndSiPM::GetBaseLineFluctuationLG()
    const
  {
    return GetData(fBaseLineFluctuationLG, "baseLineFluctuationLG");
  }
  double
  FrontEndSiPM::GetBaseLineFluctuationHG()
    const
  {
    return GetData(fBaseLineFluctuationHG, "baseLineFluctuationHG");
  }
  double
  FrontEndSiPM::GetDigitalBackGroundProbability()
          const
  {
    return GetData(fDigitalBackGroundProbability, "digitalBackGroundProbability");
  }

  double
  FrontEndSiPM::GetDigitalBackGroundWidthMean()
  const
  {
          return GetData(fDigitalBackGroundWidthMean, "digitalBackGroundWidthMean");
  }
  double
  FrontEndSiPM::GetDigitalBackGroundWidthStdDev()
  const
  {
          return GetData(fDigitalBackGroundWidthStdDev, "digitalBackGroundWidthStdDev");
  }

  const FrontEndSiPM::BrokenChannelContainer&
  FrontEndSiPM::GetBrokenChannels()
    const 
  {
    // Note that's shared: so once initialized no further loading
    // will be done. 
    return GetData<BrokenChannelContainer,utl::ThrowOnZeroDereference,utl::ShadowPtr>(fBrokenChannels, "channelsBroken");
  }

  ULong64_t
  FrontEndSiPM::GetMask()
    const 
  {
    std::ostringstream msg;

    ULong64_t mask = 0;

    std::bitset<64> bit_mask;
    bit_mask.reset();//sets all bits to zero

    msg.str("");
    const BrokenChannelContainer * channels = 0;
    channels = & GetBrokenChannels();

    for ( BrokenChannelContainer::const_iterator chIt = channels->begin(), chIte = channels->end();
            chIt != chIte; ++chIt ){
       msg << *chIt << " " ;   
       bit_mask.set(*chIt);//set channel X to one
       mask |= ULong64_t(1) << *chIt;
    }
    msg << std::endl;

    msg << "MD MASK  -- " << std::setw( 10 ) << std::setfill(' ')
         << bit_mask << " "
         << " ==> (" << bit_mask.count() << ")\n";
    msg  << "mask in decimal: " << std::endl;
    msg  << mask <<  std::endl;

    return mask;
  }

  double
  FrontEndSiPM::GetDelayBinaryADC()
    const
  {
    utl::RandomEngine& rnd = fwk::RandomEngineRegistry::GetInstance().Get(fwk::RandomEngineRegistry::eDetector);

    return CLHEP::RandGauss::shoot(& rnd.GetEngine(), GetDelayBinaryADCMean(), GetDelayBinaryADCSigma());
  }


  unsigned short
  FrontEndSiPM::GetADCCounts(double value)
    const
  {
        unsigned short counts = (value/GetStepADC() + 0.5);
    return counts;
  }

  unsigned short
  FrontEndSiPM::GetADCBaseLineFluctuationLG()
    const
  {
    utl::RandomEngine& rnd = fwk::RandomEngineRegistry::GetInstance().Get(fwk::RandomEngineRegistry::eDetector);

    return CLHEP::RandGauss::shoot(& rnd.GetEngine(), 0.0, GetBaseLineFluctuationLG());
  }

  unsigned short
  FrontEndSiPM::GetADCBaseLineFluctuationHG()
    const
  {
    utl::RandomEngine& rnd = fwk::RandomEngineRegistry::GetInstance().Get(fwk::RandomEngineRegistry::eDetector);

    return CLHEP::RandGauss::shoot(& rnd.GetEngine(), 0.0, GetBaseLineFluctuationHG());
  }

  /*unsigned short FrontEndSiPM::GetADCBaseLineOffsetLG()
        const
  {
        return (fModule.GetBackEnd().GetLowGainAmplifierOffset()/GetStepADC()+0.5);
  }
  unsigned short FrontEndSiPM::GetADCBaseLineOffsetHG()
        const
  {
        return (fModule.GetBackEnd().GetHighGainAmplifierOffset()/GetStepADC()+0.5);
  }*/

  short
  FrontEndSiPM::GetInjectDigitalNoiseBin()
  const{

          utl::RandomEngine& rnd = fwk::RandomEngineRegistry::GetInstance().Get(fwk::RandomEngineRegistry::eDetector);
          double chance =  CLHEP::RandFlat::shoot(& rnd.GetEngine(), 0, 1.0);
          short bin = -1;
          if(chance <= GetDigitalBackGroundProbability()){
                  bin = CLHEP::RandFlat::shoot(& rnd.GetEngine(), 0, (GetPreT1BufferLength() + GetPostT1BufferLength())-1.0);
          }
          return bin;
  }

  unsigned short
  FrontEndSiPM::GetInjectDigitalNoiseWidth()
  const{
          utl::RandomEngine& rnd = fwk::RandomEngineRegistry::GetInstance().Get(fwk::RandomEngineRegistry::eDetector);
          return CLHEP::RandGauss::shoot(& rnd.GetEngine(), GetDigitalBackGroundWidthMean(), GetDigitalBackGroundWidthStdDev());
  }

  unsigned short
  FrontEndSiPM::GetInjectDigitalNoiseChannel()
  const{

          utl::RandomEngine& rnd = fwk::RandomEngineRegistry::GetInstance().Get(fwk::RandomEngineRegistry::eDetector);
          return CLHEP::RandFlat::shoot(& rnd.GetEngine(), 0, fChannels.GetNumberOfComponents());
  }

 
  FrontEndSiPM::Sampler
  FrontEndSiPM::MakeSampler()
    const
  {
    return Sampler(*this);
  }
  
  FrontEndSiPM::Sampler::Sampler(const FrontEndSiPM& fe) :
    fLastSample(false), // Take as false the non-existing previous sample
    fFrontEndSiPM(fe)
  {
  }

  bool 
  FrontEndSiPM::Sampler::operator()(double v)
  {
    // Note that we use both comps with =, tough, if both
    // limits coincide, we are privileging one of them 
    // (the first we are comparing with).
    bool ret;
    if (v >= fFrontEndSiPM.GetTrueRangeLowThreshold())
      ret = true;
    else if (v <= fFrontEndSiPM.GetFalseRangeHiThreshold())
      ret = false;
    else 
      ret = fLastSample;
    // Keep this as the new last sample.
    fLastSample = ret;
    return ret;
  }

  void
  FrontEndSiPM::Update(bool invalidateData, bool invalidateComponents)
  {
    MDetectorComponent<FrontEndSiPM>::Type::Update(invalidateData, invalidateComponents);
    fChannels.Update(GetIdsMap(), invalidateData, invalidateComponents);
    if ( invalidateData ) 
      fBrokenChannels = 0;  
  }

}