Inheritance diagram for trkf::Track3DKalmanHit:

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

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.

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.

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

overrideprivate

Begin job method.

Definition at line 175 of file Track3DKalmanHit_module.cc.

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

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

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

overrideprivate

End job method.

Definition at line 238 of file Track3DKalmanHit_module.cc.

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

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

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

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

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

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

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

void trkf::Track3DKalmanHit::prepareForInput ( )

private

Definition at line 247 of file Track3DKalmanHit_module.cc.

 {
   fSpacePointAlg.clearHitMap();
 }

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

overrideprivate

Produce method.

Definition at line 191 of file Track3DKalmanHit_module.cc.

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