Inheritance diagram for trkf::Track3DKalmanHit:

Public Types
using	ModuleType = EDProducer

using	WorkerType = WorkerT< EDProducer >

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

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

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

virtual void	produce (art::Event &e) override

virtual void	beginJob () override
	Begin job method. More...

virtual void	endJob () override
	End job method. More...

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

KalmanInputs	getInput (const art::Event &evt) const

Hits	getClusteredHits (const art::Event &evt) const
	Fill a collection using clustered hits. More...

KalmanInputs	getPFParticleStuff (const art::Event &evt) const
	If UsePFParticles is true use this method to fill in hits. More...

Hits	getAllHits (const art::Event &evt) const
	If both UseClusteredHits and UsePFParticles is false use this method to fill in hits. More...

void	createOutputs (const art::Event &evt, const std::vector< KalmanOutput > &outputs, const KalmanInputs &inputs, std::vector< recob::Track > &tracks, std::vector< recob::SpacePoint > &spts, art::Assns< recob::Track, recob::Hit > &th_assn, art::Assns< recob::Track, recob::Hit, recob::TrackHitMeta > &thm_assn, art::Assns< recob::Track, recob::SpacePoint > &tsp_assn, art::Assns< recob::SpacePoint, recob::Hit > &sph_assn, art::Assns< recob::PFParticle, recob::Track > &pfPartTrack_assns)

void	fillHistograms (std::vector< KalmanOutput > &outputs)
	Fill Histograms method. More...

Private Attributes
bool	fHist
	Make histograms. More...

bool	fUseClusterHits
	Use clustered hits as input. More...

bool	fUsePFParticleHits
	Use PFParticle hits as input. More...

bool	fUsePFParticleSeeds
	Use PFParticle seeds. More...

std::string	fHitModuleLabel
	Unclustered Hits. More...

std::string	fClusterModuleLabel
	Clustered Hits. More...

std::string	fPFParticleModuleLabel
	PFParticle label. More...

Track3DKalmanHitAlg	fTKHAlg
	Track3DKalmanHit algorithm. More...

SpacePointAlg	fSpacePointAlg
	Space point algorithm. More...

TH1F *	fHIncChisq
	Incremental chisquare. More...

TH1F *	fHPull
	Hit pull. More...

int	fNumEvent
	Number of events seen. More...

Detailed Description

Definition at line 69 of file Track3DKalmanHit_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

trkf::Track3DKalmanHit::Track3DKalmanHit ( fhicl::ParameterSet const & pset )

explicit

Constructor.

Arguments:

p - Fcl parameters.

Definition at line 131 of file Track3DKalmanHit_module.cc.

References fClusterModuleLabel, fHitModuleLabel, fUseClusterHits, and reconfigure().

                                                                      :
 fHist(false),
 fUseClusterHits(false),
 fUsePFParticleHits(false),
 fUsePFParticleSeeds(false),
 fTKHAlg(pset.get<fhicl::ParameterSet>("Track3DKalmanHitAlg")),
 fSpacePointAlg(pset.get<fhicl::ParameterSet>("SpacePointAlg")),
 fHIncChisq(0),
 fHPull(0),
 fNumEvent(0)
 {
    reconfigure(pset);
    produces<std::vector<recob::Track> >();
    produces<std::vector<recob::SpacePoint>            >();
    produces<art::Assns<recob::Track, recob::Hit> >(); // ****** REMEMBER to remove when FindMany improved ******
    produces<art::Assns<recob::Track, recob::Hit, recob::TrackHitMeta> >();
    produces<art::Assns<recob::Track, recob::SpacePoint> >();
    produces<art::Assns<recob::SpacePoint, recob::Hit> >();
    produces<art::Assns<recob::PFParticle, recob::Track> >();
    
    // Report.
    
    mf::LogInfo("Track3DKalmanHit")
    << "Track3DKalmanHit configured with the following parameters:\n"
    << "  UseClusterHits = " << fUseClusterHits << "\n"
    << "  HitModuleLabel = " << fHitModuleLabel << "\n"
    << "  ClusterModuleLabel = " << fClusterModuleLabel;
 }

Member Function Documentation

void trkf::Track3DKalmanHit::beginJob ( )

overridevirtual

Begin job method.

Reimplemented from art::EDProducer.

Definition at line 187 of file Track3DKalmanHit_module.cc.

References dir, fHIncChisq, fHist, fHPull, art::TFileDirectory::make(), and art::TFileDirectory::mkdir().

 {
    if(fHist) {
       // Book histograms.
       art::ServiceHandle<art::TFileService> tfs;
       art::TFileDirectory dir = tfs->mkdir("hitkalman", "Track3DKalmanHit histograms");
       
       fHIncChisq = dir.make<TH1F>("IncChisq", "Incremental Chisquare", 100, 0., 20.);
       fHPull = dir.make<TH1F>("Pull", "Hit Pull", 100, -10., 10.);
    }
 }

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);
 }

void trkf::Track3DKalmanHit::createOutputs	(	const art::Event &	evt,
		const std::vector< KalmanOutput > &	outputs,
		const KalmanInputs &	inputs,
		std::vector< recob::Track > &	tracks,
		std::vector< recob::SpacePoint > &	spts,
		art::Assns< recob::Track, recob::Hit > &	th_assn,
		art::Assns< recob::Track, recob::Hit, recob::TrackHitMeta > &	thm_assn,
		art::Assns< recob::Track, recob::SpacePoint > &	tsp_assn,
		art::Assns< recob::SpacePoint, recob::Hit > &	sph_assn,
		art::Assns< recob::PFParticle, recob::Track > &	pfPartTrack_assns
	)

private

Definition at line 372 of file Track3DKalmanHit_module.cc.

References art::Assns< L, R, D >::addSingle(), trkf::SpacePointAlg::fillSpacePoints(), fSpacePointAlg, fUsePFParticleHits, trkf::SpacePointAlg::getAssociatedHits(), recob::Track::NumberTrajectoryPoints(), art::Event::productGetter(), art::PtrVector< T >::size(), and track.

Referenced by produce().

 {
    if(outputs.size()!= inputs.size()) return;
    
    size_t tracksSize(0);
    for(auto const &kalman_output : outputs) {
       tracksSize += kalman_output.tracks.size();
    }
    tracks.reserve(tracksSize);
    
    auto const tid = getProductID<std::vector<recob::Track> >();
    auto const tidgetter = evt.productGetter(tid);
    
    auto const spacepointId = getProductID<std::vector<recob::SpacePoint> >();
    auto const getter = evt.productGetter(spacepointId);
    for (size_t i = 0; i<outputs.size();++i) {
       // Recover the kalman tracks double ended queue
       const std::deque<KGTrack>& kalman_tracks = outputs[i].tracks;
       
       for(auto const& kalman_track:kalman_tracks) {
          
          // Add Track object to collection.
          recob::Track track;
          kalman_track.fillTrack(track, tracks.size());
          if(track.NumberTrajectoryPoints() < 2) {
             continue;
          }
          unsigned int numtrajpts = track.NumberTrajectoryPoints();
          tracks.emplace_back(std::move(track));
          // SS: tracks->size() does not change after this point in each iteration
          
          //fill hits from this track
          Hits trhits;
          std::vector<unsigned int> hittpindex; //hit-trajectory point index
          kalman_track.fillHits(trhits, hittpindex);
          if (hittpindex.back()>=numtrajpts){ //something is wrong
            throw cet::exception("Track3DKalmanHit")
              << "Last hit corresponds to trajectory point index "<<hittpindex.back()<<" while the number of trajectory points is "<<numtrajpts<<'\n';
          }
          
          // Make space points from this track.
          auto nspt = spts.size();
          fSpacePointAlg.fillSpacePoints(spts, kalman_track.TrackMap());
          
          std::vector<art::Ptr<recob::SpacePoint>> sptvec;
          for(auto ispt = nspt; ispt < spts.size(); ++ispt) {
             sptvec.emplace_back(spacepointId, ispt, getter);
             // Associate newly created space points with hits.
             // Make space point to hit associations.
             auto const &sphits = fSpacePointAlg.getAssociatedHits((spts)[ispt]);
             for(auto const& sphit: sphits) {
                sph_assn.addSingle(sptvec.back(), sphit);
             }
          }
          
          art::Ptr<recob::Track> aptr(tid, tracks.size()-1, tidgetter);
          
          // Make Track to Hit associations.
          for (size_t h = 0; h< trhits.size(); ++h){
             th_assn.addSingle(aptr, trhits[h]);
             recob::TrackHitMeta metadata(hittpindex[h], -1);
             thm_assn.addSingle(aptr, trhits[h], metadata);
          }
          
          // Make track to space point associations
          for (auto const& spt: sptvec) {
             tsp_assn.addSingle(aptr, spt);
          }
          
          // Optionally fill track-to-PFParticle associations.
          if (fUsePFParticleHits) {
             pfPartTrack_assns.addSingle(inputs[i].pfPartPtr, aptr);
          }
       } // end of loop over a given collection
    }
 }

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 trkf::Track3DKalmanHit::endJob ( )

overridevirtual

End job method.

Reimplemented from art::EDProducer.

Definition at line 237 of file Track3DKalmanHit_module.cc.

References fNumEvent.

 {
    mf::LogInfo("Track3DKalmanHit")
    << "Track3DKalmanHit statistics:\n"
    << "  Number of events = " << fNumEvent << "\n";
 }

void trkf::Track3DKalmanHit::fillHistograms ( std::vector< KalmanOutput > & outputs )

private

Fill Histograms method.

Definition at line 462 of file Track3DKalmanHit_module.cc.

References fHIncChisq, fHPull, trkf::KHitTrack::getHit(), trkf::KHit< N >::getResError(), trkf::KHit< N >::getResVector(), and trkf::KGTrack::getTrackMap().

Referenced by produce().

 {
    for(auto const &output : outputs) {
       const std::deque<KGTrack>& kalman_tracks = output.tracks;
       for (size_t i = 0; i < kalman_tracks.size(); ++i) {
          const KGTrack& trg = kalman_tracks[i];
          // Loop over measurements in this track.
          const std::multimap<double, KHitTrack>& trackmap = trg.getTrackMap();
          for(std::multimap<double, KHitTrack>::const_iterator ih = trackmap.begin();
              ih != trackmap.end(); ++ih) {
             const KHitTrack& trh = (*ih).second;
             const std::shared_ptr<const KHitBase>& hit = trh.getHit();
             double chisq = hit->getChisq();
             fHIncChisq->Fill(chisq);
             const KHit<1>* ph1 = dynamic_cast<const KHit<1>*>(&*hit);
             if(ph1 != 0) {
                double pull = ph1->getResVector()(0) / std::sqrt(ph1->getResError()(0, 0));
                fHPull->Fill(pull);
             }
          }
       }
    }
 }

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();
 }

trkf::Hits trkf::Track3DKalmanHit::getAllHits ( const art::Event & evt ) const

private

If both UseClusteredHits and UsePFParticles is false use this method to fill in hits.

Definition at line 284 of file Track3DKalmanHit_module.cc.

References fHitModuleLabel, art::DataViewImpl::getByLabel(), hits(), art::Handle< T >::isValid(), art::PtrVector< T >::push_back(), and art::PtrVector< T >::reserve().

Referenced by getInput().

                                                                   {
    Hits hits;
    art::Handle< std::vector<recob::Hit> > hith;
    evt.getByLabel(fHitModuleLabel, hith);
    if(!hith.isValid()) return hits;
    size_t nhits = hith->size();
    hits.reserve(nhits);
    
    for(size_t i = 0; i < nhits; ++i) {
       hits.push_back(art::Ptr<recob::Hit>(hith, i));
    }
    return hits;
 }

trkf::Hits trkf::Track3DKalmanHit::getClusteredHits ( const art::Event & evt ) const

private

Fill a collection using clustered hits.

Definition at line 266 of file Track3DKalmanHit_module.cc.

References art::PtrVector< T >::end(), fClusterModuleLabel, art::DataViewImpl::getByLabel(), hits(), art::PtrVector< T >::insert(), and art::Handle< T >::isValid().

Referenced by getInput().

                                                                         {
    Hits hits;
    art::Handle< std::vector<recob::Cluster> > clusterh;
    evt.getByLabel(fClusterModuleLabel, clusterh);
    
    if (!clusterh.isValid()) return hits;
    // Get hits from all clusters.
    art::FindManyP<recob::Hit> hitsbycluster(clusterh, evt, fClusterModuleLabel);
    
    for(size_t i = 0; i < clusterh->size(); ++i) {
       std::vector< art::Ptr<recob::Hit> > clushits = hitsbycluster.at(i);
       hits.insert(hits.end(), clushits.begin(), clushits.end());
    }
    return hits;
 }

trkf::KalmanInputs trkf::Track3DKalmanHit::getInput ( const art::Event & evt ) const

private

Definition at line 257 of file Track3DKalmanHit_module.cc.

References fUseClusterHits, fUsePFParticleHits, getAllHits(), getClusteredHits(), and getPFParticleStuff().

Referenced by produce().

                                                                         {
    if (fUsePFParticleHits) return getPFParticleStuff(evt);
    return KalmanInputs(1, KalmanInput(fUseClusterHits ?
                                       getClusteredHits(evt):
                                       getAllHits(evt)));
 }

trkf::KalmanInputs trkf::Track3DKalmanHit::getPFParticleStuff ( const art::Event & evt ) const

private

If UsePFParticles is true use this method to fill in hits.

Definition at line 300 of file Track3DKalmanHit_module.cc.

References art::PtrVector< T >::end(), fClusterModuleLabel, fPFParticleModuleLabel, fUsePFParticleSeeds, art::DataViewImpl::getByLabel(), hits(), trkf::KalmanInput::hits, art::PtrVector< T >::insert(), art::Handle< T >::isValid(), trkf::KalmanInput::pfPartPtr, trkf::KalmanInput::seedhits, trkf::KalmanInput::seeds, and x.

Referenced by getInput().

                                                                                   {
    KalmanInputs inputs;
    // Our program is to drive the track creation/fitting off the PFParticles in the data store
    // We'll use the hits associated to the PFParticles for each track - and only those hits.
    // Without a valid collection of PFParticles there is nothing to do here
    // We need a handle to the collection of clusters in the data store so we can
    // handle associations to hits.
    art::Handle<std::vector<recob::PFParticle> > pfParticleHandle;
    evt.getByLabel(fPFParticleModuleLabel, pfParticleHandle);
    if (!pfParticleHandle.isValid()) return inputs;
    
    art::Handle<std::vector<recob::Cluster> > clusterHandle;
    evt.getByLabel(fClusterModuleLabel, clusterHandle);
    
    // If there are no clusters then something is really wrong
    if (!clusterHandle.isValid()) return inputs;
    
    // Recover the collection of associations between PFParticles and clusters, this will
    // be the mechanism by which we actually deal with clusters
    art::FindManyP<recob::Cluster> clusterAssns(pfParticleHandle, evt, fPFParticleModuleLabel);
    
    // Associations to seeds.
    art::FindManyP<recob::Seed> seedAssns(pfParticleHandle, evt, fPFParticleModuleLabel);
    
    // Likewise, recover the collection of associations to hits
    art::FindManyP<recob::Hit> clusterHitAssns(clusterHandle, evt, fClusterModuleLabel);
    
    inputs.reserve(pfParticleHandle->size());
    
    // While PFParticle describes a hierarchal structure, for now we simply loop over the collection
    for(size_t partIdx = 0; partIdx < pfParticleHandle->size(); partIdx++) {
       
       // Add a new empty hit collection.
       inputs.emplace_back();
       KalmanInput& kalman_input = inputs.back();
       kalman_input.pfPartPtr = art::Ptr<recob::PFParticle>(pfParticleHandle, partIdx);
       Hits& hits = kalman_input.hits;
       
       // Fill this hit vector by looping over associated clusters and finding the
       // hits associated to them
       std::vector<art::Ptr<recob::Cluster> > clusterVec = clusterAssns.at(partIdx);
       
       for(auto const &cluster : clusterVec) {
          std::vector<art::Ptr<recob::Hit> > hitVec = clusterHitAssns.at(cluster.key());
          hits.insert(hits.end(), hitVec.begin(), hitVec.end());
       }
       
       // If requested, fill associated seeds.
       if(!fUsePFParticleSeeds) continue;
       art::PtrVector<recob::Seed>& seeds = kalman_input.seeds;
       std::vector<art::Ptr<recob::Seed> > seedVec = seedAssns.at(partIdx);
       seeds.insert(seeds.end(), seedVec.begin(), seedVec.end());
       art::FindManyP<recob::Hit> seedHitAssns(seedVec, evt, fPFParticleModuleLabel);
       
       for(size_t seedIdx = 0; seedIdx < seedVec.size(); ++seedIdx) {
          std::vector<art::Ptr<recob::Hit> > seedHitVec;
          //SS: why seedIdx can have an invalid value?
          try {
             seedHitVec = seedHitAssns.at(seedIdx);
          }
          catch(art::Exception x) {
             seedHitVec.clear();
          }
          kalman_input.seedhits.emplace_back();
          Hits& seedhits = kalman_input.seedhits.back();
          seedhits.insert(seedhits.end(), seedHitVec.begin(), seedHitVec.end());
       }
    }
    return inputs;
 }

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 trkf::Track3DKalmanHit::prepareForInput ( )

