Inheritance diagram for trkf::Track3DKalmanHit:

Public Types
using	ModuleType = EDProducer

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

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

void	doBeginJob (SharedResources const &resources)

void	doEndJob ()

void	doRespondToOpenInputFile (FileBlock const &fb)

void	doRespondToCloseInputFile (FileBlock const &fb)

void	doRespondToOpenOutputFiles (FileBlock const &fb)

void	doRespondToCloseOutputFiles (FileBlock const &fb)

bool	doBeginRun (RunPrincipal &rp, ModuleContext const &mc)

bool	doEndRun (RunPrincipal &rp, ModuleContext const &mc)

bool	doBeginSubRun (SubRunPrincipal &srp, ModuleContext const &mc)

bool	doEndSubRun (SubRunPrincipal &srp, ModuleContext const &mc)

bool	doEvent (EventPrincipal &ep, ModuleContext const &mc, std::atomic< std::size_t > &counts_run, std::atomic< std::size_t > &counts_passed, std::atomic< std::size_t > &counts_failed)

void	fillProductDescriptions ()

void	registerProducts (ProductDescriptions &productsToRegister)

ModuleDescription const &	moduleDescription () const

void	setModuleDescription (ModuleDescription const &)

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

void	sortConsumables (std::string const &current_process_name)

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

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

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

Protected Member Functions
ConsumesCollector &	consumesCollector ()

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

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

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

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

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

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

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

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

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

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, detinfo::DetectorPropertiesData const &detProp, 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 73 of file Track3DKalmanHit_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

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

explicit

Constructor.

Arguments:

p - Fcl parameters.

Definition at line 131 of file Track3DKalmanHit_module.cc.

References fClusterModuleLabel, fHIncChisq, fHist, fHitModuleLabel, fHPull, fNumEvent, fPFParticleModuleLabel, fSpacePointAlg, fTKHAlg, fUseClusterHits, fUsePFParticleHits, fUsePFParticleSeeds, and art::ProductRegistryHelper::produces().

   : EDProducer{pset}
   , 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)
 {
   fHist = pset.get<bool>("Hist");
   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";
   }
 
   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 ( )

overrideprivatevirtual

Begin job method.

Reimplemented from art::EDProducer.

Definition at line 174 of file Track3DKalmanHit_module.cc.

References dir, fHIncChisq, fHist, and fHPull.

 {
   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 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 trkf::Track3DKalmanHit::createOutputs	(	const art::Event &	evt,
		detinfo::DetectorPropertiesData const &	detProp,
		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 371 of file Track3DKalmanHit_module.cc.

References art::Assns< L, R, D >::addSingle(), trkf::SpacePointAlg::fillSpacePoints(), fSpacePointAlg, fUsePFParticleHits, trkf::SpacePointAlg::getAssociatedHits(), art::ProductRetriever::getProductID(), recob::Track::NumberTrajectoryPoints(), art::ProductRetriever::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 = evt.getProductID<std::vector<recob::Track>>();
   auto const tidgetter = evt.productGetter(tid);
 
   auto const spacepointId = evt.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(detProp, 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(detProp, 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
   }
 }

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

overrideprivatevirtual

End job method.

Reimplemented from art::EDProducer.

Definition at line 235 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 461 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);
         }
       }
     }
   }
 }

void art::Modifier::fillProductDescriptions ( )

inherited

Definition at line 10 of file Modifier.cc.

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

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

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 281 of file Track3DKalmanHit_module.cc.

References fHitModuleLabel, art::ProductRetriever::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 262 of file Track3DKalmanHit_module.cc.

References art::PtrVector< T >::end(), fClusterModuleLabel, art::ProductRetriever::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;
 }

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

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

private

Definition at line 254 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 298 of file Track3DKalmanHit_module.cc.

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

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 const&) {
         seedHitVec.clear();
       }
       kalman_input.seedhits.emplace_back();
       Hits& seedhits = kalman_input.seedhits.back();
       seedhits.insert(seedhits.end(), seedHitVec.begin(), seedHitVec.end());
     }
   }
   return inputs;
 }

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

private

Definition at line 243 of file Track3DKalmanHit_module.cc.

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

Referenced by produce().

 {
   fSpacePointAlg.clearHitMap();
 }

void trkf::Track3DKalmanHit::produce ( art::Event & evt )

overrideprivatevirtual

Produce method.

Implements art::EDProducer.

Definition at line 189 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 const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
   auto const detProp =
     art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataFor(evt, clockData);
   auto outputs = fTKHAlg.makeTracks(clockData, detProp, inputs);
 
   if (fHist) { fillHistograms(outputs); }
 
   createOutputs(evt,
                 detProp,
                 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 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);
   }