Inheritance diagram for opdet::OptDetDigitizer:

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

Public Member Functions inherited from art::EDProducer
	EDProducer (fhicl::ParameterSet const &pset)

template<typename Config >
	EDProducer (Table< Config > const &config)

std::string	workerType () const

Public Member Functions inherited from art::detail::Producer
virtual	~Producer () noexcept

	Producer (fhicl::ParameterSet const &)

	Producer (Producer const &)=delete

	Producer (Producer &&)=delete

Producer &	operator= (Producer const &)=delete

Producer &	operator= (Producer &&)=delete

void	doBeginJob (SharedResources const &resources)

void	doEndJob ()

void	doRespondToOpenInputFile (FileBlock const &fb)

void	doRespondToCloseInputFile (FileBlock const &fb)

void	doRespondToOpenOutputFiles (FileBlock const &fb)

void	doRespondToCloseOutputFiles (FileBlock const &fb)

bool	doBeginRun (RunPrincipal &rp, ModuleContext const &mc)

bool	doEndRun (RunPrincipal &rp, ModuleContext const &mc)

bool	doBeginSubRun (SubRunPrincipal &srp, ModuleContext const &mc)

bool	doEndSubRun (SubRunPrincipal &srp, ModuleContext const &mc)

bool	doEvent (EventPrincipal &ep, ModuleContext const &mc, std::atomic< std::size_t > &counts_run, std::atomic< std::size_t > &counts_passed, std::atomic< std::size_t > &counts_failed)

Public Member Functions inherited from art::Modifier
	~Modifier () noexcept

	Modifier ()

	Modifier (Modifier const &)=delete

	Modifier (Modifier &&)=delete

Modifier &	operator= (Modifier const &)=delete

Modifier &	operator= (Modifier &&)=delete

Public Member Functions inherited from art::ModuleBase
virtual	~ModuleBase () noexcept

	ModuleBase ()

ModuleDescription const &	moduleDescription () const

void	setModuleDescription (ModuleDescription const &)

std::array< std::vector< ProductInfo >, NumBranchTypes > const &	getConsumables () const

void	sortConsumables (std::string const &current_process_name)

template<typename T , BranchType BT>
ViewToken< T >	consumesView (InputTag const &tag)

template<typename T , BranchType BT>
ViewToken< T >	mayConsumeView (InputTag const &tag)

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

Additional Inherited Members
Public Types inherited from art::EDProducer
using	ModuleType = EDProducer

using	WorkerType = WorkerT< EDProducer >

Public Types inherited from art::detail::Producer
template<typename UserConfig , typename KeysToIgnore = void>
using	Table = Modifier::Table< UserConfig, KeysToIgnore >

Public Types inherited from art::Modifier
template<typename UserConfig , typename UserKeysToIgnore = void>
using	Table = ProducerTable< UserConfig, detail::ModuleConfig, UserKeysToIgnore >

Static Public Member Functions inherited from art::EDProducer
static void	commitEvent (EventPrincipal &ep, Event &e)

Protected Member Functions inherited from art::ModuleBase
ConsumesCollector &	consumesCollector ()

template<typename T , BranchType = InEvent>
ProductToken< T >	consumes (InputTag const &)

template<typename Element , BranchType = InEvent>
ViewToken< Element >	consumesView (InputTag const &)

template<typename T , BranchType = InEvent>
void	consumesMany ()

template<typename T , BranchType = InEvent>
ProductToken< T >	mayConsume (InputTag const &)

template<typename Element , BranchType = InEvent>
ViewToken< Element >	mayConsumeView (InputTag const &)

template<typename T , BranchType = InEvent>
void	mayConsumeMany ()

Detailed Description

Definition at line 37 of file OptDetDigitizer_module.cc.

Constructor & Destructor Documentation

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

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 )

overrideprivatevirtual

Implements art::EDProducer.

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:

larana/larana/OpticalDetector/OptDetDigitizer_module.cc

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation