opdet::OptDetDigitizer Class Reference

Inheritance diagram for opdet::OptDetDigitizer:

Public Member Functions
	OptDetDigitizer (const fhicl::ParameterSet &)

Private Member Functions
void	produce (art::Event &) override
void	AddDarkNoise (std::vector< double > &RawWF, double gain)
void	AddWaveform (optdata::TimeSlice_t time, std::vector< double > &OldPulse, std::vector< double > &NewPulse, double factor, bool extend=false)
optdata::ChannelData	ApplyDigitization (std::vector< double > const RawWF, optdata::Channel_t const ch) const

Private Attributes
std::string	fInputModule
float	fSampleFreq
float	fTimeBegin
float	fTimeEnd
float	fQE
optdata::ADC_Count_t	fSaturationScale
std::vector< optdata::ADC_Count_t >	fPedMeanArray
float	fDarkRate
optdata::ADC_Count_t	fPedFlucAmp
float	fPedFlucRate
std::vector< double >	fSinglePEWaveform
bool	fSimGainSpread
CLHEP::HepRandomEngine &	fEngine
CLHEP::RandFlat	fFlatRandom
CLHEP::RandPoisson	fPoissonRandom
art::ServiceHandle < OpDigiProperties >	fOpDigiProperties
art::ServiceHandle < geo::Geometry const >	fGeom

Detailed Description

Definition at line 37 of file OptDetDigitizer_module.cc.

Constructor & Destructor Documentation

opdet::OptDetDigitizer::OptDetDigitizer ( const fhicl::ParameterSet &  pset )

explicit

Definition at line 86 of file OptDetDigitizer_module.cc.

    : EDProducer{pset}
    , fEngine(art::ServiceHandle<rndm::NuRandomService>()->createEngine(*this, pset, "Seed"))
    , fFlatRandom{fEngine}
    , fPoissonRandom{fEngine}
  {
    // Infrastructure piece
    produces<std::vector< optdata::ChannelDataGroup> >();

    optdata::ChannelDataGroup dg;
    // Input Module and histogram parameters come from .fcl
    fInputModule   = pset.get<std::string>("InputModule");
    fSimGainSpread = pset.get<bool       >("SimGainSpread");
    fTimeBegin  = fOpDigiProperties->TimeBegin();
    fTimeEnd    = fOpDigiProperties->TimeEnd();
    fSampleFreq = fOpDigiProperties->SampleFreq();
    fQE         = fOpDigiProperties->QE();
    fDarkRate   = fOpDigiProperties->DarkRate();
    fPedFlucAmp = fOpDigiProperties->PedFlucAmp();
    fPedFlucRate= fOpDigiProperties->PedFlucRate();
    fSaturationScale = fOpDigiProperties->SaturationScale();
    fPedMeanArray = fOpDigiProperties->PedMeanArray();

    fSinglePEWaveform = fOpDigiProperties->SinglePEWaveform();
  }

Member Function Documentation

void opdet::OptDetDigitizer::AddDarkNoise ( std::vector< double > &  RawWF, double  gain  )

private

Definition at line 128 of file OptDetDigitizer_module.cc.

                                                                         {
    // Add dark noise
    double MeanDarkPulses = fDarkRate * (fTimeEnd-fTimeBegin) / 1000000;

    unsigned int NumberOfPulses = fPoissonRandom.fire(MeanDarkPulses);
    for(size_t i=0; i!=NumberOfPulses; ++i)
      {
        double PulseTime_ns = fTimeBegin*1000 + (fTimeEnd-fTimeBegin)*1000*(fFlatRandom.fire(1.0)); // Should be in ns
        optdata::TimeSlice_t PulseTime_ts = fOpDigiProperties->GetTimeSlice(PulseTime_ns);
        AddWaveform( PulseTime_ts,
                     RawWF,
                     fSinglePEWaveform,
                     gain);
      }

  }

void opdet::OptDetDigitizer::AddWaveform ( optdata::TimeSlice_t  time, std::vector< double > &  OldPulse, std::vector< double > &  NewPulse, double  factor, bool  extend = false  )

private

Definition at line 114 of file OptDetDigitizer_module.cc.

  {
    if( (time+NewPulse.size()) > OldPulse.size() && extend )
      OldPulse.resize(time + NewPulse.size());
    for(size_t i = 0; i<NewPulse.size() && (time+i)<OldPulse.size(); ++i)
      OldPulse[time+i] += NewPulse[i] * factor;
  }

optdata::ChannelData opdet::OptDetDigitizer::ApplyDigitization ( std::vector< double > const  RawWF, optdata::Channel_t const  ch  ) const

private

Definition at line 145 of file OptDetDigitizer_module.cc.

  {
    //
    // Digitization includes...
    //     (a) amplitude digitization
    //     (b) saturation
    //     (c) pedestal fluctuation
    //

    // prepare return data container
    optdata::ChannelData chData(ch);
    chData.reserve(rawWF.size());
    optdata::ADC_Count_t baseMean(fPedMeanArray.at(ch));
    for(optdata::TimeSlice_t time=0; time<rawWF.size(); ++time)
      {
        double thisSample = rawWF[time];

        optdata::ADC_Count_t thisCount = (optdata::ADC_Count_t)(thisSample)+baseMean;

        // (a) amplitude digitization
        if(CLHEP::RandFlat::shoot(1.0) < (thisSample - int(thisSample)))
          thisCount+=1;

        // (b) saturation
        if(thisCount > fSaturationScale) thisCount = fSaturationScale;

        chData.push_back(thisCount);
      }

    // (c) pedestal fluctuation
    double timeSpan = chData.size() * 1.e-6/(fOpDigiProperties->SampleFreq());
    unsigned int nFluc = CLHEP::RandPoisson::shoot(fPedFlucRate * timeSpan);
    for(size_t i=0; i<nFluc; ++i)
      {
        optdata::TimeSlice_t pulseTime(CLHEP::RandFlat::shoot(0.0,(double)(chData.size())));
        optdata::ADC_Count_t amp = chData[pulseTime];
        if( CLHEP::RandFlat::shoot(0.,1.) > 0.5)
          {
            amp += fPedFlucAmp;
            if(amp > fSaturationScale) amp=fSaturationScale;
          }
        else
          amp -= fPedFlucAmp;
        chData[pulseTime] = amp;
      }

    return chData;
  }

void opdet::OptDetDigitizer::produce ( art::Event &  evt )

overrideprivate

Definition at line 197 of file OptDetDigitizer_module.cc.

  {

    //
    // Event-wise initialization
    //

    // Infrastructure piece
    std::unique_ptr< std::vector<optdata::ChannelDataGroup > > StoragePtr (new std::vector<optdata::ChannelDataGroup>);

    // Read in the Sim Photons
    sim::SimPhotonsCollection ThePhotCollection = sim::SimListUtils::GetSimPhotonsCollection(evt,fInputModule);

    // Convert units into ns from us/MHz
    double timeBegin_ns  = fTimeBegin  *  1000;
    double timeEnd_ns    = fTimeEnd    *  1000;
    double sampleFreq_ns = fSampleFreq /  1000;

    // Compute # of timeslices to be stored in the output. This is defined by a user input (fcl file)
    optdata::TimeSlice_t timeSliceWindow(fOpDigiProperties->GetTimeSlice(timeEnd_ns));

    /*
      Create output data product, optdata::ChannelDataGroup for each gain channel.
      Note : Although the frame + sample number in DATA should have a reference of T=0 @ DAQ start time, this is
             not handled in MC. Hence we do not set them here (use constructor default)
    */
    optdata::ChannelDataGroup rawWFGroup_HighGain(optdata::kHighGain);
    optdata::ChannelDataGroup rawWFGroup_LowGain(optdata::kLowGain);
    // Reserve entries equal to # of channels
    rawWFGroup_HighGain.reserve(fGeom->NOpChannels());
    rawWFGroup_LowGain.reserve(fGeom->NOpChannels());

    /*
      Define "raw" waveform container which will be filled based on G4 photon timing + SPE waveform information.
      Note this is not completely an analog waveform because it is digitized in terms of time (as it is using std::vector).
    */
    std::vector<std::vector<double> > rawWF_HighGain(fGeom->NOpChannels(),std::vector<double>(timeSliceWindow,0.0));
    std::vector<std::vector<double> > rawWF_LowGain(fGeom->NOpChannels(),std::vector<double>(timeSliceWindow,0.0));

    /*
      Start data processing ... see following steps
      (1) Loop over input array of optical photons & fill "raw" waveform container w/ corresponding SPE waveform
      (2) Loop over filled "raw" waveform and process (digitization, adding noise, baseline spread, etc)
    */

    //
    // Step (1) ... loop over G4 optical photons
    //

    // For every OpDet, convert PE into waveform and combine all together
    for(sim::SimPhotonsCollection::const_iterator itOpDet=ThePhotCollection.begin(); itOpDet!=ThePhotCollection.end(); itOpDet++)
      {
        const sim::SimPhotons& ThePhot=itOpDet->second;

        int ch = ThePhot.OpChannel();
        // For every photon in the hit:
        for(const sim::OnePhoton& Phot: ThePhot)
          {
            // Sample a random subset according to QE
            if(fFlatRandom.fire(1.0)<=fQE)
              {
                optdata::TimeSlice_t PhotonTime(fOpDigiProperties->GetTimeSlice(Phot.Time));
                if( Phot.Time > timeBegin_ns  &&  Phot.Time < timeEnd_ns )
                  {
                    if(fSimGainSpread)
                      {
                        AddWaveform( PhotonTime, rawWF_HighGain[ch], fSinglePEWaveform, fOpDigiProperties->HighGain(ch));
                        AddWaveform( PhotonTime, rawWF_LowGain[ch], fSinglePEWaveform, fOpDigiProperties->LowGain(ch));
                      }
                    else
                      {
                        AddWaveform( PhotonTime, rawWF_HighGain[ch], fSinglePEWaveform, fOpDigiProperties->HighGainMean(ch));
                        AddWaveform( PhotonTime, rawWF_LowGain[ch], fSinglePEWaveform, fOpDigiProperties->LowGainMean(ch));
                      }
                  }
              } // random QE cut
          } // for each Photon in SimPhotons
      }

    //
    // Loop over "raw" waveform (channel-wise)
    //
    for(unsigned short iCh = 0; iCh < rawWF_LowGain.size(); ++iCh){
      rawWF_LowGain[iCh].resize((timeEnd_ns - timeBegin_ns) * sampleFreq_ns);
      rawWF_HighGain[iCh].resize((timeEnd_ns - timeBegin_ns) * sampleFreq_ns);

      // Add dark noise
      if(fSimGainSpread){
        AddDarkNoise(rawWF_LowGain[iCh],fOpDigiProperties->LowGain(iCh));
        AddDarkNoise(rawWF_HighGain[iCh],fOpDigiProperties->HighGain(iCh));
      }else{
        AddDarkNoise(rawWF_LowGain[iCh],fOpDigiProperties->LowGainMean(iCh));
        AddDarkNoise(rawWF_HighGain[iCh],fOpDigiProperties->HighGainMean(iCh));
      }

      // Apply digitization and make channel data
      optdata::ChannelData chData_HighGain(ApplyDigitization(rawWF_HighGain[iCh],iCh));
      optdata::ChannelData chData_LowGain(ApplyDigitization(rawWF_LowGain[iCh],iCh));

      rawWFGroup_HighGain.push_back(chData_HighGain);
      rawWFGroup_LowGain.push_back(chData_LowGain);
    } // for each OpDet in SimPhotonsCollection

    StoragePtr->push_back(rawWFGroup_HighGain);
    StoragePtr->push_back(rawWFGroup_LowGain);

    evt.put(std::move(StoragePtr));
  }

Member Data Documentation

float opdet::OptDetDigitizer::fDarkRate

private

Definition at line 52 of file OptDetDigitizer_module.cc.

CLHEP::HepRandomEngine& opdet::OptDetDigitizer::fEngine

private

Definition at line 61 of file OptDetDigitizer_module.cc.

CLHEP::RandFlat opdet::OptDetDigitizer::fFlatRandom

private

Definition at line 62 of file OptDetDigitizer_module.cc.

art::ServiceHandle<geo::Geometry const> opdet::OptDetDigitizer::fGeom

private

Definition at line 73 of file OptDetDigitizer_module.cc.

std::string opdet::OptDetDigitizer::fInputModule

private

Definition at line 45 of file OptDetDigitizer_module.cc.

art::ServiceHandle<OpDigiProperties> opdet::OptDetDigitizer::fOpDigiProperties

private

Definition at line 72 of file OptDetDigitizer_module.cc.

optdata::ADC_Count_t opdet::OptDetDigitizer::fPedFlucAmp

private

Definition at line 53 of file OptDetDigitizer_module.cc.

float opdet::OptDetDigitizer::fPedFlucRate

private

Definition at line 54 of file OptDetDigitizer_module.cc.

std::vector<optdata::ADC_Count_t> opdet::OptDetDigitizer::fPedMeanArray

private

Definition at line 51 of file OptDetDigitizer_module.cc.

CLHEP::RandPoisson opdet::OptDetDigitizer::fPoissonRandom

private

Definition at line 63 of file OptDetDigitizer_module.cc.

float opdet::OptDetDigitizer::fQE

private

Definition at line 49 of file OptDetDigitizer_module.cc.

float opdet::OptDetDigitizer::fSampleFreq

private

Definition at line 46 of file OptDetDigitizer_module.cc.

optdata::ADC_Count_t opdet::OptDetDigitizer::fSaturationScale

private

Definition at line 50 of file OptDetDigitizer_module.cc.

bool opdet::OptDetDigitizer::fSimGainSpread

private

Definition at line 59 of file OptDetDigitizer_module.cc.

std::vector<double> opdet::OptDetDigitizer::fSinglePEWaveform

private

Definition at line 57 of file OptDetDigitizer_module.cc.

float opdet::OptDetDigitizer::fTimeBegin

private

Definition at line 47 of file OptDetDigitizer_module.cc.

float opdet::OptDetDigitizer::fTimeEnd

private

Definition at line 48 of file OptDetDigitizer_module.cc.

---

The documentation for this class was generated from the following file:

• OptDetDigitizer_module.cc