Inheritance diagram for opdet::OpMCDigi:

Public Member Functions
	OpMCDigi (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	AddTimedWaveform (int time, std::vector< double > &OldPulse, std::vector< double > &NewPulse)

Private Attributes
std::string	fInputModule

float	fSampleFreq

float	fTimeBegin

float	fTimeEnd

float	fSaturationScale

float	fDarkRate

std::vector< double >	fSinglePEWaveform

CLHEP::HepRandomEngine &	fEngine

CLHEP::RandFlat	fFlatRandom

CLHEP::RandPoisson	fPoissonRandom

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 43 of file OpMCDigi_module.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 76 of file OpMCDigi_module.cc.

     : EDProducer{pset}
     , fInputModule{pset.get<std::string>("InputModule")}
       //, fQE{pset.get<double>("QE")}
     , fSaturationScale{pset.get<float>("SaturationScale")}
     , fDarkRate{pset.get<float>("DarkRate")}
       // create a default random engine; obtain the random seed from NuRandomService,
       // unless overridden in configuration with key "Seed"
     , fEngine(art::ServiceHandle<rndm::NuRandomService>{}->createEngine(*this, pset, "Seed"))
     , fFlatRandom{fEngine}
     , fPoissonRandom{fEngine}
   {
     produces<std::vector< raw::OpDetPulse> >();
 
     art::ServiceHandle<OpDigiProperties> odp;
     fSampleFreq = odp->SampleFreq();
     fTimeBegin  = odp->TimeBegin();
     fTimeEnd    = odp->TimeEnd();
     fSinglePEWaveform = odp->SinglePEWaveform();
   }

Member Function Documentation

void opdet::OpMCDigi::AddTimedWaveform	(	int	time,
		std::vector< double > &	OldPulse,
		std::vector< double > &	NewPulse
	)

private

Definition at line 100 of file OpMCDigi_module.cc.

   {
 
     if( (binTime + NewPulse.size() ) > OldPulse.size()) {
       OldPulse.resize(binTime + NewPulse.size());
     }
 
     // Add shifted NewWaveform to Waveform at pointer
     for(size_t i = 0; i!=NewPulse.size(); ++i) {
       OldPulse.at(binTime+i) += NewPulse.at(i);
     }
   }

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

overrideprivatevirtual

Implements art::EDProducer.

Definition at line 116 of file OpMCDigi_module.cc.

   {
     auto StoragePtr = std::make_unique<std::vector<raw::OpDetPulse>>();
 
     bool const fUseLitePhotons = art::ServiceHandle<sim::LArG4Parameters const>{}->UseLitePhotons();
 
     // Service for determining opdet responses
     art::ServiceHandle<opdet::OpDetResponseInterface const> odresponse;
 
     double const TimeBegin_ns  = fTimeBegin  *  1000;
     double const TimeEnd_ns    = fTimeEnd    *  1000;
     double const SampleFreq_ns = fSampleFreq /  1000;
 
     int const nSamples = ( TimeEnd_ns-TimeBegin_ns)*SampleFreq_ns;
     int const NOpChannels = odresponse->NOpChannels();
 
 
     // This vector will store all the waveforms we will make
     std::vector<std::vector<double> > PulsesFromDetPhotons(NOpChannels,std::vector<double>(nSamples,0.0));
 
     if(!fUseLitePhotons) {
       // Read in the Sim Photons
       sim::SimPhotonsCollection ThePhotCollection = sim::SimListUtils::GetSimPhotonsCollection(evt,fInputModule);
       // For every OpDet:
       for(auto const& pr : ThePhotCollection) {
         const sim::SimPhotons& ThePhot=pr.second;
 
         int const Ch = ThePhot.OpChannel();
         int readoutCh;
 
         // For every photon in the hit:
         for(const sim::OnePhoton& Phot: ThePhot) {
           // Sample a random subset according to QE
           if(!odresponse->detected(Ch, Phot, readoutCh)) {
             continue;
           }
 
           // Convert photon arrival time to the appropriate bin,
           // dictated by fSampleFreq. Photon arrival time is in ns,
           // beginning time in us, and sample frequency in MHz. Notice
           // that we have to accommodate for the beginning time
           if((Phot.Time > TimeBegin_ns) && (Phot.Time < TimeEnd_ns)) {
             auto const binTime = static_cast<int>((Phot.Time - TimeBegin_ns) * SampleFreq_ns);
             AddTimedWaveform( binTime, PulsesFromDetPhotons[readoutCh], fSinglePEWaveform );
           }
         } // for each Photon in SimPhotons
       }
     }
     else {
       auto const photons = *evt.getValidHandle<std::vector<sim::SimPhotonsLite>>("largeant");
       // For every OpDet:
       for (auto const& photon : photons) {
         int const Ch=photon.OpChannel;
         int readoutCh;
 
         std::map<int, int> PhotonsMap = photon.DetectedPhotons;
 
         // For every photon in the hit:
         for(auto const& pr : photon.DetectedPhotons) {
           for(int i = 0; i < pr.second; i++) {
             // Sample a random subset according to QE
             if(odresponse->detectedLite(Ch, readoutCh)) {
               // Convert photon arrival time to the appropriate bin, dictated by fSampleFreq.
               // Photon arrival time is in ns, beginning time in us, and sample frequency in MHz.
               // Notice that we have to accommodate for the beginning time
               if((pr.first > TimeBegin_ns) && (pr.first < TimeEnd_ns)) {
                 auto const binTime = static_cast<int>((pr.first - TimeBegin_ns) * SampleFreq_ns);
                 AddTimedWaveform( binTime, PulsesFromDetPhotons[readoutCh], fSinglePEWaveform );
               }
             } // random QE cut
           }
         } // for each Photon in SimPhotons
       }
     }
 
     // Create vector of output objects, add dark noise and apply
     //  saturation
 
     std::vector<raw::OpDetPulse*> ThePulses(NOpChannels);
     for(int iCh=0; iCh!=NOpChannels; ++iCh) {
       PulsesFromDetPhotons[iCh].resize((TimeEnd_ns - TimeBegin_ns) * SampleFreq_ns);
 
       // Add dark noise
       double const MeanDarkPulses = fDarkRate * (fTimeEnd-fTimeBegin) / 1000000;
       unsigned const int NumberOfPulses = fPoissonRandom.fire(MeanDarkPulses);
 
       for(size_t i=0; i!=NumberOfPulses; ++i) {
         double const PulseTime = (fTimeEnd-fTimeBegin)*fFlatRandom.fire(1.0);
         int const binTime = static_cast<int>(PulseTime * fSampleFreq);
 
         AddTimedWaveform(binTime, PulsesFromDetPhotons[iCh], fSinglePEWaveform);
       }
 
       // Apply saturation for large signals
       for(size_t i=0; i!=PulsesFromDetPhotons[iCh].size(); ++i) {
         if(PulsesFromDetPhotons[iCh].at(i)>fSaturationScale) PulsesFromDetPhotons[iCh].at(i) = fSaturationScale;
       }
 
       // Produce ADC pulse of integers rather than doubles
 
       std::vector<short> shortvec;
 
       for(size_t i=0; i!=PulsesFromDetPhotons[iCh].size(); ++i) {
         // Throw randoms to fairly sample +ve and -ve side of doubles
         int ThisSample = PulsesFromDetPhotons[iCh].at(i);
         if(ThisSample>0) {
           if(fFlatRandom.fire(1.0) > (ThisSample - int(ThisSample)))
             shortvec.push_back(int(ThisSample));
           else
             shortvec.push_back(int(ThisSample)+1);
         }
         else {
           if(fFlatRandom.fire(1.0) >  (int(ThisSample)-ThisSample))
             shortvec.push_back(int(ThisSample));
           else
             shortvec.push_back(int(ThisSample)-1);
         }
       }
 
       StoragePtr->emplace_back(iCh, shortvec ,0, fTimeBegin);
 
     } // for each OpDet in SimPhotonsCollection
 
     evt.put(std::move(StoragePtr));
   }

Member Data Documentation

float opdet::OpMCDigi::fDarkRate

private

Definition at line 58 of file OpMCDigi_module.cc.

CLHEP::HepRandomEngine& opdet::OpMCDigi::fEngine

private

Definition at line 62 of file OpMCDigi_module.cc.

CLHEP::RandFlat opdet::OpMCDigi::fFlatRandom

private

Definition at line 63 of file OpMCDigi_module.cc.

std::string opdet::OpMCDigi::fInputModule

private

Definition at line 51 of file OpMCDigi_module.cc.

CLHEP::RandPoisson opdet::OpMCDigi::fPoissonRandom

private

Definition at line 64 of file OpMCDigi_module.cc.

float opdet::OpMCDigi::fSampleFreq

private

Definition at line 52 of file OpMCDigi_module.cc.

float opdet::OpMCDigi::fSaturationScale

private

Definition at line 56 of file OpMCDigi_module.cc.

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

private

Definition at line 60 of file OpMCDigi_module.cc.

float opdet::OpMCDigi::fTimeBegin

private

Definition at line 53 of file OpMCDigi_module.cc.

float opdet::OpMCDigi::fTimeEnd

private

Definition at line 54 of file OpMCDigi_module.cc.

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

larana/larana/OpticalDetector/OpMCDigi_module.cc

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation