Inheritance diagram for SimWireDUNE:

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

virtual	~SimWireDUNE ()

void	produce (art::Event &evt)

void	beginJob ()

void	endJob ()

void	reconfigure (fhicl::ParameterSet const &p)

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 Attributes
std::string	fSimChannelLabel
	Data product holding the ionization electrons. More...

bool	fNoiseOn
	noise turned on or off for debugging; default is on More...

bool	fPedestalOn
	switch for simulation of nonzero pedestals More...

bool	fDistortOn
	switch for simulation of stuck bits More...

bool	fSuppressOn
	switch for simulation of zero suppression More...

bool	fKeepEmptyChannels
	Write out empty channels iff true. More...

bool	fUseRawDigitInput
	Use (presumably noise-free) RawDigits for input instead of SimChannels. More...

std::string	fRawDigitInputLabel
	The module label for the RawDigits to read in. More...

std::string	fAdcSimulatorName

std::unique_ptr< AdcSimulator >	m_pads

art::ServiceHandle< geo::Geometry >	m_pgeo

art::ServiceHandle< AdcSuppressService >	m_pzs

art::ServiceHandle< AdcCompressService >	m_pcmp

art::ServiceHandle< SimChannelExtractService >	m_pscx

art::ServiceHandle< ChannelNoiseService >	m_pcns

art::ServiceHandle< AdcDistortionService >	m_pdis

art::ServiceHandle< PedestalAdditionService >	m_ppad

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 64 of file SimWireDUNE_module.cc.

Constructor & Destructor Documentation

SimWireDUNE::SimWireDUNE ( fhicl::ParameterSet const & pset )

explicit

Definition at line 110 of file SimWireDUNE_module.cc.

                                                       : EDProducer{pset} {
   reconfigure(pset);
   produces< std::vector<raw::RawDigit> >();
 }

SimWireDUNE::~SimWireDUNE ( )

virtual

Definition at line 117 of file SimWireDUNE_module.cc.

117 { }

Member Function Documentation

void SimWireDUNE::beginJob ( )

virtual

Reimplemented from art::EDProducer.

Definition at line 181 of file SimWireDUNE_module.cc.

181 { }

void SimWireDUNE::endJob ( )

virtual

Reimplemented from art::EDProducer.

Definition at line 185 of file SimWireDUNE_module.cc.

185 { }

void SimWireDUNE::produce ( art::Event & evt )

virtual

Implements art::EDProducer.

Definition at line 189 of file SimWireDUNE_module.cc.

                                        {
   const string myname = "SimWireDUNE::produce: ";
 
   // 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;
   std::vector<const sim::SimChannel*> simChannels(m_pgeo->Nchannels(), nullptr);
   evt.getView(fSimChannelLabel, chanHandle);
   for ( size_t c=0; c<chanHandle.size(); ++c ) {
     simChannels[chanHandle[c]->Channel()] = chanHandle[c];
   }
 
   // Do the same as above, but for the RawDigits, so we can map from channel number to digit
   std::vector<const raw::RawDigit*> inputDigitsHandle;
   std::vector<const raw::RawDigit*> inputDigits(m_pgeo->Nchannels(), nullptr);
   if(fUseRawDigitInput){
     evt.getView(fRawDigitInputLabel, inputDigitsHandle);
     for ( size_t c=0; c<inputDigitsHandle.size(); ++c ) {
       const raw::RawDigit* dig=inputDigitsHandle[c];
       inputDigits[dig->Channel()] = dig;
     }
   }
 
   // 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
   std::unique_ptr<std::vector<raw::RawDigit>>  digcol(new std::vector<raw::RawDigit>);
 
   // Fetch the number of ticks to write out for each channel.
   auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
   auto const detProp = art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataFor(evt, clockData);
   unsigned int nTickReadout  = detProp.ReadOutWindowSize();
   m_pcns->newEvent();
   // Loop over channels.
   std::map<int,double>::iterator mapIter;
   for ( unsigned int chan = 0; chan<m_pgeo->Nchannels(); ++chan ) {
 
     // Get the SimChannel for this channel
     const sim::SimChannel* psc = simChannels[chan];
 
     // Create vector that holds the floating ADC count for each tick.
     std::vector<AdcSignal> fChargeWork;
 
     if(fUseRawDigitInput){
       const raw::RawDigit* dig=inputDigits[chan];
       fChargeWork.insert(fChargeWork.end(), dig->ADCs().begin(), dig->ADCs().end());
     }
     else{
       // Extract the floating ADC count from the SimChannel for each tick in the channel.
       m_pscx->extract(clockData, psc, fChargeWork);
     }
 
     // Add noise to each tick in the channel.
     if ( fNoiseOn ) {
       m_pcns->addNoise(clockData, detProp, chan, fChargeWork);
     }
 
     // Option to display signals before adding pedestals.
     // E.g. logsig = chan==1000.
     bool logsig = false;
     if ( logsig ) {
       cout << myname << "Signals after noise:" << endl;
       for ( unsigned int itck=0; itck<fChargeWork.size(); ++itck ) {
         if(fChargeWork[itck] > 0 )
           cout << myname << " " << itck << ": chg=" << fChargeWork[itck] << endl;
       }
     }
 
     // Add pedestal.
     float pedval = 0.0; // Pedestal to be recorded in RawDigits collection
     float pedrms = 0.0; // Pedestal RMS to be recorded in RawDigits collection
     if ( fPedestalOn ) {
       m_ppad->addPedestal(chan, fChargeWork, pedval, pedrms);
     }
 
     // Convert floating ADC to integral ADC count.
     std::vector<short> adcvec(fChargeWork.size(), 0);
     const short adcmax = 4095;
     for ( unsigned int itck=0; itck<fChargeWork.size(); ++itck ) {
       AdcSignal adcin = fChargeWork[itck];
       short adc = 0;
       bool useOldAdc = false;
       // New ADC calculation (with tool).
       if ( m_pads ) {
         if(adcin > 0)
           //cout << " adcin " << adcin << endl;
         adc = m_pads->count(adcin, chan);
       } else {
         //cout << myname << "WARNING: AdcSimulator not found." << endl;
         useOldAdc = true;
       }
       // Old ADC calculation.
       if ( useOldAdc ) {
         short adc1 = 0;
         if ( adcin > 0 ) adc1 = (short) (adcin + 0.5);
         if ( adc1 > adcmax ) adc1 = adcmax;
         bool show = m_pads && adc1 != adc;
 
         static int ndump = 1000;
         if ( ndump && show ) {
           cout << myname << "  ADC: " << adc1 << " --> " << adc << " (" << adcin << ")" << endl;
           --ndump;
         }
         adc = adc1;
       }
       // Record the ADC value.
       adcvec[itck] = adc;
     }
     // Resize to the correct number of time samples, dropping extra samples.
     adcvec.resize(nTickReadout);
 
     // Add stuck bits.
     if ( fDistortOn ) {
       m_pdis->modify(chan, adcvec);
     }
 
     // Zero suppress.
     AdcCountSelection acs(adcvec, chan, pedval);
     if ( fSuppressOn ) {
       m_pzs->filter(acs);
     }
     int nkeep = 0;
     for ( bool kept : acs.filter ) if ( kept ) ++nkeep;
 
     // If flag is not set and channel is empty, skip it.
     if ( ! fKeepEmptyChannels && nkeep==0 ) continue;
 
     // Compress.
     raw::Compress_t comp = raw::kNone;
     m_pcmp->compress(adcvec, acs.filter, pedval, comp);
 
     // Create and store raw digit.
     raw::RawDigit rd(chan, nTickReadout, adcvec, comp);
     rd.SetPedestal(pedval, pedrms);
     digcol->push_back(rd);            // add this digit to the collection
 
   }  // end loop over channels
 
   evt.put(std::move(digcol));
 
 }

void SimWireDUNE::reconfigure ( fhicl::ParameterSet const & p )

Definition at line 121 of file SimWireDUNE_module.cc.

                                                         {
   string myname = "SimWireDUNE::reconfigure: ";
   string myprefix = myname + "    ";
   fSimChannelLabel   = p.get<std::string>("SimChannelLabel");
   fNoiseOn           = p.get<bool>("NoiseOn");
   fPedestalOn        = p.get<bool>("PedestalOn");
   fDistortOn         = p.get<bool>("DistortOn");
   fSuppressOn        = p.get<bool>("SuppressOn");
   fKeepEmptyChannels = p.get<bool>("KeepEmptyChannels");
   fUseRawDigitInput  = p.get<bool>("UseRawDigitInput", false);
   fRawDigitInputLabel= p.get<string>("RawDigitInputLabel", "");
   fAdcSimulatorName = p.get<string>("AdcSimulator");
 
   DuneToolManager* pdtm = DuneToolManager::instance();
   m_pads = pdtm == nullptr ? nullptr : pdtm->getPrivate<AdcSimulator>(fAdcSimulatorName);
   ostringstream out;
   out << myname << "Tools:" << endl;
   out << "  AdcSimulator: " << bool(m_pads) << endl;
   out << myname << "Accessed services:" << endl;
   out << myname << "  SimChannel extraction service:" << endl;
   m_pscx->print(out, myprefix) << endl;
   if ( fNoiseOn ) {
     out << myname << "  Channel noise service:" << endl;;
     m_pcns->print(out, myprefix);
   } else {
     out << myname << "  Channel noise is off.";
   }
   out << endl;
   if ( fPedestalOn ) {
     out << myname << "  Pedestal addition service:" << endl;;
     m_ppad->print(out, myprefix);
   } else {
     out << myname << "  Pedestal addition is off.";
   }
   out << endl;
   if ( fDistortOn ) {
     out << myname << "  ADC distortion service:" << endl;;
     m_pdis->print(out, myprefix);
   } else {
     out << myname << "  ADC distortion is off.";
   }
   out << endl;
   if ( fSuppressOn ) {
     out << myname << "  ADC suppression service:" << endl;
     m_pzs->print(out, myprefix);
   } else {
     out << myname << "  ADC suppression is off.";
   }
   out << endl;
   out << myname << "  Compression service:" << endl;
   out << endl;
   m_pcmp->print(out, myprefix);
   out << myname << "  KeepEmptyChannels:" << fKeepEmptyChannels << endl;
   mf::LogInfo("SimWireDUNE::reconfigure") << out.str();
 
   return;
 }

Member Data Documentation

std::string SimWireDUNE::fAdcSimulatorName

private

Definition at line 90 of file SimWireDUNE_module.cc.

bool SimWireDUNE::fDistortOn

private

switch for simulation of stuck bits

Definition at line 84 of file SimWireDUNE_module.cc.

bool SimWireDUNE::fKeepEmptyChannels

private

Write out empty channels iff true.

Definition at line 86 of file SimWireDUNE_module.cc.

bool SimWireDUNE::fNoiseOn

private

noise turned on or off for debugging; default is on

Definition at line 82 of file SimWireDUNE_module.cc.

bool SimWireDUNE::fPedestalOn

private

switch for simulation of nonzero pedestals

Definition at line 83 of file SimWireDUNE_module.cc.

std::string SimWireDUNE::fRawDigitInputLabel

private

The module label for the RawDigits to read in.

Definition at line 88 of file SimWireDUNE_module.cc.

std::string SimWireDUNE::fSimChannelLabel

private

Data product holding the ionization electrons.

Definition at line 79 of file SimWireDUNE_module.cc.

bool SimWireDUNE::fSuppressOn

private

switch for simulation of zero suppression

Definition at line 85 of file SimWireDUNE_module.cc.

bool SimWireDUNE::fUseRawDigitInput

private

Use (presumably noise-free) RawDigits for input instead of SimChannels.

Definition at line 87 of file SimWireDUNE_module.cc.

std::unique_ptr<AdcSimulator> SimWireDUNE::m_pads

private

Definition at line 93 of file SimWireDUNE_module.cc.

art::ServiceHandle<AdcCompressService> SimWireDUNE::m_pcmp

private

Definition at line 98 of file SimWireDUNE_module.cc.

art::ServiceHandle<ChannelNoiseService> SimWireDUNE::m_pcns

private

Definition at line 100 of file SimWireDUNE_module.cc.

art::ServiceHandle<AdcDistortionService> SimWireDUNE::m_pdis

private

Definition at line 101 of file SimWireDUNE_module.cc.

art::ServiceHandle<geo::Geometry> SimWireDUNE::m_pgeo

private

Definition at line 96 of file SimWireDUNE_module.cc.

art::ServiceHandle<PedestalAdditionService> SimWireDUNE::m_ppad

private

Definition at line 102 of file SimWireDUNE_module.cc.

art::ServiceHandle<SimChannelExtractService> SimWireDUNE::m_pscx

private

Definition at line 99 of file SimWireDUNE_module.cc.

art::ServiceHandle<AdcSuppressService> SimWireDUNE::m_pzs

private

Definition at line 97 of file SimWireDUNE_module.cc.

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

dunesim/dunesim/DetSim/Module/SimWireDUNE_module.cc

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation