Inheritance diagram for opdet::WaveformDigitizerSim:

Classes
struct	Config

Public Types
using	Parameters = art::EDProducer::Table< Config >

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 >

Public Member Functions
	WaveformDigitizerSim (Parameters const &config)

void	produce (art::Event &)

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	CreateSinglePEWaveform ()

double	Pulse1PE (double time_in_us) const

void	SetDefaultBeginEndTimes ()

void	CheckFHiCLParameters () const

void	AddPEsToWaveform (const sim::OpDetDivRec *dr_p, vector< double > &pdWaveform, FocusList &fls) const

void	AddLineNoise (vector< double > &waveform, const FocusList &fls)

vector< uint16_t >	Digitize (vector< double >::iterator itBegin, vector< double >::iterator itEnd) const

template<typename T >
Ranges_t	CFDTrigger (vector< T > const &wf, const FocusList &fls) const

double	Tick2us (size_t tick) const

double	Tick2ns (size_t tick) const

size_t	us2Tick (double time_in_us) const

size_t	ns2Tick (double time_in_ns) const

Private Attributes
vector< art::InputTag >	fInputTags

double	fVoltageToADC

double	fPulseLength

double	fPeakTime

double	fMaxAmplitude

double	fFrontTime

double	fBackTime

size_t	fPadding

size_t	fReadoutWindow

size_t	fPreTrigger

double	fThresholdPE

size_t	fDwindow

short	fPedestal

double	fLineNoiseRMS

int	fMaxSaturationCutOff

double	fTimeBegin

double	fTimeEnd

bool	fFullWaveformOutput

CLHEP::HepRandomEngine &	fOpDigiEngine

CLHEP::RandGauss	fRandGauss

double	fSampleFreqMHz

size_t	fPulseLengthTicks

double	fThresholdADC

vector< double >	fSinglePEWaveform

Additional Inherited Members
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 122 of file WaveformDigitizerSim_module.cc.

Member Typedef Documentation

using opdet::WaveformDigitizerSim::Parameters = art::EDProducer::Table<Config>

Definition at line 176 of file WaveformDigitizerSim_module.cc.

Constructor & Destructor Documentation

opdet::WaveformDigitizerSim::WaveformDigitizerSim ( Parameters const & config )

explicit

Definition at line 293 of file WaveformDigitizerSim_module.cc.

     : EDProducer{config}
     , fInputTags{           config().InputTags() }
 
     , fVoltageToADC{        config().VoltageToADC() }
     , fPulseLength{         config().PulseLength() }
     , fPeakTime{            config().PeakTime() }
     , fMaxAmplitude{        config().MaxAmplitude() }
     , fFrontTime{           config().FrontTime() }
     , fBackTime{            config().BackTime() }
 
     , fPadding{             config().Padding() }
     , fReadoutWindow{       config().ReadoutWindow() }
     , fPreTrigger{          config().PreTrigger() }
     , fThresholdPE{         config().Threshold() }
     , fDwindow{             config().Dwindow() }
     
     , fPedestal{            config().Pedestal() }
     , fLineNoiseRMS{        config().LineNoiseRMS() }
     , fMaxSaturationCutOff{ std::numeric_limits<int>::max() }
 
     , fFullWaveformOutput{  config().FullWaveformOutput() }
 
     , fOpDigiEngine( art::ServiceHandle<rndm::NuRandomService>()->createEngine(*this, 
                                                                                "HepJamesRandom",
                                                                                "waveformdigi", 
                                                                                config.get_PSet(), 
                                                                                "SeedWaveformDigi") )
     , fRandGauss(fOpDigiEngine)
   {
 
     // This module produces (infrastructure piece)
     produces< vector< raw::OpDetWaveform > >();
 
     for (auto tag: fInputTags) {
       consumes< vector< sim::OpDetDivRec > >(tag);
     }
 
     mf::LogInfo logger("WaveformDigitizerSim");
 
     // Get the optical clock frequency
     auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataForJob();
     fSampleFreqMHz = clockData.OpticalClock().Frequency();
     logger << "Using a sampling frequency of " << fSampleFreqMHz << " MHz" << "\n";
     
 
     // Creating a single photoelectron waveform template
     // based on fhicl configuration
     CreateSinglePEWaveform();
     logger  << "Requested pulse length of, " << fPulseLength << " us "
             << "which is " << fPulseLengthTicks << " ticks" << "\n";
     logger  << "Requested PE threshold, " << std::fixed
             << std::setprecision(2) << fThresholdPE
             << ", converted to ADC threshold "
             << std::setprecision(0) << fThresholdADC << "\n";
 
 
     // Set a dynamic range if given
     short br;
     if ( config().DynamicBitRange(br) ) {
       fMaxSaturationCutOff = pow(2, br) - 1;
       logger << "Limiting output to " << br << " bits" << "\n";
     }
 
     
     // Set earliest and latest allowed times
     std::string tsource;
     if (config().TimeBegin(fTimeBegin) && config().TimeEnd(fTimeEnd))
       tsource = "override";
     else {
       tsource = "default";
       SetDefaultBeginEndTimes();
     }
     logger << "Using " << tsource << " time limits on PD digitizer: " << fTimeBegin << " us to " << fTimeEnd << " us";
 
     // Check for valid configuration
     CheckFHiCLParameters();
   }

Member Function Documentation

void opdet::WaveformDigitizerSim::AddLineNoise	(	vector< double > &	waveform,
		const FocusList &	fls
	)

private

Definition at line 543 of file WaveformDigitizerSim_module.cc.

   {
     if (fLineNoiseRMS <= 0.0) return;
 
     for (auto p: fls.ranges) {
       for(auto k = p.first; k <= p.second; ++k){
         waveform[k] += fRandGauss.fire(0, fLineNoiseRMS);
       }
     }
   }

void opdet::WaveformDigitizerSim::AddPEsToWaveform	(	const sim::OpDetDivRec *	dr_p,
		vector< double > &	pdWaveform,
		FocusList &	fls
	)		const

private

Definition at line 508 of file WaveformDigitizerSim_module.cc.

   {
     // Vector of DivRec time bins (struct OpDet_Time_Chans)
     for (auto odtc: dr_p->GetTimeChans()) {
 
       // Extract time for this odtc within the event
       double photonTime_ns = odtc.time;
       size_t timeBin       = ns2Tick(photonTime_ns);
 
       // Check if the photon is inside the digitization range. If not, skip it.
       if ( timeBin < 0 || timeBin >= pdWaveform.size() ) {
         mf::LogWarning("WaveformDigitizerSim") << "Skipping a photon at " << photonTime_ns/1000. << " us, outside digitization window of " << fTimeBegin << " to " << fTimeEnd;
         continue;
       }
 
       // Loop through records at this time and count photons
       int nPE = 0;
       for (auto const& sdp : odtc.phots)
         nPE += sdp.phot;
 
       // Add ticks until the end of the single PE waveform or end of the whole pdWaveform
       size_t stop = std::min(fPulseLengthTicks, pdWaveform.size()-timeBin);
 
       // Add this range to the focus list
       fls.AddRange(timeBin, timeBin+stop-1);
 
       // Add the nPE pulse to the waveform
       for (size_t tick = 0; tick < stop; ++tick)
         pdWaveform[timeBin+tick] += fSinglePEWaveform[tick]*nPE;
     }
   }

template<typename T >

Ranges_t opdet::WaveformDigitizerSim::CFDTrigger	(	vector< T > const &	wf,
		const FocusList &	fls
	)		const

private

Definition at line 568 of file WaveformDigitizerSim_module.cc.

   {
 
     Ranges_t readouts;
 
     for (auto range: fls.ranges) {
       size_t  wstart = -1;
       size_t  wend   = -1;
       bool fire   = false;
 
       for (size_t tick = range.first; tick < range.second - fDwindow; ++tick) {
 
         // Fire CFD
         if (wf[tick+fDwindow] - wf[tick] > fThresholdADC) {
 
           if (!fire) {
             // Start a new readout window 
             fire   = true;
             wstart = tick-fPreTrigger;
             wend   = tick-fPreTrigger+fReadoutWindow;
           }
           else {
             // Extend the current readout window
             // Simplest to implement here, update to the
             // actual DAPHNE algorithm once known
             wend = tick-fPreTrigger+fReadoutWindow;
           }
 
         }
         else if (fire && tick >= wend) {
           // We've reached the end of a window, save it
           fire = false;
           readouts.emplace_back(wstart, wend);
         }
 
       }
 
       // Check for lingering window, add a final window
       // up to the end of the waveform if so.
       if (fire == true) {
         readouts.emplace_back(wstart, range.second-1);
       }
     }
 
     return readouts;
   }

void opdet::WaveformDigitizerSim::CheckFHiCLParameters ( ) const

private

Definition at line 418 of file WaveformDigitizerSim_module.cc.

   {
     // Check that we have input tags
     if (fInputTags.size() == 0) 
       throw art::Exception(art::errors::Configuration)
         << "No input tags were given to WaveformDigitizerSim.\n";
 
     // Sanity check the line noise
     if (fLineNoiseRMS < 0.0)
       throw art::Exception(art::errors::Configuration)
         << "fLineNoiseRMS: " << fLineNoiseRMS << '\n'
         << "Line noise RMS should be non-negative!\n";
 
     // Sanity check beginning and end times
     if (fTimeBegin >= fTimeEnd) {
       throw art::Exception(art::errors::Configuration)
         << "TimeBegin: " << fTimeBegin << " and " << "TimeEnd: "   << fTimeEnd   << '\n'
         << "TimeBegin should be less than TimeEnd!\n";
     }
   }

void opdet::WaveformDigitizerSim::CreateSinglePEWaveform ( )

private

