Inheritance diagram for hit::HitCheater:

Public Types
using	ModuleType = EDProducer

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

Public Member Functions
	HitCheater (fhicl::ParameterSet const &p)

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 &e) override

void	FindHitsOnChannel (const sim::SimChannel *sc, std::vector< recob::Hit > &hits, int spill)

Private Attributes
std::string	fG4ModuleLabel
	label name for module making sim::SimChannels More...

std::string	fWireModuleLabel
	label name for module making recob::Wires More...

double	fMinCharge
	Minimum charge required to make a hit. More...

double	fElectronsToADC
	Conversion factor of electrons to ADC counts. More...

std::string	fCalDataProductInstanceName
	label name for module making recob::Wires More...

int	fReadOutWindowSize
	Number of samples in a readout window; NOT total samples. More...

int	fNumberTimeSamples
	Number of total time samples (N*readoutwindowsize) More...

double	fSamplingRate
	from detinfo::DetectorPropertiesService More...

int	fTriggerOffset
	from detinfo::DetectorPropertiesService More...

int	fNewHitTDCGap
	gap allowed in tdcs without charge before making a new hit More...

Detailed Description

Definition at line 42 of file HitCheater_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

hit::HitCheater::HitCheater ( fhicl::ParameterSet const & p )

explicit

Definition at line 64 of file HitCheater_module.cc.

References recob::HitAndAssociationsWriterBase::declare_products(), fCalDataProductInstanceName, fElectronsToADC, fG4ModuleLabel, fMinCharge, fNewHitTDCGap, fNumberTimeSamples, fReadOutWindowSize, fSamplingRate, fTriggerOffset, fWireModuleLabel, art::ProductRegistryHelper::producesCollector(), detinfo::sampling_rate(), and detinfo::trigger_offset().

                                                     : EDProducer{p}
 {
   fG4ModuleLabel = p.get<std::string>("G4ModuleLabel", "largeant");
   fWireModuleLabel = p.get<std::string>("WireModuleLabel", "caldata");
   fMinCharge = p.get<double>("MinimumCharge", 5.);
   fNewHitTDCGap = p.get<int>("NewHitTDCGap", 1);
 
   auto const clock_data = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataForJob();
   auto const det_prop =
     art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataForJob(clock_data);
   fElectronsToADC = det_prop.ElectronsToADC();
   fSamplingRate = sampling_rate(clock_data);
   fTriggerOffset = trigger_offset(clock_data);
 
   fCalDataProductInstanceName = "";
   size_t pos = fWireModuleLabel.find(":");
   if (pos != std::string::npos) {
     fCalDataProductInstanceName = fWireModuleLabel.substr(pos + 1);
     fWireModuleLabel = fWireModuleLabel.substr(0, pos);
   }
 
   fReadOutWindowSize = det_prop.ReadOutWindowSize();
   fNumberTimeSamples = det_prop.NumberTimeSamples();
 
   // let HitCollectionCreator declare that we are going to produce
   // hits and associations with wires and raw digits
   // (with no particular product label)
   recob::HitCollectionCreator::declare_products(producesCollector());
 }

Member Function Documentation

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 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 hit::HitCheater::FindHitsOnChannel	(	const sim::SimChannel *	sc,
		std::vector< recob::Hit > &	hits,
		int	spill
	)

private

Definition at line 155 of file HitCheater_module.cc.

References lar::util::StatCollector< T, W >::add(), sim::SimChannel::Channel(), lar::util::StatCollector< T, W >::clear(), geo::CryostatID::Cryostat, DEFINE_ART_MODULE, edep, fElectronsToADC, geo::GeometryCore::FindTPCAtPosition(), fMinCharge, fNewHitTDCGap, fNumberTimeSamples, fReadOutWindowSize, Get, geo::CryostatID::isValid, art::errors::LogicError, MF_LOG_DEBUG, lar::util::StatCollector< T, W >::RMS(), sim::SimChannel::TDCIDEMap(), and geo::TPCID::TPC.