private

Definition at line 247 of file Track3DKalmanHit_module.cc.

References trkf::SpacePointAlg::clearHitMap(), and fSpacePointAlg.

Referenced by produce().

                                            {
    fSpacePointAlg.clearHitMap();
 }

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 trkf::Track3DKalmanHit::produce ( art::Event & evt )

overridevirtual

Produce method.

Implements art::EDProducer.

Definition at line 202 of file Track3DKalmanHit_module.cc.

References trkf::SpacePointAlg::clearHitMap(), createOutputs(), fHist, fillHistograms(), fNumEvent, fSpacePointAlg, fTKHAlg, getInput(), trkf::Track3DKalmanHitAlg::makeTracks(), prepareForInput(), and art::Event::put().

 {
    ++fNumEvent;
    auto tracks = std::make_unique<std::vector<recob::Track>>();
    auto th_assn = std::make_unique<art::Assns<recob::Track, recob::Hit>>();
    auto thm_assn = std::make_unique< art::Assns< recob::Track, recob::Hit, recob::TrackHitMeta > >();
    auto tsp_assn = std::make_unique<art::Assns<recob::Track, recob::SpacePoint>>();
    auto pfPartTrack_assns = std::make_unique<art::Assns<recob::PFParticle, recob::Track>>();
    auto spts = std::make_unique<std::vector<recob::SpacePoint>>();
    auto sph_assn = std::make_unique<art::Assns<recob::SpacePoint, recob::Hit>>();
    
    prepareForInput();
    auto inputs = getInput(evt);
    
    auto outputs = fTKHAlg.makeTracks(inputs);
    
    if(fHist) {
       fillHistograms(outputs);
    }
    
    createOutputs(evt, outputs, inputs, *tracks, *spts, *th_assn, *thm_assn, *tsp_assn, *sph_assn, *pfPartTrack_assns);
    
    fSpacePointAlg.clearHitMap();
    
    evt.put(std::move(tracks));
    evt.put(std::move(spts));
    evt.put(std::move(th_assn));
    evt.put(std::move(thm_assn));
    evt.put(std::move(tsp_assn));
    evt.put(std::move(sph_assn));
    evt.put(std::move(pfPartTrack_assns));
 }

void trkf::Track3DKalmanHit::reconfigure ( fhicl::ParameterSet const & pset )

virtual

Reconfigure method.

Arguments:

p - Fcl parameter set.

Definition at line 168 of file Track3DKalmanHit_module.cc.

References fClusterModuleLabel, fHist, fHitModuleLabel, fPFParticleModuleLabel, fSpacePointAlg, fTKHAlg, fUseClusterHits, fUsePFParticleHits, fUsePFParticleSeeds, fhicl::ParameterSet::get(), trkf::Track3DKalmanHitAlg::reconfigure(), and trkf::SpacePointAlg::reconfigure().

Referenced by Track3DKalmanHit().

 {
    fHist = pset.get<bool>("Hist");
    fTKHAlg.reconfigure(pset.get<fhicl::ParameterSet>("Track3DKalmanHitAlg"));
    fSpacePointAlg.reconfigure(pset.get<fhicl::ParameterSet>("SpacePointAlg"));
    fUseClusterHits = pset.get<bool>("UseClusterHits");
    fUsePFParticleHits = pset.get<bool>("UsePFParticleHits");
    fUsePFParticleSeeds = pset.get<bool>("UsePFParticleSeeds");
    fHitModuleLabel = pset.get<std::string>("HitModuleLabel");
    fClusterModuleLabel = pset.get<std::string>("ClusterModuleLabel");
    fPFParticleModuleLabel = pset.get<std::string>("PFParticleModuleLabel");
    if(fUseClusterHits && fUsePFParticleHits) {
       throw cet::exception("Track3DKalmanHit")
       << "Using input from both clustered and PFParticle hits.\n";
    }
 }

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);
 }