Inheritance diagram for detsim::SimWire:

Public Types
using	ModuleType = EDProducer

template<typename UserConfig , typename KeysToIgnore = void>
using	Table = Modifier::Table< UserConfig, KeysToIgnore >

Public Member Functions
	SimWire (fhicl::ParameterSet const &pset)

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)

void	fillProductDescriptions ()

void	registerProducts (ProductDescriptions &productsToRegister)

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)

std::unique_ptr< Worker >	makeWorker (WorkerParams const &wp)

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

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

Protected Member Functions
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 ()

Private Member Functions
void	produce (art::Event &evt) override

void	beginJob () override

void	ConvoluteResponseFunctions ()
	convolute electronics and field response More...

void	SetFieldResponse ()
	response of wires to field More...

void	SetElectResponse ()
	response of electronics More...

void	GenNoise (std::vector< float > &array, CLHEP::HepRandomEngine &engine)

Private Attributes
std::string	fDriftEModuleLabel
	module making the ionization electrons More...

raw::Compress_t	fCompression
	compression type to use More...

int	fNTicks
	number of ticks of the clock More...

double	fSampleRate
	sampling rate in ns More...

unsigned int	fNSamplesReadout
	number of ADC readout samples in 1 readout frame More...

double	fCol3DCorrection

double	fInd3DCorrection

unsigned int	fNElectResp
	number of entries from response to use More...

double	fInputFieldRespSamplingPeriod
	Sampling period in the input field response. More...

double	fShapeTimeConst
	time constants for exponential shaping More...

double	fADCPerPCAtLowestASICGain
	ADCs/pC at lowest gain setting of 4.7 mV/fC. More...

double	fASICGainInMVPerFC
	actual gain setting used in mV/fC More...

int	fNoiseNchToSim
	number of noise channels to generate More...

std::string	fNoiseModelChoice
	choice for noise model More...

std::string	fNoiseFluctChoice
	choice for noise freq component mag fluctuations More...

std::vector< int >	fFieldRespTOffset
	field response time offset in ticks More...

std::vector< int >	fCalibRespTOffset
	calib response time offset in ticks More...

std::vector< float >	fColFieldParams
	collection plane field function parameterization More...

std::vector< float >	fIndFieldParams
	induction plane field function parameterization More...

std::vector< double >	fColFieldResponse
	response function for the field @ collection plane More...

std::vector< double >	fIndFieldResponse
	response function for the field @ induction plane More...

std::vector< TComplex >	fColShape
	response function for the field @ collection plane More...

std::vector< TComplex >	fIndShape
	response function for the field @ induction plane More...

std::vector< double >	fElectResponse
	response function for the electronics More...

std::vector< std::vector< float > >	fNoise
	noise on each channel for each time More...

std::vector< double >	fNoiseModelPar
	noise model params More...

std::vector< double >	fNoiseFluctPar
	Poisson noise fluctuations params. More...

TH1D *	fIndFieldResp
	response function for the field @ induction plane More...

TH1D *	fColFieldResp
	response function for the field @ collection plane More...

TH1D *	fElectResp
	response function for the electronics More...

TH1D *	fColTimeShape
	convoluted shape for field x electronics @ col plane More...

TH1D *	fIndTimeShape
	convoluted shape for field x electronics @ ind plane More...

TH1D *	fNoiseDist
	distribution of noise counts More...

TF1 *	fNoiseFluct
	Poisson dist for fluctuations in magnitude of noise freq components. More...

CLHEP::HepRandomEngine &	fEngine
	Random-number engine owned by art. More...

Detailed Description

Definition at line 69 of file SimWire_module.cc.

Member Typedef Documentation

using art::EDProducer::ModuleType = EDProducer

inherited

Definition at line 17 of file EDProducer.h.

template<typename UserConfig , typename KeysToIgnore = void>

using art::detail::Producer::Table = Modifier::Table<UserConfig, KeysToIgnore>

inherited

Definition at line 26 of file Producer.h.

Constructor & Destructor Documentation

detsim::SimWire::SimWire ( fhicl::ParameterSet const & pset )

explicit

Definition at line 132 of file SimWire_module.cc.

References art::detail::EngineCreator::createEngine(), fADCPerPCAtLowestASICGain, fASICGainInMVPerFC, fCalibRespTOffset, fCol3DCorrection, fColFieldParams, fCompression, fDriftEModuleLabel, fEngine, fFieldRespTOffset, fInd3DCorrection, fIndFieldParams, fInputFieldRespSamplingPeriod, fNoiseFluctChoice, fNoiseFluctPar, fNoiseModelChoice, fNoiseModelPar, fNoiseNchToSim, fNSamplesReadout, fSampleRate, fShapeTimeConst, raw::kHuffman, raw::kNone, MF_LOG_WARNING, and detinfo::sampling_rate().

     : EDProducer{pset}
     , fDriftEModuleLabel{pset.get<std::string>("DriftEModuleLabel")}
     , fCompression{pset.get<std::string>("CompressionType") == "Huffman" ? raw::kHuffman :
                                                                            raw::kNone}
     , fCol3DCorrection{pset.get<double>("Col3DCorrection")}
     , fInd3DCorrection{pset.get<double>("Ind3DCorrection")}
     , fInputFieldRespSamplingPeriod{pset.get<double>("InputFieldRespSamplingPeriod")}
     , fShapeTimeConst{pset.get<double>("ShapeTimeConst")}
     , fADCPerPCAtLowestASICGain{pset.get<double>("ADCPerPCAtLowestASICGain")}
     , fASICGainInMVPerFC{pset.get<double>("ASICGainInMVPerFC")}
     , fNoiseNchToSim{pset.get<int>("NoiseNchToSim")}
     , fNoiseModelChoice{pset.get<std::string>("NoiseModelChoice")}
     , fNoiseFluctChoice{pset.get<std::string>("NoiseFluctChoice")}
     , fFieldRespTOffset{pset.get<std::vector<int>>("FieldRespTOffset")}
     , fCalibRespTOffset{pset.get<std::vector<int>>("CalibRespTOffset")}
     , fColFieldParams{pset.get<std::vector<float>>("ColFieldParams")}
     , fIndFieldParams{pset.get<std::vector<float>>("IndFieldParams")}
     , fNoiseModelPar{pset.get<std::vector<double>>("NoiseModelPar")}
     , fNoiseFluctPar{pset.get<std::vector<double>>("NoiseFluctPar")}
     // create a default random engine; obtain the random seed from NuRandomService,
     // unless overridden in configuration with key "Seed"
     , fEngine(art::ServiceHandle<rndm::NuRandomService>()->registerAndSeedEngine(createEngine(0),
                                                                                  pset,
                                                                                  "Seed"))
   {
     auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataForJob();
     auto const detProp =
       art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataForJob(clockData);
     fSampleRate = sampling_rate(clockData);
     fNSamplesReadout = detProp.NumberTimeSamples();
 
     MF_LOG_WARNING("SimWire") << "SimWire is an example module that works for the "
                               << "MicroBooNE detector.  Each experiment should implement "
                               << "its own version of this module to simulate electronics "
                               << "response.";
 
     produces<std::vector<raw::RawDigit>>();
   }

Member Function Documentation

void detsim::SimWire::beginJob ( )

overrideprivatevirtual

Reimplemented from art::EDProducer.

Definition at line 173 of file SimWire_module.cc.

References ConvoluteResponseFunctions(), fEngine, util::LArFFT::FFTSize(), fNoise, fNoiseDist, fNoiseFluct, fNoiseFluctChoice, fNoiseFluctPar, fNoiseNchToSim, fNTicks, GenNoise(), SetElectResponse(), and SetFieldResponse().

   {
     // ... get access to the TFile service
     art::ServiceHandle<art::TFileService const> tfs;
 
     fNoiseDist = tfs->make<TH1D>("Noise", ";Noise (ADC);", 1000, -10., 10.);
 
     art::ServiceHandle<util::LArFFT const> fFFT;
     fNTicks = fFFT->FFTSize();
 
     // ... Poisson dist function for fluctuating magnitude of noise frequency component
     if (fNoiseFluctChoice == "SimplePoisson") {
       // .. simple modified Poisson with (x-1)! in denominator
       fNoiseFluct = new TF1("_poisson", "[0]**(x) * exp(-[0]) / ROOT::Math::tgamma(x)", 0, 5.);
       fNoiseFluct->SetParameters(fNoiseFluctPar[0]); // Poisson mean
     }
     else if (fNoiseFluctChoice == "WeightedPoisson") {
       // .. weighted Poisson in ArgoNeuT DDN model
       fNoiseFluct = new TF1(
         "_poisson", "[0]*pow([1]/[2], x/[2])*exp(-[1]/[2])/ROOT::Math::tgamma(x/[2]+1.)", 0, 5.);
       fNoiseFluct->SetParameters(fNoiseFluctPar[0], fNoiseFluctPar[1], fNoiseFluctPar[2]);
     }
     else {
       throw cet::exception("SimWire::beginJob")
         << fNoiseFluctChoice << " is an unknown noise fluctuation choice" << std::endl;
     }
 
     // ... generate the noise in advance depending on value of fNoiseNchToSim:
     //     positive - generate N=fNoiseNchToSim channels & randomly pick from pool when adding to signal
     //     zero     - no noise
     //     negative - generate unique noise for each channel for each event
     if (fNoiseNchToSim > 0) {
       if (fNoiseNchToSim > 10000) {
         throw cet::exception("SimWire::beginJob")
           << fNoiseNchToSim << " noise channels requested exceeds 10000" << std::endl;
       }
       fNoise.resize(fNoiseNchToSim);
       for (unsigned int p = 0; p < fNoise.size(); ++p) {
         GenNoise(fNoise[p], fEngine);
         for (int i = 0; i < fNTicks; ++i) {
           fNoiseDist->Fill(fNoise[p][i]);
         }
       }
     }
 
     // ... set field response and electronics response, then convolute them
     SetFieldResponse();
     SetElectResponse();
     ConvoluteResponseFunctions();
   }

template<typename T , BranchType BT>

ProductToken< T > art::ModuleBase::consumes ( InputTag const & tag )

protectedinherited

Definition at line 61 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::consumes().

   {
     return collector_.consumes<T, BT>(tag);
   }

ConsumesCollector & art::ModuleBase::consumesCollector ( )

protectedinherited

Definition at line 57 of file ModuleBase.cc.

References art::ModuleBase::collector_.

   {
     return collector_;
   }

template<typename T , BranchType BT>

void art::ModuleBase::consumesMany ( )

protectedinherited

Definition at line 75 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::consumesMany().

   {
     collector_.consumesMany<T, BT>();
   }

template<typename Element , BranchType = InEvent>

ViewToken<Element> art::ModuleBase::consumesView ( InputTag const & )

protectedinherited

template<typename T , BranchType BT>

ViewToken<T> art::ModuleBase::consumesView ( InputTag const & tag )

inherited

Definition at line 68 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::consumesView().

   {
     return collector_.consumesView<T, BT>(tag);
   }

void detsim::SimWire::ConvoluteResponseFunctions ( )

private

convolute electronics and field response

Definition at line 335 of file SimWire_module.cc.

References col, util::LArFFT::DoFFT(), util::LArFFT::DoInvFFT(), fColFieldResponse, fColShape, fColTimeShape, fElectResponse, fIndFieldResponse, fIndShape, fIndTimeShape, fNTicks, util::LArFFT::PeakCorrelation(), and util::LArFFT::ShiftData().

Referenced by beginJob().

   {
     double tick, ticks, peak;
 
     std::vector<double> col(fNTicks, 0.);
     std::vector<double> ind(fNTicks, 0.);
     std::vector<TComplex> kern(fNTicks / 2 + 1);
     std::vector<double> delta(fNTicks, 0.);
 
     art::ServiceHandle<util::LArFFT> fFFT;
 
     // ... do collection plane
     fColShape.resize(fNTicks / 2 + 1);
     fFFT->DoFFT(fElectResponse, fColShape);
 
     fFFT->DoFFT(fColFieldResponse, kern);
     for (unsigned int i = 0; i < kern.size(); ++i)
       fColShape[i] *= kern[i];
 
     fFFT->DoInvFFT(fColShape, col);
 
     delta[0] = 1.0;
     peak = fFFT->PeakCorrelation(delta, col);
     tick = 0.;
     ticks = tick - peak;
     fFFT->ShiftData(fColShape, ticks);
     fFFT->DoInvFFT(fColShape, col);
 
     // ... do induction plane
     fIndShape.resize(fNTicks / 2 + 1);
     fFFT->DoFFT(fElectResponse, fIndShape);
 
     kern.clear();
     kern.resize(fNTicks / 2 + 1);
     fFFT->DoFFT(fIndFieldResponse, kern);
     for (unsigned int i = 0; i < kern.size(); ++i)
       fIndShape[i] *= kern[i];
 
     fFFT->DoInvFFT(fIndShape, ind);
 
     delta.resize(0);
     delta.resize(fNTicks, 0);
     delta[0] = 1.0;
     peak = fFFT->PeakCorrelation(delta, ind);
     tick = 0.;
     ticks = tick - peak;
     fFFT->ShiftData(fIndShape, ticks);
     fFFT->DoInvFFT(fIndShape, ind);
 
     // ... write the time-domain shapes out to a file
     art::ServiceHandle<art::TFileService const> tfs;
     fColTimeShape = tfs->make<TH1D>(
       "ConvolutedCollection", ";ticks; Electronics#timesCollection", fNTicks, 0, fNTicks);
     fIndTimeShape = tfs->make<TH1D>(
       "ConvolutedInduction", ";ticks; Electronics#timesInduction", fNTicks, 0, fNTicks);
 
     // ... check that you did the right thing
     for (unsigned int i = 0; i < ind.size(); ++i) {
       fColTimeShape->Fill(i, col[i]);
       fIndTimeShape->Fill(i, ind[i]);
     }
 
     fColTimeShape->Write();
     fIndTimeShape->Write();
   }

void art::detail::Producer::doBeginJob ( SharedResources const & resources )

inherited

Definition at line 22 of file Producer.cc.

References art::detail::Producer::beginJobWithFrame(), and art::detail::Producer::setupQueues().

   {
     setupQueues(resources);
     ProcessingFrame const frame{ScheduleID{}};
     beginJobWithFrame(frame);
   }

bool art::detail::Producer::doBeginRun	(	RunPrincipal &	rp,
		ModuleContext const &	mc
	)

inherited

Definition at line 65 of file Producer.cc.

References art::detail::Producer::beginRunWithFrame(), art::RangeSet::forRun(), art::RunPrincipal::makeRun(), r, art::RunPrincipal::runID(), and art::ModuleContext::scheduleID().

   {
     auto r = rp.makeRun(mc, RangeSet::forRun(rp.runID()));
     ProcessingFrame const frame{mc.scheduleID()};
     beginRunWithFrame(r, frame);
     r.commitProducts();
     return true;
   }

bool art::detail::Producer::doBeginSubRun	(	SubRunPrincipal &	srp,
		ModuleContext const &	mc
	)

inherited

Definition at line 85 of file Producer.cc.

References art::detail::Producer::beginSubRunWithFrame(), art::RangeSet::forSubRun(), art::SubRunPrincipal::makeSubRun(), art::ModuleContext::scheduleID(), and art::SubRunPrincipal::subRunID().

   {
     auto sr = srp.makeSubRun(mc, RangeSet::forSubRun(srp.subRunID()));
     ProcessingFrame const frame{mc.scheduleID()};
     beginSubRunWithFrame(sr, frame);
     sr.commitProducts();
     return true;
   }

void art::detail::Producer::doEndJob ( )

inherited

Definition at line 30 of file Producer.cc.

References art::detail::Producer::endJobWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     endJobWithFrame(frame);
   }

bool art::detail::Producer::doEndRun	(	RunPrincipal &	rp,
		ModuleContext const &	mc
	)

inherited

Definition at line 75 of file Producer.cc.

References art::detail::Producer::endRunWithFrame(), art::RunPrincipal::makeRun(), r, art::ModuleContext::scheduleID(), and art::Principal::seenRanges().

   {
     auto r = rp.makeRun(mc, rp.seenRanges());
     ProcessingFrame const frame{mc.scheduleID()};
     endRunWithFrame(r, frame);
     r.commitProducts();
     return true;
   }

bool art::detail::Producer::doEndSubRun	(	SubRunPrincipal &	srp,
		ModuleContext const &	mc
	)

inherited

Definition at line 95 of file Producer.cc.

References art::detail::Producer::endSubRunWithFrame(), art::SubRunPrincipal::makeSubRun(), art::ModuleContext::scheduleID(), and art::Principal::seenRanges().

   {
     auto sr = srp.makeSubRun(mc, srp.seenRanges());
     ProcessingFrame const frame{mc.scheduleID()};
     endSubRunWithFrame(sr, frame);
     sr.commitProducts();
     return true;
   }

bool art::detail::Producer::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
	)

inherited

Definition at line 105 of file Producer.cc.

References art::detail::Producer::checkPutProducts_, e, art::EventPrincipal::makeEvent(), art::detail::Producer::produceWithFrame(), and art::ModuleContext::scheduleID().

   {
     auto e = ep.makeEvent(mc);
     ++counts_run;
     ProcessingFrame const frame{mc.scheduleID()};
     produceWithFrame(e, frame);
     e.commitProducts(checkPutProducts_, &expectedProducts<InEvent>());
     ++counts_passed;
     return true;
   }

void art::detail::Producer::doRespondToCloseInputFile ( FileBlock const & fb )

inherited

Definition at line 44 of file Producer.cc.

References art::detail::Producer::respondToCloseInputFileWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     respondToCloseInputFileWithFrame(fb, frame);
   }

void art::detail::Producer::doRespondToCloseOutputFiles ( FileBlock const & fb )

inherited

Definition at line 58 of file Producer.cc.

References art::detail::Producer::respondToCloseOutputFilesWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     respondToCloseOutputFilesWithFrame(fb, frame);
   }

void art::detail::Producer::doRespondToOpenInputFile ( FileBlock const & fb )

inherited

Definition at line 37 of file Producer.cc.

References art::detail::Producer::respondToOpenInputFileWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     respondToOpenInputFileWithFrame(fb, frame);
   }

void art::detail::Producer::doRespondToOpenOutputFiles ( FileBlock const & fb )

inherited

Definition at line 51 of file Producer.cc.

References art::detail::Producer::respondToOpenOutputFilesWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     respondToOpenOutputFilesWithFrame(fb, frame);
   }

void art::Modifier::fillProductDescriptions ( )

inherited

Definition at line 10 of file Modifier.cc.

References art::ProductRegistryHelper::fillDescriptions(), and art::ModuleBase::moduleDescription().

   {
     ProductRegistryHelper::fillDescriptions(moduleDescription());
   }

void detsim::SimWire::GenNoise	(	std::vector< float > &	array,
		CLHEP::HepRandomEngine &	engine
	)

private

Definition at line 402 of file SimWire_module.cc.

References util::LArFFT::DoInvFFT(), fNoiseFluct, fNoiseModelChoice, fNoiseModelPar, fNTicks, fSampleRate, and x.

Referenced by beginJob(), and produce().

   {
     CLHEP::RandFlat flat(engine);
 
     noise.clear();
     noise.resize(fNTicks, 0.);
     std::vector<TComplex> noiseFrequency(fNTicks / 2 + 1, 0.); // noise in frequency space
 
     double pval = 0.;
     double phase = 0.;
     double rnd[2] = {0.};
 
     // .. width of frequencyBin in kHz
     double binWidth = 1.0 / (fNTicks * fSampleRate * 1.0e-6);
 
     for (int i = 0; i < fNTicks / 2 + 1; ++i) {
 
       double x = (i + 0.5) * binWidth;
 
       if (fNoiseModelChoice == "Legacy") {
         // ... Legacy exponential model kept here for reference:
         //     par[0]=NoiseFact, par[1]=NoiseWidth, par[2]=LowCutoff, par[3-7]=0
         //     example parameter values for fcl: NoiseModelPar:[ 1.32e-1,120,7.5,0,0,0,0,0 ]
         pval = fNoiseModelPar[0] * exp(-(double)i * binWidth / fNoiseModelPar[1]);
         double lofilter = 1.0 / (1.0 + exp(-(i - fNoiseModelPar[2] / binWidth) / 0.5));
         flat.fireArray(1, rnd, 0, 1);
         pval *= lofilter * (0.9 + 0.2 * rnd[0]);
       }
       else if (fNoiseModelChoice == "ModUBooNE") {
         // ... Modified uBooNE model with additive exp to account for low freq region:
         //     example parameter values for fcl: NoiseModelPar:[
         //                                         4450.,-530.,280.,110.,
         //                                         -0.85,18.,0.064,74. ]
         pval = fNoiseModelPar[0] * exp(-0.5 * pow((x - fNoiseModelPar[1]) / fNoiseModelPar[2], 2)) *
                  exp(-0.5 * pow(x / fNoiseModelPar[3], fNoiseModelPar[4])) +
                fNoiseModelPar[5] + exp(-fNoiseModelPar[6] * (x - fNoiseModelPar[7]));
         double randomizer = fNoiseFluct->GetRandom();
         pval = pval * randomizer / fNTicks;
       }
       else if (fNoiseModelChoice == "ArgoNeuT") {
         // ... ArgoNeuT data driven model:
         //     In fcl set parameters to: NoiseModelPar:[
         //                                 5000,-5.52058e2,2.81587e2,-5.66561e1,
         //                                 4.10817e1,1.76284e1,1e-1,5.97838e1 ]
         pval = fNoiseModelPar[0] * exp(-0.5 * pow((x - fNoiseModelPar[1]) / fNoiseModelPar[2], 2)) *
                  ((fNoiseModelPar[3] / (x + fNoiseModelPar[4])) + 1) +
                fNoiseModelPar[5] + exp(-fNoiseModelPar[6] * (x - fNoiseModelPar[7]));
         double randomizer = fNoiseFluct->GetRandom();
         pval = pval * randomizer / fNTicks;
       }
       else {
         throw cet::exception("SimWire::GenNoise")
           << fNoiseModelChoice << " is an unknown choice for the noise model" << std::endl;
       }
 
       flat.fireArray(1, rnd, 0, 1);
       phase = rnd[0] * 2. * TMath::Pi();
 
       TComplex tc(pval * cos(phase), pval * sin(phase));
       noiseFrequency[i] += tc;
     }
 
     // .. inverse FFT MCSignal
     art::ServiceHandle<util::LArFFT> fFFT;
     fFFT->DoInvFFT(noiseFrequency, noise);
 
     noiseFrequency.clear();
 
     // .. multiply each noise value by fNTicks as the InvFFT
     //    divides each bin by fNTicks assuming that a forward FFT
     //    has already been done.
     for (unsigned int i = 0; i < noise.size(); ++i)
       noise[i] *= 1. * fNTicks;
   }

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