Definition at line 373 of file WaveformDigitizerSim_module.cc.

   {
     double maxADC = 0.;
     fPulseLengthTicks = std::round(fPulseLength*fSampleFreqMHz);
     fSinglePEWaveform.resize(fPulseLengthTicks);
 
     for (size_t tick = 0; tick < fPulseLengthTicks; ++tick) {
       double val = Pulse1PE(static_cast< double >(tick)/fSampleFreqMHz);
       fSinglePEWaveform[tick] = val;
       if (val > maxADC) maxADC = val;
     }
 
     // Set the ADC threshold based on the PE threshold
     fThresholdADC = fThresholdPE * maxADC;
   }

vector< uint16_t > opdet::WaveformDigitizerSim::Digitize	(	vector< double >::iterator	itBegin,
		vector< double >::iterator	itEnd
	)		const

private

Definition at line 555 of file WaveformDigitizerSim_module.cc.

   {
     for(auto it = itBegin; it != itEnd; ++it) {
       if(*it > fMaxSaturationCutOff) 
         *it = fMaxSaturationCutOff; 
     }
 
     // Don't bother to round properly, it's faster this way
     return vector< uint16_t >(itBegin, itEnd);
   }

size_t opdet::WaveformDigitizerSim::ns2Tick ( double time_in_ns ) const

inlineprivate

Definition at line 272 of file WaveformDigitizerSim_module.cc.

272 { return us2Tick(time_in_ns/1000.); };

opdet::WaveformDigitizerSim::us2Tick

size_t us2Tick(double time_in_us) const

Definition: WaveformDigitizerSim_module.cc:271

void opdet::WaveformDigitizerSim::produce ( art::Event & event )

virtual

Implements art::EDProducer.

Definition at line 448 of file WaveformDigitizerSim_module.cc.

   {
     // A pointer that will store produced OpDetWaveforms
     auto wave_forms_p = std::make_unique< vector< raw::OpDetWaveform > >();
 
     // Total number of ticks in the whole event
     unsigned int nSamples = (fTimeEnd - fTimeBegin)*fSampleFreqMHz;
 
     // First, pull all of the DivRec handles from the event, and collect up
     // all DivRecs on the same channel into a single vector
     std::map< int, vector<const sim::OpDetDivRec *> > DivRecsByChannel;
     for (auto tag: fInputTags) {
       auto dr_handle = event.getHandle< vector< sim::OpDetDivRec > >(tag);
       if (!dr_handle) {
         mf::LogWarning("WaveformDigitizerSim") << "Could not load OpDetDivRecs " << tag << ". Skipping.";
         continue;
       }
       for (auto const& dr : *dr_handle) {
         DivRecsByChannel[dr.OpDetNum()].push_back( &dr );
       }
     }
 
     // Now, loop through channels, treating all photons on a cha
     for (auto const& [opDet, vDivRecs]: DivRecsByChannel)
     {
       // Create the empty waveform vector and focus list
       vector< double > pdWaveform(nSamples, fPedestal);
       FocusList fls(nSamples, fPadding);
 
       // Add a PE template to the waveform for each true photon
       for (auto dr_p: vDivRecs) AddPEsToWaveform(dr_p, pdWaveform, fls);
 
       // So that line noise is added to all ticks in full output mode
       if (fFullWaveformOutput)  fls.everything(); 
 
       // Add line noise
       AddLineNoise(pdWaveform, fls);
 
       if (fFullWaveformOutput) {
         wave_forms_p->emplace_back(Tick2us(0), opDet, Digitize(pdWaveform.begin(), pdWaveform.end()));
       }
       else {
         // Checking for tiggers on floats, rather than shorts.
         // This is an approximation, but it saves making an extra copy
         // of the waveform and makes the code easier to follow.
         for ( auto t: CFDTrigger(pdWaveform, fls) ) {
 
           // Digitize and store
           auto shortWF = Digitize(pdWaveform.begin()+t.first, pdWaveform.begin()+t.second+1);
           wave_forms_p->emplace_back(Tick2us(t.first), opDet,  shortWF);
         }
       }
     }
 
     // Push the OpDetWaveforms into the event
     event.put(std::move(wave_forms_p));
 
   }

double opdet::WaveformDigitizerSim::Pulse1PE ( double time_in_us ) const

private

Definition at line 390 of file WaveformDigitizerSim_module.cc.

   {
 
     if (time_in_us < fPeakTime) 
       return (fVoltageToADC*fMaxAmplitude*std::exp((time_in_us - fPeakTime)/fFrontTime));
     else 
       return (fVoltageToADC*fMaxAmplitude*std::exp(-(time_in_us - fPeakTime)/fBackTime));
 
   }

void opdet::WaveformDigitizerSim::SetDefaultBeginEndTimes ( )

private

Definition at line 401 of file WaveformDigitizerSim_module.cc.

   {
     // A little wasteful to get clockData again, but only happens once per job
     auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataForJob();
     auto const detProp   = art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataForJob(clockData);
 
     // Take the TPC readout window size and convert to us with the electronics
     // clock frequency, adding 5 us of padding
     fTimeEnd   = detProp.ReadOutWindowSize() / clockData.TPCClock().Frequency() + 5;
 
     // Assume the readout is symmetrical around 0
     fTimeBegin = -1.*fTimeEnd;
 
   }