Referenced by produce().

 {
   art::ServiceHandle<geo::Geometry const> geo;
   auto const& wireReadoutGeom = art::ServiceHandle<geo::WireReadout const>()->Get();
   raw::ChannelID_t channel = sc->Channel();
   geo::SigType_t signal_type = wireReadoutGeom.SignalType(channel);
   geo::View_t view = wireReadoutGeom.View(channel);
 
   // determine the possible geo::WireIDs for this particular channel
   // then make a map of tdc to electrons for each one of those geo::WireIDs
   // then find hits on each geo::WireID
   std::vector<geo::WireID> wireids = wireReadoutGeom.ChannelToWire(channel);
 
   std::map<geo::WireID, std::map<unsigned int, double>> wireIDSignals;
 
   auto const& idemap = sc->TDCIDEMap();
 
   for (auto const& mapitr : idemap) {
     unsigned short tdc = mapitr.first;
 
     if (fReadOutWindowSize != fNumberTimeSamples) {
       if (tdc < spill * fReadOutWindowSize || tdc > (spill + 1) * fReadOutWindowSize) continue;
     }
     else {
       if (tdc > fReadOutWindowSize) continue;
     }
 
     // figure out which TPC we are in for each voxel
 
     for (auto const& ideitr : mapitr.second) {
 
       const float edep = ideitr.numElectrons;
 
       geo::Point_t const pos{ideitr.x, ideitr.y, ideitr.z};
 
       geo::TPCID tpcID = geo->FindTPCAtPosition(pos);
       if (!tpcID.isValid) {
         mf::LogWarning("HitCheater")
           << "TPC for position ( " << pos.X() << " ; " << pos.Y() << " ; " << pos.Z() << " )"
           << " in no TPC; move on to the next sim::IDE";
         continue;
       }
       const unsigned int tpc = tpcID.TPC;
       const unsigned int cstat = tpcID.Cryostat;
 
       for (auto const& wid : wireids) {
         if (wid.TPC == tpc && wid.Cryostat == cstat) {
           // in the right TPC, now figure out which wire we want
           // this works because there is only one plane option for
           // each WireID in each TPC
           if (wid.Wire == wireReadoutGeom.Plane(wid).NearestWireID(pos).Wire)
             wireIDSignals[wid][tdc] += edep;
         } // end if in the correct TPC and Cryostat
       }   // end loop over wireids for this channel
     }     // end loop over ides for this channel
   }       // end loop over tdcs for this channel
 
   // now loop over each wire ID and determine where the hits are
   for (auto const& widitr : wireIDSignals) {
 
     // get the first tdc in the
     unsigned short prev = widitr.second.begin()->first;
     unsigned short startTime = prev;
     double totCharge = 0.;
     double maxCharge = -1.;
     double peakTime = 0.;
     int multiplicity = 1;
     lar::util::StatCollector<double> time; // reduce rounding errors
 
     // loop over all the tdcs for this geo::WireID
     for (auto tdcitr : widitr.second) {
       unsigned short tdc = tdcitr.first;
       if (tdc < prev) {
         throw art::Exception(art::errors::LogicError) << "SimChannel TDCs going backward!";
       }
 
       // more than a one tdc gap between times with
       // signal, start a new hit
       if (tdc - prev > fNewHitTDCGap) {
 
         if (totCharge > fMinCharge) {
           hits.emplace_back(channel,                   // channel
                             (raw::TDCtick_t)startTime, // start_tick
                             (raw::TDCtick_t)prev,      // end_tick
                             peakTime,                  // peak_time
                             1.,                        // sigma_peak_time
                             time.RMS(),                // RMS
                             maxCharge,                 // peak_amplitude
                             std::sqrt(maxCharge),      // sigma_peak_amplitude
                             totCharge,                 // ROIsummedADC
                             totCharge,                 // HitsummedADC
                             totCharge,                 // hit_integral
                             std::sqrt(totCharge),      // hit_sigma_integral
                             multiplicity,              // multiplicity
                             0,                         // local_index
                             1.,                        // goodness_of_fit
                             0.,                        // dof
                             view,                      // view
                             signal_type,               // signal_type
                             widitr.first               // wireID
           );
 
           MF_LOG_DEBUG("HitCheater") << "new hit is " << hits.back();
 
         } // end if charge is large enough
 
         // reset the variables for each hit
         startTime = tdc;
         peakTime = tdc;
         totCharge = 0.;
         maxCharge = -1.;
         time.clear();
 
       } // end if need to start a new hit
 
       const double adc = fElectronsToADC * tdcitr.second;
 
       totCharge += adc;
       // use ADC as weight; the shift reduces the precision needed;
       // average would need to be shifted back: time.Averatge() + startTime
       // but RMS is not affected
       time.add(tdc - startTime, adc);
       if (adc > maxCharge) {
         maxCharge = adc;
         peakTime = tdc;
       }
 
       prev = tdc;
 
     } // end loop over tdc values for the current geo::WireID
 
     // We might have missed the last hit, so do it now
     if (totCharge > fMinCharge) {
       hits.emplace_back(channel,                   // channel
                         (raw::TDCtick_t)startTime, // start_tick
                         (raw::TDCtick_t)prev + 1,  // end_tick; prev included in the hit
                         peakTime,                  // peak_time
                         1.,                        // sigma_peak_time
                         time.RMS(),                // RMS
                         maxCharge,                 // peak_amplitude
                         std::sqrt(maxCharge),      // sigma_peak_amplitude
                         totCharge,                 // ROIsummedADC
                         totCharge,                 // HitsummedADC
                         totCharge,                 // hit_integral
                         std::sqrt(totCharge),      // hit_sigma_integral
                         multiplicity,              // multiplicity
                         0,                         // local_index
                         1.,                        // goodness_of_fit
                         0.,                        // dof
                         view,                      // view
                         signal_type,               // signal_type
                         widitr.first               // wireID
       );
 
       MF_LOG_DEBUG("HitCheater") << "last hit is " << hits.back();
 
     } // end if charge is large enough
 
   } // end loop over map of geo::WireID to map<tdc,electrons>
 
   return;
 }

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 hit::HitCheater::produce ( art::Event & e )

overrideprivatevirtual

Implements art::EDProducer.

Definition at line 95 of file HitCheater_module.cc.

References recob::Wire::Channel(), recob::HitCollectionCreator::emplace_back(), fCalDataProductInstanceName, fG4ModuleLabel, FindHitsOnChannel(), fWireModuleLabel, art::ProductRetriever::getValidHandle(), art::ProductRetriever::getView(), hits(), art::Ptr< T >::isNonnull(), art::Ptr< T >::key(), MF_LOG_DEBUG, recob::HitCollectionCreator::put_into(), sc, and recob::HitCollectionCreator::size().

 {
   // this object contains the hit collection
   // and its associations to wires and raw digits:
   recob::HitCollectionCreator hits(e);
 
   // Read in the wire List object(s).
   art::InputTag WireInputTag(fWireModuleLabel, fCalDataProductInstanceName);
   art::ValidHandle<std::vector<recob::Wire>> wHandle =
     e.getValidHandle<std::vector<recob::Wire>>(WireInputTag);
 
   int whatSpill = 1;
   if (!fCalDataProductInstanceName.empty()) {
     if (fCalDataProductInstanceName.find("ost") != std::string::npos)
       whatSpill = 2;
     else
       whatSpill = 0;
   }
 
   // also get the raw digits associated with the wires;
   // we assume they have been created by the same module as the wires
   art::FindOneP<raw::RawDigit> WireToRawDigits(wHandle, e, WireInputTag);
 
   // make a map of wires to channel numbers
   std::map<raw::ChannelID_t, art::Ptr<recob::Wire>> wireMap;
 
   for (size_t wc = 0; wc < wHandle->size(); ++wc) {
     art::Ptr<recob::Wire> wire(wHandle, wc);
     wireMap[wire->Channel()] = wire;
   }
 
   // get the sim::SimChannels out of the event
   std::vector<const sim::SimChannel*> sccol;
   e.getView(fG4ModuleLabel, sccol);
 
   // find the hits on each channel
   for (sim::SimChannel const* sc : sccol) {
     std::vector<recob::Hit> hits_on_channel;
 
     FindHitsOnChannel(sc, hits_on_channel, whatSpill);
 
     art::Ptr<recob::Wire> const& wire = wireMap[sc->Channel()];
     art::Ptr<raw::RawDigit> rawdigits; // null by default
     if (wire.isNonnull()) rawdigits = WireToRawDigits.at(wire.key());
 
     // add all the hits found on this channel to the data product,
     // all associated to the same hit and wire
     for (recob::Hit& hit : hits_on_channel)
       hits.emplace_back(std::move(hit), wire, rawdigits);
 
   } // end loop over SimChannels
 
   // put the cheated hits into the event
   MF_LOG_DEBUG("HitCheater") << "putting " << hits.size() << " hits into the event";
   hits.put_into(e);
 
   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 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);
   }