inherited

Definition at line 43 of file ModuleBase.cc.

References art::ModuleBase::collector_, and art::ConsumesCollector::getConsumables().

   {
     return collector_.getConsumables();
   }

std::unique_ptr< Worker > art::ModuleBase::makeWorker ( WorkerParams const & wp )

inherited

Definition at line 37 of file ModuleBase.cc.

References art::ModuleBase::doMakeWorker(), and art::NumBranchTypes.

   {
     return doMakeWorker(wp);
   }

template<typename T , BranchType BT>

ProductToken< T > art::ModuleBase::mayConsume ( InputTag const & tag )

protectedinherited

Definition at line 82 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::mayConsume().

   {
     return collector_.mayConsume<T, BT>(tag);
   }

template<typename T , BranchType BT>

void art::ModuleBase::mayConsumeMany ( )

protectedinherited

Definition at line 96 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::mayConsumeMany().

   {
     collector_.mayConsumeMany<T, BT>();
   }

template<typename Element , BranchType = InEvent>

ViewToken<Element> art::ModuleBase::mayConsumeView ( InputTag const & )

protectedinherited

template<typename T , BranchType BT>

ViewToken<T> art::ModuleBase::mayConsumeView ( InputTag const & tag )

inherited

Definition at line 89 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::mayConsumeView().

   {
     return collector_.mayConsumeView<T, BT>(tag);
   }

ModuleDescription const & art::ModuleBase::moduleDescription ( ) const

inherited

Definition at line 13 of file ModuleBase.cc.

References art::errors::LogicError.

Referenced by art::OutputModule::doRespondToOpenInputFile(), art::OutputModule::doWriteEvent(), art::Modifier::fillProductDescriptions(), art::OutputModule::makePlugins_(), art::OutputWorker::OutputWorker(), reco::shower::LArPandoraModularShowerCreation::produce(), art::Modifier::registerProducts(), and art::OutputModule::registerProducts().

   {
     if (md_.has_value()) {
       return *md_;
     }
 
     throw Exception{errors::LogicError,
                     "There was an error while calling moduleDescription().\n"}
       << "The moduleDescription() base-class member function cannot be called\n"
          "during module construction.  To determine which module is "
          "responsible\n"
          "for calling it, find the '<module type>:<module "
          "label>@Construction'\n"
          "tag in the message prefix above.  Please contact artists@fnal.gov\n"
          "for guidance.\n";
   }

void detsim::SimWire::produce ( art::Event & evt )

overrideprivatevirtual

Implements art::EDProducer.

Definition at line 225 of file SimWire_module.cc.

References sim::SimChannel::Charge(), raw::Compress(), fCalibRespTOffset, fColShape, fCompression, fDriftEModuleLabel, fEngine, fFieldRespTOffset, fIndShape, fNoise, fNoiseNchToSim, fNSamplesReadout, fNTicks, GenNoise(), Get, art::ProductRetriever::getView(), geo::kInduction, art::Event::put(), and sc.

   {
     auto const& wireReadoutGeom = art::ServiceHandle<geo::WireReadout const>()->Get();
     auto const nchannels = wireReadoutGeom.Nchannels();
 
     // ... generate unique noise for each channel in each event
     if (fNoiseNchToSim < 0) {
       fNoise.clear();
       fNoise.resize(nchannels);
       for (unsigned int p = 0; p < nchannels; ++p) {
         GenNoise(fNoise[p], fEngine);
       }
     }
 
     // ... make a vector of const sim::SimChannel* that has same number
     //     of entries as the number of channels in the detector
     //     and set the entries for the channels that have signal on them
     //     using the chanHandle
     std::vector<const sim::SimChannel*> chanHandle;
     evt.getView(fDriftEModuleLabel, chanHandle);
 
     std::vector<const sim::SimChannel*> channels(nchannels);
     for (size_t c = 0; c < chanHandle.size(); ++c) {
       channels[chanHandle[c]->Channel()] = chanHandle[c];
     }
 
     // ... make an unique_ptr of sim::SimDigits that allows ownership of the produced
     //     digits to be transferred to the art::Event after the put statement below
     auto digcol = std::make_unique<std::vector<raw::RawDigit>>();
 
     art::ServiceHandle<util::LArFFT> fFFT;
 
     // ... Add all channels
     CLHEP::RandFlat flat(fEngine);
 
     std::map<int, double>::iterator mapIter;
     for (unsigned int chan = 0; chan < nchannels; chan++) {
 
       std::vector<short> adcvec(fNTicks, 0);
       std::vector<double> fChargeWork(fNTicks, 0.);
 
       if (channels[chan]) {
 
         // .. get the sim::SimChannel for this channel
         const sim::SimChannel* sc = channels[chan];
 
         // .. loop over the tdcs and grab the number of electrons for each
         for (int t = 0; t < fNTicks; ++t)
           fChargeWork[t] = sc->Charge(t);
 
         int time_offset = 0;
 
         // .. Convolve charge with appropriate response function
         if (wireReadoutGeom.SignalType(chan) == geo::kInduction) {
           fFFT->Convolute(fChargeWork, fIndShape);
           time_offset = fFieldRespTOffset[1] + fCalibRespTOffset[1];
         }
         else {
           fFFT->Convolute(fChargeWork, fColShape);
           time_offset = fFieldRespTOffset[0] + fCalibRespTOffset[0];
         }
 
         // .. Apply field response offset
         std::vector<int> temp;
         if (time_offset <= 0) {
           temp.assign(fChargeWork.begin(), fChargeWork.begin() - time_offset);
           fChargeWork.erase(fChargeWork.begin(), fChargeWork.begin() - time_offset);
           fChargeWork.insert(fChargeWork.end(), temp.begin(), temp.end());
         }
         else {
           temp.assign(fChargeWork.end() - time_offset, fChargeWork.end());
           fChargeWork.erase(fChargeWork.end() - time_offset, fChargeWork.end());
           fChargeWork.insert(fChargeWork.begin(), temp.begin(), temp.end());
         }
       }
 
       // ... Add noise to signal depending on value of fNoiseNchToSim
       if (fNoiseNchToSim != 0) {
         int noisechan = chan;
         if (fNoiseNchToSim > 0) {
           noisechan = TMath::Nint(flat.fire() * (1. * (fNoise.size() - 1) + 0.1));
         }
         for (int i = 0; i < fNTicks; ++i) {
           adcvec[i] = (short)TMath::Nint(fNoise[noisechan][i] + fChargeWork[i]);
         }
       }
       else {
         for (int i = 0; i < fNTicks; ++i) {
           adcvec[i] = (short)TMath::Nint(fChargeWork[i]);
         }
       }
 
       adcvec.resize(fNSamplesReadout);
 
       // ... compress the adc vector using the desired compression scheme,
       //     if raw::kNone is selected nothing happens to adcvec
       //     This shrinks adcvec, if fCompression is not kNone.
       raw::Compress(adcvec, fCompression);
 
       // ... add this digit to the collection
       digcol->emplace_back(chan, fNTicks, move(adcvec), fCompression);
 
     } //end loop over channels
 
     evt.put(std::move(digcol));
 
     return;
   }

void art::Modifier::registerProducts ( ProductDescriptions & productsToRegister )

inherited

Definition at line 16 of file Modifier.cc.

References art::ModuleBase::moduleDescription(), and art::ProductRegistryHelper::registerProducts().

   {
     ProductRegistryHelper::registerProducts(productsToRegister,
                                             moduleDescription());
   }

void detsim::SimWire::SetElectResponse ( )

private

response of electronics

Definition at line 532 of file SimWire_module.cc.

References DEFINE_ART_MODULE, e, fADCPerPCAtLowestASICGain, fASICGainInMVPerFC, fElectResp, fElectResponse, fInputFieldRespSamplingPeriod, fNElectResp, fNTicks, and fShapeTimeConst.

Referenced by beginJob().

   {
     fElectResponse.resize(fNTicks, 0.);
     std::vector<double> time(fNTicks, 0.);
 
     // ... Gain and shaping time variables from fcl file:
     double Ao = 1.0;
     double To = fShapeTimeConst; //peaking time
 
     // ... this is actually sampling time, in ns
     mf::LogInfo("SimWire::SetElectResponse")
       << "Check sampling intervals: " << fInputFieldRespSamplingPeriod << " ns"
       << "Check number of samples: " << fNTicks;
 
     // ... The following sets the microboone electronics response function in
     //     time-space. Function comes from BNL SPICE simulation of DUNE35t
     //     electronics. SPICE gives the electronics transfer function in
     //     frequency-space. The inverse laplace transform of that function
     //     (in time-space) was calculated in Mathematica and is what is being
     //     used below. Parameters Ao and To are cumulative gain/timing parameters
     //     from the full (ASIC->Intermediate amp->Receiver->ADC) electronics chain.
     //     They have been adjusted to make the SPICE simulation to match the
     //     actual electronics response. Default params are Ao=1.4, To=0.5us.
     double max = 0;
 
     for (size_t i = 0; i < fElectResponse.size(); ++i) {
 
       // ... convert time to microseconds, to match fElectResponse[i] definition
       time[i] = (1. * i) * fInputFieldRespSamplingPeriod * 1e-3;
       fElectResponse[i] =
         4.31054 * exp(-2.94809 * time[i] / To) * Ao -
         2.6202 * exp(-2.82833 * time[i] / To) * cos(1.19361 * time[i] / To) * Ao -
         2.6202 * exp(-2.82833 * time[i] / To) * cos(1.19361 * time[i] / To) *
           cos(2.38722 * time[i] / To) * Ao +
         0.464924 * exp(-2.40318 * time[i] / To) * cos(2.5928 * time[i] / To) * Ao +
         0.464924 * exp(-2.40318 * time[i] / To) * cos(2.5928 * time[i] / To) *
           cos(5.18561 * time[i] / To) * Ao +
         0.762456 * exp(-2.82833 * time[i] / To) * sin(1.19361 * time[i] / To) * Ao -
         0.762456 * exp(-2.82833 * time[i] / To) * cos(2.38722 * time[i] / To) *
           sin(1.19361 * time[i] / To) * Ao +
         0.762456 * exp(-2.82833 * time[i] / To) * cos(1.19361 * time[i] / To) *
           sin(2.38722 * time[i] / To) * Ao -
         2.6202 * exp(-2.82833 * time[i] / To) * sin(1.19361 * time[i] / To) *
           sin(2.38722 * time[i] / To) * Ao -
         0.327684 * exp(-2.40318 * time[i] / To) * sin(2.5928 * time[i] / To) * Ao +
         +0.327684 * exp(-2.40318 * time[i] / To) * cos(5.18561 * time[i] / To) *
           sin(2.5928 * time[i] / To) * Ao -
         0.327684 * exp(-2.40318 * time[i] / To) * cos(2.5928 * time[i] / To) *
           sin(5.18561 * time[i] / To) * Ao +
         0.464924 * exp(-2.40318 * time[i] / To) * sin(2.5928 * time[i] / To) *
           sin(5.18561 * time[i] / To) * Ao;
 
       if (fElectResponse[i] > max) max = fElectResponse[i];
 
     } // end loop over time buckets
 
     // ... "normalize" fElectResponse[i], before the convolution
 
     for (auto& element : fElectResponse) {
       element /= max;
       element *= fADCPerPCAtLowestASICGain * 1.60217657e-7;
       element *= fASICGainInMVPerFC / 4.7; // relative to lowest gain setting of 4.7 mV/fC
     }
 
     fNElectResp = fElectResponse.size();
 
     // ... write the response out to a file
 
     art::ServiceHandle<art::TFileService const> tfs;
     fElectResp = tfs->make<TH1D>(
       "ElectronicsResponse", ";t (ns);Electronics Response", fNElectResp, 0, fNElectResp);
     for (unsigned int i = 0; i < fNElectResp; ++i) {
       fElectResp->Fill(i, fElectResponse[i]);
     }
 
     fElectResp->Write();
   }

