Inheritance diagram for hit::HitCheater:

Public Types
using	ModuleType = EDProducer

using	WorkerType = WorkerT< EDProducer >

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

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

virtual	~HitCheater ()

virtual void	produce (art::Event &e)

virtual void	beginJob ()

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

template<typename PROD , BranchType B = InEvent>
ProductID	getProductID (std::string const &instanceName={}) const

template<typename PROD , BranchType B>
ProductID	getProductID (ModuleDescription const &moduleDescription, std::string const &instanceName) const

bool	modifiesEvent () const

template<typename T , BranchType = InEvent>
ProductToken< T >	consumes (InputTag const &)

template<typename T , art::BranchType BT>
art::ProductToken< T >	consumes (InputTag const &it)

template<typename T , BranchType = InEvent>
void	consumesMany ()

template<typename Element , BranchType = InEvent>
ViewToken< Element >	consumesView (InputTag const &)

template<typename T , art::BranchType BT>
art::ViewToken< T >	consumesView (InputTag const &it)

template<typename T , BranchType = InEvent>
ProductToken< T >	mayConsume (InputTag const &)

template<typename T , art::BranchType BT>
art::ProductToken< T >	mayConsume (InputTag const &it)

template<typename T , BranchType = InEvent>
void	mayConsumeMany ()

template<typename Element , BranchType = InEvent>
ViewToken< Element >	mayConsumeView (InputTag const &)

template<typename T , art::BranchType BT>
art::ViewToken< T >	mayConsumeView (InputTag const &it)

base_engine_t &	createEngine (seed_t seed)

base_engine_t &	createEngine (seed_t seed, std::string const &kind_of_engine_to_make)

base_engine_t &	createEngine (seed_t seed, std::string const &kind_of_engine_to_make, label_t const &engine_label)

seed_t	get_seed_value (fhicl::ParameterSet const &pset, char const key[]="seed", seed_t const implicit_seed=-1)

Static Public Member Functions
static cet::exempt_ptr< Consumer >	non_module_context ()

Protected Member Functions
CurrentProcessingContext const *	currentContext () const

void	validateConsumedProduct (BranchType const bt, ProductInfo const &pi)

void	prepareForJob (fhicl::ParameterSet const &pset)

void	showMissingConsumes () const

Private Member Functions
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 45 of file HitCheater_module.cc.

Member Typedef Documentation

using art::EDProducer::ModuleType = EDProducer

inherited

Definition at line 34 of file EDProducer.h.

template<typename UserConfig , typename KeysToIgnore = void>

using art::EDProducer::Table = ProducerBase::Table<UserConfig, KeysToIgnore>

inherited

Definition at line 43 of file EDProducer.h.

using art::EDProducer::WorkerType = WorkerT<EDProducer>

inherited

Definition at line 35 of file EDProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 77 of file HitCheater_module.cc.

References recob::HitAndAssociationsWriterBase::declare_products(), and reconfigure().

 {
   this->reconfigure(p);
 
   // 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(*this);
 }

hit::HitCheater::~HitCheater ( )

virtual

Definition at line 88 of file HitCheater_module.cc.

89 {

90 }

Member Function Documentation

void hit::HitCheater::beginJob ( )

virtual

Reimplemented from art::EDProducer.

Definition at line 324 of file HitCheater_module.cc.

 {
   return;
 }

template<typename T , BranchType = InEvent>

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

inherited

template<typename T , art::BranchType BT>

art::ProductToken<T> art::Consumer::consumes ( InputTag const & it )

inherited

Definition at line 147 of file Consumer.h.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

 {
   if (!moduleContext_)
     return ProductToken<T>::invalid();
 
   consumables_[BT].emplace_back(ConsumableType::Product,
                                 TypeID{typeid(T)},
                                 it.label(),
                                 it.instance(),
                                 it.process());
   return ProductToken<T>{it};
 }

template<typename T , art::BranchType BT>

void art::Consumer::consumesMany ( )

inherited

Definition at line 162 of file Consumer.h.

 {
   if (!moduleContext_)
     return;
 
   consumables_[BT].emplace_back(ConsumableType::Many, TypeID{typeid(T)});
 }

template<typename Element , BranchType = InEvent>

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

inherited

template<typename T , art::BranchType BT>

art::ViewToken<T> art::Consumer::consumesView ( InputTag const & it )

inherited

Definition at line 172 of file Consumer.h.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

 {
   if (!moduleContext_)
     return ViewToken<T>::invalid();
 
   consumables_[BT].emplace_back(ConsumableType::ViewElement,
                                 TypeID{typeid(T)},
                                 it.label(),
                                 it.instance(),
                                 it.process());
   return ViewToken<T>{it};
 }

EngineCreator::base_engine_t & EngineCreator::createEngine ( seed_t seed )

inherited

Definition at line 26 of file EngineCreator.cc.

References art::EngineCreator::rng().

Referenced by evgen::CosmicsGen::CosmicsGen(), rndm::NuRandomService::createEngine(), cluster::fuzzyCluster::fuzzyCluster(), cluster::HoughLineFinder::HoughLineFinder(), art::MixFilter< T >::initEngine_(), larg4::LArG4::LArG4(), evgen::LightSource::LightSource(), evgen::NeutronOsc::NeutronOsc(), evgen::NucleonDecay::NucleonDecay(), opdet::OpMCDigi::OpMCDigi(), opdet::OptDetDigitizer::OptDetDigitizer(), phot::PhotonLibraryPropagation::PhotonLibraryPropagation(), detsim::SimDriftElectrons::SimDriftElectrons(), evgen::SingleGen::SingleGen(), evgen::SNNueAr40CCGen::SNNueAr40CCGen(), ToyOneShowerGen::ToyOneShowerGen(), and trkf::Track3DKalman::Track3DKalman().

 {
   return rng()->createEngine(placeholder_schedule_id(), seed);
 }

EngineCreator::base_engine_t & EngineCreator::createEngine	(	seed_t	seed,
		std::string const &	kind_of_engine_to_make
	)

inherited

Definition at line 32 of file EngineCreator.cc.

References art::EngineCreator::rng().

 {
   return rng()->createEngine(
     placeholder_schedule_id(), seed, kind_of_engine_to_make);
 }

EngineCreator::base_engine_t & EngineCreator::createEngine	(	seed_t	seed,
		std::string const &	kind_of_engine_to_make,
		label_t const &	engine_label
	)

inherited

Definition at line 40 of file EngineCreator.cc.

References art::EngineCreator::rng().

 {
   return rng()->createEngine(
     placeholder_schedule_id(), seed, kind_of_engine_to_make, engine_label);
 }

CurrentProcessingContext const * art::EDProducer::currentContext ( ) const

protectedinherited

Definition at line 120 of file EDProducer.cc.

References art::EDProducer::current_context_.

   {
     return current_context_.get();
   }

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

private

Definition at line 151 of file HitCheater_module.cc.

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

Referenced by produce().

 {
   art::ServiceHandle<geo::Geometry> geo;
   
   raw::ChannelID_t channel = sc->Channel();
   geo::SigType_t signal_type = geo->SignalType(channel);
   geo::View_t view = geo->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 = geo->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 < 0 || tdc > fReadOutWindowSize) continue;
     }
     
     // figure out which TPC we are in for each voxel
 
     for(auto const& ideitr : mapitr.second){
 
       const float edep = ideitr.numElectrons;
       
       std::array<double, 3> pos;
       pos[0] = ideitr.x;
       pos[1] = ideitr.y;
       pos[2] = ideitr.z;
 
       geo::TPCID tpcID = geo->FindTPCAtPosition(pos.data());
       if (!tpcID.isValid) {
         mf::LogWarning("HitCheater") << "TPC for position ( "
           << pos[0] << " ; " << pos[1] << " ; " << pos[2] << " )"
           << " 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 == geo->NearestWire(pos.data(), wid.Plane, wid.TPC, wid.Cryostat))
             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,                        // summedADC
             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
             );
           
           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,                        // summedADC
         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
         );
       
       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;
 }

EngineCreator::seed_t EngineCreator::get_seed_value	(	fhicl::ParameterSet const &	pset,
		char const	key[] = `"seed"`,
		seed_t const	implicit_seed = `-1`
	)

inherited

Definition at line 49 of file EngineCreator.cc.

References fhicl::ParameterSet::get().

Referenced by art::MixFilter< T >::initEngine_().

 {
   auto const& explicit_seeds = pset.get<std::vector<int>>(key, {});
   return explicit_seeds.empty() ? implicit_seed : explicit_seeds.front();
 }

template<typename PROD , BranchType B>

ProductID art::EDProducer::getProductID ( std::string const & instanceName = {} ) const

inlineinherited

Definition at line 123 of file EDProducer.h.

References art::EDProducer::moduleDescription_.

   {
     return ProducerBase::getProductID<PROD, B>(moduleDescription_,
                                                instanceName);
   }

template<typename PROD , BranchType B>

ProductID art::ProducerBase::getProductID	(	ModuleDescription const &	moduleDescription,
		std::string const &	instanceName
	)		const

inherited

Definition at line 56 of file ProducerBase.h.

References B, and art::ModuleDescription::moduleLabel().

Referenced by art::ProducerBase::modifiesEvent().

   {
     auto const& pd =
       get_ProductDescription<PROD>(B, md.moduleLabel(), instanceName);
     return pd.productID();
   }

template<typename T , BranchType = InEvent>

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

inherited

template<typename T , art::BranchType BT>

art::ProductToken<T> art::Consumer::mayConsume ( InputTag const & it )

inherited

Definition at line 190 of file Consumer.h.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

 {
   if (!moduleContext_)
     return ProductToken<T>::invalid();
 
   consumables_[BT].emplace_back(ConsumableType::Product,
                                 TypeID{typeid(T)},
                                 it.label(),
                                 it.instance(),
                                 it.process());
   return ProductToken<T>{it};
 }

template<typename T , art::BranchType BT>

void art::Consumer::mayConsumeMany ( )

inherited

Definition at line 205 of file Consumer.h.

 {
   if (!moduleContext_)
     return;
 
   consumables_[BT].emplace_back(ConsumableType::Many, TypeID{typeid(T)});
 }

template<typename Element , BranchType = InEvent>

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

inherited

template<typename T , art::BranchType BT>

art::ViewToken<T> art::Consumer::mayConsumeView ( InputTag const & it )

inherited

Definition at line 215 of file Consumer.h.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

 {
   if (!moduleContext_)
     return ViewToken<T>::invalid();
 
   consumables_[BT].emplace_back(ConsumableType::ViewElement,
                                 TypeID{typeid(T)},
                                 it.label(),
                                 it.instance(),
                                 it.process());
   return ViewToken<T>{it};
 }

bool art::ProducerBase::modifiesEvent ( ) const

inlineinherited

Definition at line 40 of file ProducerBase.h.

References art::ProducerBase::getProductID().

     {
       return true;
     }

cet::exempt_ptr< art::Consumer > art::Consumer::non_module_context ( )

staticinherited

Definition at line 76 of file Consumer.cc.

 {
   static Consumer invalid{InvalidTag{}};
   return &invalid;
 }

void art::Consumer::prepareForJob ( fhicl::ParameterSet const & pset )

protectedinherited

Definition at line 89 of file Consumer.cc.

References fhicl::ParameterSet::get_if_present().

Referenced by art::EDProducer::doBeginJob(), art::EDFilter::doBeginJob(), and art::EDAnalyzer::doBeginJob().

 {
   if (!moduleContext_)
     return;
 
   pset.get_if_present("errorOnMissingConsumes", requireConsumes_);
   for (auto& consumablesPerBranch : consumables_) {
     cet::sort_all(consumablesPerBranch);
   }
 }

void hit::HitCheater::produce ( art::Event & e )

virtual

Implements art::EDProducer.

Definition at line 93 of file HitCheater_module.cc.

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

 {
   // this object contains the hit collection
   // and its associations to wires and raw digits:
   recob::HitCollectionCreator hits(*this, 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
   LOG_DEBUG("HitCheater") << "putting " << hits.size() << " hits into the event";
   hits.put_into(e);
 
   return;
 }

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

virtual

Definition at line 330 of file HitCheater_module.cc.

References DEFINE_ART_MODULE, fCalDataProductInstanceName, fElectronsToADC, fG4ModuleLabel, fMinCharge, fNewHitTDCGap, fNumberTimeSamples, fReadOutWindowSize, fSamplingRate, fTriggerOffset, fWireModuleLabel, and fhicl::ParameterSet::get().

Referenced by HitCheater().

 {
   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         );
 
   const detinfo::DetectorProperties* detprop = lar::providerFrom<detinfo::DetectorPropertiesService>();
   fElectronsToADC = detprop->ElectronsToADC();
   fSamplingRate   = detprop->SamplingRate();
   fTriggerOffset  = detprop->TriggerOffset();
 
    fCalDataProductInstanceName="";
    size_t pos = fWireModuleLabel.find(":");
    if( pos!=std::string::npos ) {
      fCalDataProductInstanceName = fWireModuleLabel.substr( pos+1 );
      fWireModuleLabel = fWireModuleLabel.substr( 0, pos );
    }
 
    fReadOutWindowSize  = detprop->ReadOutWindowSize();
    fNumberTimeSamples  = detprop->NumberTimeSamples();
 
   return;
 }

void art::Consumer::showMissingConsumes ( ) const

protectedinherited

Definition at line 125 of file Consumer.cc.

Referenced by art::EDProducer::doEndJob(), art::EDFilter::doEndJob(), art::EDAnalyzer::doEndJob(), and art::RootOutput::endJob().

 {
   if (!moduleContext_)
     return;
 
   // If none of the branches have missing consumes statements, exit early.
   if (std::all_of(cbegin(missingConsumes_),
                   cend(missingConsumes_),
                   [](auto const& perBranch) { return perBranch.empty(); }))
     return;
 
   constexpr cet::HorizontalRule rule{60};
   mf::LogPrint log{"MTdiagnostics"};
   log << '\n'
       << rule('=') << '\n'
       << "The following consumes (or mayConsume) statements are missing from\n"
       << module_context(moduleDescription_) << '\n'
       << rule('-') << '\n';
 
   cet::for_all_with_index(
     missingConsumes_, [&log](std::size_t const i, auto const& perBranch) {
       for (auto const& pi : perBranch) {
         log << "  "
             << assemble_consumes_statement(static_cast<BranchType>(i), pi)
             << '\n';
       }
     });
   log << rule('=');
 }

void art::Consumer::validateConsumedProduct	(	BranchType const	bt,
		ProductInfo const &	pi
	)

protectedinherited

Definition at line 101 of file Consumer.cc.

References art::errors::ProductRegistrationFailure.

 {
   // Early exits if consumes tracking has been disabled or if the
   // consumed product is an allowed consumable.
   if (!moduleContext_)
     return;
 
   if (cet::binary_search_all(consumables_[bt], pi))
     return;
 
   if (requireConsumes_) {
     throw Exception(errors::ProductRegistrationFailure,
                     "Consumer: an error occurred during validation of a "
                     "retrieved product\n\n")
       << "The following consumes (or mayConsume) statement is missing from\n"
       << module_context(moduleDescription_) << ":\n\n"
       << "  " << assemble_consumes_statement(bt, pi) << "\n\n";
   }
 
   missingConsumes_[bt].insert(pi);
 }