void detsim::SimWire::SetFieldResponse ( )

private

response of wires to field

Definition at line 478 of file SimWire_module.cc.

References fColFieldParams, fColFieldResp, fColFieldResponse, fIndFieldParams, fIndFieldResp, fIndFieldResponse, and fNTicks.

Referenced by beginJob().

   {
 
     // ... Files to write the response functions to
     art::ServiceHandle<art::TFileService const> tfs;
     fIndFieldResp =
       tfs->make<TH1D>("InductionFieldResponse", ";t (ns);Induction Response", fNTicks, 0, fNTicks);
     fColFieldResp = tfs->make<TH1D>(
       "CollectionFieldResponse", ";t (ns);Collection Response", fNTicks, 0, fNTicks);
 
     fColFieldResponse.resize(fNTicks, 0.);
     fIndFieldResponse.resize(fNTicks, 0.);
 
     // ... First set response for collection plane
     int nbinc = fColFieldParams[0];
 
     double integral = 0.;
     for (int i = 1; i < nbinc; ++i) {
       fColFieldResponse[i] = i * i;
       integral += fColFieldResponse[i];
     }
 
     for (int i = 0; i < nbinc; ++i) {
       fColFieldResponse[i] *= fColFieldParams[1] / integral;
       fColFieldResp->Fill(i, fColFieldResponse[i]);
     }
 
     // ... Now set response for induction plane
     int nbini = fIndFieldParams[0];
     unsigned short lastbini = 2 * nbini;
 
     integral = 0;
     for (unsigned short i = 0; i < lastbini; ++i) {
       double ang = i * TMath::Pi() / nbini;
       fIndFieldResponse[i] = sin(ang);
       if (fIndFieldResponse[i] > 0) { integral += fIndFieldResponse[i]; }
       else {
         fIndFieldResponse[i] *=
           fIndFieldParams[2]; // scale the negative lobe by 10% (from ArgoNeuT)
       }
     }
     ++lastbini;
 
     for (unsigned short i = 0; i < lastbini; ++i) {
       fIndFieldResponse[i] *= fIndFieldParams[1] / integral;
       fIndFieldResp->Fill(i, fIndFieldResponse[i]);
     }
 
     // ... Save the field responses
     fColFieldResp->Write();
     fIndFieldResp->Write();
   }

void art::ModuleBase::setModuleDescription ( ModuleDescription const & md )

inherited

Definition at line 31 of file ModuleBase.cc.

References art::ModuleBase::md_.

   {
     md_ = md;
   }

void art::ModuleBase::sortConsumables ( std::string const & current_process_name )

inherited

Definition at line 49 of file ModuleBase.cc.

References art::ModuleBase::collector_, and art::ConsumesCollector::sortConsumables().

   {
     // Now that we know we have seen all the consumes declarations,
     // sort the results for fast lookup later.
     collector_.sortConsumables(current_process_name);
   }

Member Data Documentation

double detsim::SimWire::fADCPerPCAtLowestASICGain

private

ADCs/pC at lowest gain setting of 4.7 mV/fC.

Definition at line 97 of file SimWire_module.cc.

Referenced by SetElectResponse(), and SimWire().

double detsim::SimWire::fASICGainInMVPerFC

private

actual gain setting used in mV/fC

Definition at line 98 of file SimWire_module.cc.

Referenced by SetElectResponse(), and SimWire().

std::vector<int> detsim::SimWire::fCalibRespTOffset

private

calib response time offset in ticks

Definition at line 104 of file SimWire_module.cc.

Referenced by produce(), and SimWire().

double detsim::SimWire::fCol3DCorrection

private

correction factor to account for 3D path of electrons thru wires

Definition at line 90 of file SimWire_module.cc.

Referenced by SimWire().

std::vector<float> detsim::SimWire::fColFieldParams

private

collection plane field function parameterization

Definition at line 105 of file SimWire_module.cc.

Referenced by SetFieldResponse(), and SimWire().

TH1D* detsim::SimWire::fColFieldResp

private

response function for the field @ collection plane

Definition at line 117 of file SimWire_module.cc.

Referenced by SetFieldResponse().

std::vector<double> detsim::SimWire::fColFieldResponse

private

response function for the field @ collection plane

Definition at line 107 of file SimWire_module.cc.

Referenced by ConvoluteResponseFunctions(), and SetFieldResponse().

std::vector<TComplex> detsim::SimWire::fColShape

private

response function for the field @ collection plane

Definition at line 109 of file SimWire_module.cc.

Referenced by ConvoluteResponseFunctions(), and produce().

TH1D* detsim::SimWire::fColTimeShape

private

convoluted shape for field x electronics @ col plane

Definition at line 119 of file SimWire_module.cc.

Referenced by ConvoluteResponseFunctions().

raw::Compress_t detsim::SimWire::fCompression

private

compression type to use

Definition at line 85 of file SimWire_module.cc.

Referenced by produce(), and SimWire().

std::string detsim::SimWire::fDriftEModuleLabel

private

module making the ionization electrons

Definition at line 84 of file SimWire_module.cc.

Referenced by produce(), and SimWire().

TH1D* detsim::SimWire::fElectResp

private

response function for the electronics

Definition at line 118 of file SimWire_module.cc.

Referenced by SetElectResponse().

std::vector<double> detsim::SimWire::fElectResponse

private

response function for the electronics

Definition at line 111 of file SimWire_module.cc.

Referenced by ConvoluteResponseFunctions(), and SetElectResponse().

CLHEP::HepRandomEngine& detsim::SimWire::fEngine

private

Random-number engine owned by art.

Definition at line 124 of file SimWire_module.cc.

Referenced by beginJob(), produce(), and SimWire().

std::vector<int> detsim::SimWire::fFieldRespTOffset

private

field response time offset in ticks

Definition at line 103 of file SimWire_module.cc.

Referenced by produce(), and SimWire().

double detsim::SimWire::fInd3DCorrection

private

correction factor to account for 3D path of electrons thru wires

Definition at line 92 of file SimWire_module.cc.

Referenced by SimWire().

std::vector<float> detsim::SimWire::fIndFieldParams

private

induction plane field function parameterization

Definition at line 106 of file SimWire_module.cc.

Referenced by SetFieldResponse(), and SimWire().

TH1D* detsim::SimWire::fIndFieldResp

private

response function for the field @ induction plane

Definition at line 116 of file SimWire_module.cc.

Referenced by SetFieldResponse().

std::vector<double> detsim::SimWire::fIndFieldResponse

private

response function for the field @ induction plane

Definition at line 108 of file SimWire_module.cc.

Referenced by ConvoluteResponseFunctions(), and SetFieldResponse().

std::vector<TComplex> detsim::SimWire::fIndShape

private

response function for the field @ induction plane

Definition at line 110 of file SimWire_module.cc.

Referenced by ConvoluteResponseFunctions(), and produce().

TH1D* detsim::SimWire::fIndTimeShape

private

convoluted shape for field x electronics @ ind plane

Definition at line 120 of file SimWire_module.cc.

Referenced by ConvoluteResponseFunctions().

double detsim::SimWire::fInputFieldRespSamplingPeriod

private

Sampling period in the input field response.

Definition at line 95 of file SimWire_module.cc.

Referenced by SetElectResponse(), and SimWire().

unsigned int detsim::SimWire::fNElectResp

private

number of entries from response to use

Definition at line 94 of file SimWire_module.cc.

Referenced by SetElectResponse().

std::vector<std::vector<float> > detsim::SimWire::fNoise

private

noise on each channel for each time

Definition at line 112 of file SimWire_module.cc.

Referenced by beginJob(), and produce().

TH1D* detsim::SimWire::fNoiseDist

private

distribution of noise counts

Definition at line 121 of file SimWire_module.cc.

Referenced by beginJob().

TF1* detsim::SimWire::fNoiseFluct

private

Poisson dist for fluctuations in magnitude of noise freq components.

Definition at line 122 of file SimWire_module.cc.

Referenced by beginJob(), and GenNoise().

std::string detsim::SimWire::fNoiseFluctChoice

private

choice for noise freq component mag fluctuations

Definition at line 101 of file SimWire_module.cc.

Referenced by beginJob(), and SimWire().

std::vector<double> detsim::SimWire::fNoiseFluctPar

private

Poisson noise fluctuations params.

Definition at line 114 of file SimWire_module.cc.

Referenced by beginJob(), and SimWire().

std::string detsim::SimWire::fNoiseModelChoice

private

choice for noise model

Definition at line 100 of file SimWire_module.cc.

Referenced by GenNoise(), and SimWire().

std::vector<double> detsim::SimWire::fNoiseModelPar

private

noise model params

Definition at line 113 of file SimWire_module.cc.

Referenced by GenNoise(), and SimWire().

int detsim::SimWire::fNoiseNchToSim

private

number of noise channels to generate

Definition at line 99 of file SimWire_module.cc.

Referenced by beginJob(), produce(), and SimWire().

unsigned int detsim::SimWire::fNSamplesReadout

private

number of ADC readout samples in 1 readout frame

Definition at line 89 of file SimWire_module.cc.

Referenced by produce(), and SimWire().

int detsim::SimWire::fNTicks

private

number of ticks of the clock

Definition at line 87 of file SimWire_module.cc.

Referenced by beginJob(), ConvoluteResponseFunctions(), GenNoise(), produce(), SetElectResponse(), and SetFieldResponse().

double detsim::SimWire::fSampleRate

private

sampling rate in ns

Definition at line 88 of file SimWire_module.cc.

Referenced by GenNoise(), and SimWire().

double detsim::SimWire::fShapeTimeConst

private

time constants for exponential shaping

Definition at line 96 of file SimWire_module.cc.

Referenced by SetElectResponse(), and SimWire().

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

larsim/v10_02_02/source/larsim/DetSim/SimWire_module.cc

Public Types

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation