Inheritance diagram for trkf::PMAlgTrackMaker:

Classes
struct	Config

Public Types
using	Parameters = art::EDProducer::Table< Config >

Public Types inherited from art::EDProducer
using	ModuleType = EDProducer

using	WorkerType = WorkerT< EDProducer >

Public Types inherited from art::detail::Producer
template<typename UserConfig , typename KeysToIgnore = void>
using	Table = Modifier::Table< UserConfig, KeysToIgnore >

Public Types inherited from art::Modifier
template<typename UserConfig , typename UserKeysToIgnore = void>
using	Table = ProducerTable< UserConfig, detail::ModuleConfig, UserKeysToIgnore >

Public Member Functions
	PMAlgTrackMaker (Parameters const &config)

	PMAlgTrackMaker (PMAlgTrackMaker const &)=delete

	PMAlgTrackMaker (PMAlgTrackMaker &&)=delete

PMAlgTrackMaker &	operator= (PMAlgTrackMaker const &)=delete

PMAlgTrackMaker &	operator= (PMAlgTrackMaker &&)=delete

Public Member Functions inherited from art::EDProducer
	EDProducer (fhicl::ParameterSet const &pset)

template<typename Config >
	EDProducer (Table< Config > const &config)

std::string	workerType () const

Public Member Functions inherited from art::detail::Producer
virtual	~Producer () noexcept

	Producer (fhicl::ParameterSet const &)

	Producer (Producer const &)=delete

	Producer (Producer &&)=delete

Producer &	operator= (Producer const &)=delete

Producer &	operator= (Producer &&)=delete

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)

Public Member Functions inherited from art::Modifier
	~Modifier () noexcept

	Modifier ()

	Modifier (Modifier const &)=delete

	Modifier (Modifier &&)=delete

Modifier &	operator= (Modifier const &)=delete

Modifier &	operator= (Modifier &&)=delete

Public Member Functions inherited from art::ModuleBase
virtual	~ModuleBase () noexcept

	ModuleBase ()

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)

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

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

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

template<size_t N>
bool	init (const art::Event &evt, pma::PMAlgTracker &pmalgTracker) const

template<size_t N>
int	getPdgFromCnnOnHits (const art::Event &evt, const pma::Track3D &trk) const

std::vector< anab::CosmicTagID_t >	getCosmicTag (const pma::Track3D::ETag pmaTag) const

Static Private Attributes
static const std::string	kKinksName = "kink"

static const std::string	kNodesName = "node"

Additional Inherited Members
Static Public Member Functions inherited from art::EDProducer
static void	commitEvent (EventPrincipal &ep, Event &e)

Protected Member Functions inherited from art::ModuleBase
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 ()

Detailed Description

Definition at line 71 of file PMAlgTrackMaker_module.cc.

Member Typedef Documentation

using trkf::PMAlgTrackMaker::Parameters = art::EDProducer::Table<Config>

Definition at line 112 of file PMAlgTrackMaker_module.cc.

Constructor & Destructor Documentation

trkf::PMAlgTrackMaker::PMAlgTrackMaker ( PMAlgTrackMaker::Parameters const & config )

explicit

Definition at line 167 of file PMAlgTrackMaker_module.cc.

     : EDProducer{config}
     , fHitModuleLabel(config().HitModuleLabel())
     , fWireModuleLabel(config().WireModuleLabel())
     , fCluModuleLabel(config().ClusterModuleLabel())
     , fEmModuleLabel(config().EmClusterModuleLabel())
     , fPmaConfig(config().ProjectionMatchingAlg())
     , fPmaTrackerConfig(config().PMAlgTracking())
     , fPmaTaggingConfig(config().PMAlgCosmicTagging())
     , fPmaVtxConfig(config().PMAlgVertexing())
     , fPmaStitchConfig(config().PMAlgStitching())
     , fSaveOnlyBranchingVtx(config().SaveOnlyBranchingVtx())
     , fSavePmaNodes(config().SavePmaNodes())
     , fGeom(art::ServiceHandle<geo::Geometry const>().get())
   {
     produces<std::vector<recob::Track>>();
     produces<std::vector<recob::SpacePoint>>();
     produces<std::vector<recob::Vertex>>();           // no instance name for interaction vertices
     produces<std::vector<recob::Vertex>>(kKinksName); // collection of kinks on tracks
     produces<std::vector<recob::Vertex>>(kNodesName); // collection of pma nodes
     produces<std::vector<anab::T0>>();
     produces<std::vector<anab::CosmicTag>>(); // Cosmic ray tags
 
     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::Vertex,
                  recob::Track>>(); // no instance name for assns of tracks to interaction vertices
     produces<art::Assns<recob::Track, recob::Vertex>>(kKinksName); // assns of kinks to tracks
     produces<art::Assns<recob::Track, anab::T0>>();
     produces<art::Assns<recob::Track, anab::CosmicTag>>(); // Cosmic ray tags associated to tracks
 
     produces<std::vector<recob::PFParticle>>();
     produces<art::Assns<recob::PFParticle, recob::Cluster>>();
     produces<art::Assns<recob::PFParticle, recob::Vertex>>();
     produces<art::Assns<recob::PFParticle, recob::Track>>();
 
     if (fPmaTrackerConfig.Validation() == "calib") // create histograms only in the calibration mode
     {
       art::ServiceHandle<art::TFileService const> tfs;
       for (size_t p = 0; p < fGeom->MaxPlanes(); ++p) {
         std::ostringstream ss1;
         ss1 << "adc_plane_" << p;
         fAdcInPassingPoints.push_back(tfs->make<TH1F>(
           (ss1.str() + "_passing").c_str(), "max adc around the point on track", 100., 0., 5.));
         fAdcInRejectedPoints.push_back(tfs->make<TH1F>(
           (ss1.str() + "_rejected").c_str(), "max adc around spurious point ", 100., 0., 5.));
       }
     }
   }

trkf::PMAlgTrackMaker::PMAlgTrackMaker ( PMAlgTrackMaker const & )

delete

trkf::PMAlgTrackMaker::PMAlgTrackMaker ( PMAlgTrackMaker && )

delete

Member Function Documentation

std::vector< anab::CosmicTagID_t > trkf::PMAlgTrackMaker::getCosmicTag ( const pma::Track3D::ETag pmaTag ) const

private

Definition at line 294 of file PMAlgTrackMaker_module.cc.

   {
     std::vector<anab::CosmicTagID_t> anabTags;
 
     if (pmaTag & pma::Track3D::kOutsideDrift_Partial) {
       anabTags.push_back(anab::CosmicTagID_t::kOutsideDrift_Partial);
     }
     if (pmaTag & pma::Track3D::kOutsideDrift_Complete) {
       anabTags.push_back(anab::CosmicTagID_t::kOutsideDrift_Complete);
     }
     if (pmaTag & pma::Track3D::kBeamIncompatible) {
       anabTags.push_back(anab::CosmicTagID_t::kFlash_BeamIncompatible);
     }
     if (pmaTag & pma::Track3D::kGeometry_XX) {
       anabTags.push_back(anab::CosmicTagID_t::kGeometry_XX);
     }
     if (pmaTag & pma::Track3D::kGeometry_YY) {
       anabTags.push_back(anab::CosmicTagID_t::kGeometry_YY);
     }
     if (pmaTag & pma::Track3D::kGeometry_ZZ) {
       anabTags.push_back(anab::CosmicTagID_t::kGeometry_ZZ);
     }
     if (pmaTag & pma::Track3D::kGeometry_YZ) {
       anabTags.push_back(anab::CosmicTagID_t::kGeometry_YZ);
     }
     if (pmaTag & pma::Track3D::kGeometry_Y) {
       anabTags.push_back(anab::CosmicTagID_t::kGeometry_Y);
     }
 
     if (anabTags.empty()) { anabTags.push_back(anab::CosmicTagID_t::kUnknown); }
 
     return anabTags;
   }

template<size_t N>

int trkf::PMAlgTrackMaker::getPdgFromCnnOnHits	(	const art::Event &	evt,
		const pma::Track3D &	trk
	)		const

private

Definition at line 225 of file PMAlgTrackMaker_module.cc.

   {
     int pdg = 0;
     if (fPmaTrackerConfig.TrackLikeThreshold() > 0) {
       auto hitResults = anab::MVAReader<recob::Hit, N>::create(evt, fCluModuleLabel);
       if (hitResults) {
         int trkLikeIdx = hitResults->getIndex("track");
         int emLikeIdx = hitResults->getIndex("em");
         if ((trkLikeIdx < 0) || (emLikeIdx < 0)) {
           throw cet::exception("PMAlgTrackMaker")
             << "No em/track labeled columns in MVA data products." << std::endl;
         }
 
         size_t nh[3] = {0, 0, 0};
         for (size_t hidx = 0; hidx < trk.size(); ++hidx) {
           ++nh[trk[hidx]->View2D()];
         }
 
         size_t best_view = 2;                                          // collection
         if ((nh[0] >= nh[1]) && (nh[0] > 1.25 * nh[2])) best_view = 0; // ind1
         if ((nh[1] >= nh[0]) && (nh[1] > 1.25 * nh[2])) best_view = 1; // ind2
 
         std::vector<art::Ptr<recob::Hit>> trkHitPtrList;
         trkHitPtrList.reserve(nh[best_view]);
         for (size_t hidx = 0; hidx < trk.size(); ++hidx) {
           if (trk[hidx]->View2D() == best_view) {
             trkHitPtrList.emplace_back(trk[hidx]->Hit2DPtr());
           }
         }
         auto vout = hitResults->getOutput(trkHitPtrList);
         double trk_like = -1, trk_or_em = vout[trkLikeIdx] + vout[emLikeIdx];
         if (trk_or_em > 0) {
           trk_like = vout[trkLikeIdx] / trk_or_em;
           if (trk_like < fPmaTrackerConfig.TrackLikeThreshold()) pdg = 11; // tag if EM-like
           // (don't set pdg for track-like, for the moment don't like the idea of using "13")
         }
         //std::cout << "trk:" << best_view << ":" << trk.size() << ":" << trkHitPtrList.size() << " p=" << trk_like << std::endl;
       }
     }
     return pdg;
   }

template<size_t N>

bool trkf::PMAlgTrackMaker::init	(	const art::Event &	evt,
		pma::PMAlgTracker &	pmalgTracker
	)		const

private

Definition at line 269 of file PMAlgTrackMaker_module.cc.

   {
     auto cluResults = anab::MVAReader<recob::Cluster, N>::create(evt, fCluModuleLabel);
     if (!cluResults) { return false; }
 
     int trkLikeIdx = cluResults->getIndex("track");
     int emLikeIdx = cluResults->getIndex("em");
     if ((trkLikeIdx < 0) || (emLikeIdx < 0)) { return false; }
 
     const art::FindManyP<recob::Hit> hitsFromClusters(
       cluResults->dataHandle(), evt, cluResults->dataTag());
     const auto& cnnOuts = cluResults->outputs();
     std::vector<float> trackLike(cnnOuts.size());
     for (size_t i = 0; i < cnnOuts.size(); ++i) {
       double trkOrEm = cnnOuts[i][trkLikeIdx] + cnnOuts[i][emLikeIdx];
       if (trkOrEm > 0) { trackLike[i] = cnnOuts[i][trkLikeIdx] / trkOrEm; }
       else {
         trackLike[i] = 0;
       }
     }
     pmalgTracker.init(hitsFromClusters, trackLike);
     return true;
   }

PMAlgTrackMaker& trkf::PMAlgTrackMaker::operator= ( PMAlgTrackMaker const & )

delete

PMAlgTrackMaker& trkf::PMAlgTrackMaker::operator= ( PMAlgTrackMaker && )

delete

void trkf::PMAlgTrackMaker::produce ( art::Event & e )

overrideprivatevirtual

Implements art::EDProducer.

Definition at line 329 of file PMAlgTrackMaker_module.cc.

   {
     // ---------------- Create data products --------------------------
     auto tracks = std::make_unique<std::vector<recob::Track>>();
     auto allsp = std::make_unique<std::vector<recob::SpacePoint>>();
     auto vtxs = std::make_unique<std::vector<recob::Vertex>>(); // interaction vertices
     auto kinks = std::make_unique<
       std::vector<recob::Vertex>>(); // kinks on tracks (no new particles start in kinks)
     auto nodes = std::make_unique<std::vector<recob::Vertex>>(); // pma nodes
     auto t0s = std::make_unique<std::vector<anab::T0>>();
     auto cosmicTags = std::make_unique<std::vector<anab::CosmicTag>>();
 
     auto trk2hit_oldway = std::make_unique<
       art::Assns<recob::Track,
                  recob::Hit>>(); // ****** REMEMBER to remove when FindMany improved ******
     auto trk2hit = std::make_unique<art::Assns<recob::Track, recob::Hit, recob::TrackHitMeta>>();
 
     auto trk2sp = std::make_unique<art::Assns<recob::Track, recob::SpacePoint>>();
     auto trk2t0 = std::make_unique<art::Assns<recob::Track, anab::T0>>();
     auto trk2ct = std::make_unique<art::Assns<recob::Track, anab::CosmicTag>>();
 
     auto sp2hit = std::make_unique<art::Assns<recob::SpacePoint, recob::Hit>>();
     auto vtx2trk = std::make_unique<
       art::Assns<recob::Vertex,
                  recob::Track>>(); // one or more tracks (particles) start in the vertex
     auto trk2kink =
       std::make_unique<art::Assns<recob::Track, recob::Vertex>>(); // one or more kinks on the track
 
     auto pfps = std::make_unique<std::vector<recob::PFParticle>>();
 
     auto pfp2clu = std::make_unique<art::Assns<recob::PFParticle, recob::Cluster>>();
     auto pfp2vtx = std::make_unique<art::Assns<recob::PFParticle, recob::Vertex>>();
     auto pfp2trk = std::make_unique<art::Assns<recob::PFParticle, recob::Track>>();
 
     // --------------------- Wires & Hits -----------------------------
     auto wireHandle = evt.getValidHandle<std::vector<recob::Wire>>(fWireModuleLabel);
     auto allHitListHandle = evt.getValidHandle<std::vector<recob::Hit>>(fHitModuleLabel);
     std::vector<art::Ptr<recob::Hit>> allhitlist;
     art::fill_ptr_vector(allhitlist, allHitListHandle);
 
     // -------------- PMA Tracker for this event ----------------------
     auto pmalgTracker = pma::PMAlgTracker(allhitlist,
                                           *wireHandle,
                                           fPmaConfig,
                                           fPmaTrackerConfig,
                                           fPmaVtxConfig,
                                           fPmaStitchConfig,
                                           fPmaTaggingConfig,
                                           fAdcInPassingPoints,
                                           fAdcInRejectedPoints);
 
     size_t mvaLength = 0;
     if (fEmModuleLabel != "") // ----------- Exclude EM parts ---------
     {
       auto cluListHandle = evt.getValidHandle<std::vector<recob::Cluster>>(fCluModuleLabel);
       auto splitCluHandle = evt.getValidHandle<std::vector<recob::Cluster>>(fEmModuleLabel);
 
       art::FindManyP<recob::Hit> hitsFromClusters(cluListHandle, evt, fCluModuleLabel);
       art::FindManyP<recob::Hit> hitsFromEmParts(splitCluHandle, evt, fEmModuleLabel);
       pmalgTracker.init(hitsFromClusters, hitsFromEmParts);
     }
     else if (fPmaTrackerConfig.TrackLikeThreshold() > 0) // --- CNN EM/trk separation ----
     {
       // try to dig out 4- or 3-output MVA data product
       if (init<4>(evt, pmalgTracker)) { mvaLength = 4; } // e.g.: EM / track / Michel / none
       else if (init<3>(evt, pmalgTracker)) {
         mvaLength = 3;
       } // e.g.: EM / track / none
       else if (init<2>(evt, pmalgTracker)) {
         mvaLength = 2;
       } // just EM / track (LArIAT starts with this style)
       else {
         throw cet::exception("PMAlgTrackMaker") << "No EM/track MVA data products." << std::endl;
       }
     }
     else // ------------------------ Use ALL clusters -----------------
     {
       auto cluListHandle = evt.getValidHandle<std::vector<recob::Cluster>>(fCluModuleLabel);
       art::FindManyP<recob::Hit> hitsFromClusters(cluListHandle, evt, fCluModuleLabel);
       pmalgTracker.init(hitsFromClusters);
     }
 
     // ------------------ Do the job here: ----------------------------
     auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
     auto const detProp =
       art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataFor(evt, clockData);
     int retCode = pmalgTracker.build(clockData, detProp);
     // ----------------------------------------------------------------
     switch (retCode) {
     case -2: mf::LogError("Summary") << "problem"; break;
     case -1: mf::LogWarning("Summary") << "no input"; break;
     case 0: mf::LogVerbatim("Summary") << "no tracks done"; break;
     default:
       if (retCode < 0)
         mf::LogVerbatim("Summary") << "unknown result";
       else if (retCode == 1)
         mf::LogVerbatim("Summary") << retCode << " track ready";
       else
         mf::LogVerbatim("Summary") << retCode << " tracks ready";
       break;
     }
 
     // ---------- Translate output to data products: ------------------
     auto const& result = pmalgTracker.result();
     if (!result.empty()) // ok, there is something to save
     {
       size_t spStart = 0, spEnd = 0;
       double sp_pos[3], sp_err[6];
       for (size_t i = 0; i < 3; ++i)
         sp_pos[i] = 0.0;
       for (size_t i = 0; i < 6; ++i)
         sp_err[i] = 1.0;
 
       auto const make_pfpptr = art::PtrMaker<recob::PFParticle>(evt);
       auto const make_trkptr = art::PtrMaker<recob::Track>(evt); // PtrMaker Step #1
       auto const make_vtxptr = art::PtrMaker<recob::Vertex>(evt);
       auto const make_kinkptr = art::PtrMaker<recob::Vertex>(evt, kKinksName);
       auto const make_t0ptr = art::PtrMaker<anab::T0>(evt);
       auto const make_ctptr = art::PtrMaker<anab::CosmicTag>(evt);
 
       tracks->reserve(result.size());
       for (size_t trkIndex = 0; trkIndex < result.size(); ++trkIndex) {
         pma::Track3D* trk = result[trkIndex].Track();
 
         trk->SelectHits(); // just in case, set all to enabled
         unsigned int itpc = trk->FrontTPC(), icryo = trk->FrontCryo();
         pma::dedx_map dedx_tmp;
         if (fGeom->TPC(itpc, icryo).HasPlane(geo::kU)) {
           trk->CompleteMissingWires(detProp, geo::kU);
           trk->GetRawdEdxSequence(dedx_tmp, geo::kU, 1);
         }
         if (fGeom->TPC(itpc, icryo).HasPlane(geo::kV)) {
           trk->CompleteMissingWires(detProp, geo::kV);
           trk->GetRawdEdxSequence(dedx_tmp, geo::kV, 1);
         }
         if (fGeom->TPC(itpc, icryo).HasPlane(geo::kX)) {
           trk->CompleteMissingWires(detProp, geo::kX);
           trk->GetRawdEdxSequence(dedx_tmp, geo::kX, 1);
         }
         if (fGeom->TPC(itpc, icryo).HasPlane(geo::kY)) {
           trk->CompleteMissingWires(detProp, geo::kY);
           trk->GetRawdEdxSequence(dedx_tmp, geo::kY, 1);
         }
         if (fGeom->TPC(itpc, icryo).HasPlane(geo::kZ)) {
           trk->CompleteMissingWires(detProp, geo::kZ);
           trk->GetRawdEdxSequence(dedx_tmp, geo::kZ, 1);
         }
 
         //gc: make sure no tracks are created with less than 2 points
         if (trk->size() < 2) continue;
 
         int pdg = 0;
         if (mvaLength == 4)
           pdg = getPdgFromCnnOnHits<4>(evt, *(result[trkIndex].Track()));
         else if (mvaLength == 3)
           pdg = getPdgFromCnnOnHits<3>(evt, *(result[trkIndex].Track()));
         else if (mvaLength == 2)
           pdg = getPdgFromCnnOnHits<2>(evt, *(result[trkIndex].Track()));
         //else mf::LogInfo("PMAlgTrackMaker") << "Not using PID from CNN.";
 
         tracks->push_back(pma::convertFrom(*trk, trkIndex, pdg));
 
         auto const trkPtr = make_trkptr(tracks->size() - 1); // PtrMaker Step #2
 
         if (trk->HasT0()) {
           // TriggBits=3 means from 3d reco (0,1,2 mean something else)
           t0s->push_back(anab::T0(trk->GetT0(), 0, 3, tracks->back().ID()));
 
           auto const t0Ptr = make_t0ptr(t0s->size() - 1); // PtrMaker Step #3
           trk2t0->addSingle(trkPtr, t0Ptr);
         }
 
         // Check if this is a cosmic ray and create an association if it is.
         if (trk->HasTagFlag(pma::Track3D::kCosmic)) {
           // Get the track end points
           std::vector<float> trkEnd0;
           std::vector<float> trkEnd1;
           // Get the drift direction, but don't care about the sign
           // Also need to subtract 1 due to the definition.
           int driftDir =
             abs(fGeom->TPC(trk->FrontTPC(), trk->FrontCryo()).DetectDriftDirection()) - 1;
 
           for (int i = 0; i < 3; ++i) {
             // Get the drift direction and apply the opposite of the drift shift in order to
             // give the CosmicTag the drift coordinate assuming T0 = T_beam as it requests.
             double shift = 0.0;
             if (i == driftDir) { shift = trk->Nodes()[0]->GetDriftShift(); }
             trkEnd0.push_back(trk->Nodes()[0]->Point3D()[i] - shift);
             trkEnd1.push_back(trk->Nodes()[trk->Nodes().size() - 1]->Point3D()[i] - shift);
           }
           // Make the tag object. For now, let's say this is very likely a cosmic (3rd argument = 1).
           // Set the type of cosmic to the value saved in pma::Track.
           auto tags = getCosmicTag(trk->GetTag());
           for (const auto t : tags) {
             cosmicTags->emplace_back(trkEnd0, trkEnd1, 1, t);
             auto const cosmicPtr = make_ctptr(cosmicTags->size() - 1);
             trk2ct->addSingle(trkPtr, cosmicPtr);
           }
         }
 
         //gc: save associated hits in the same order as trajectory points
         for (size_t h = 0, cnt = 0; h < trk->size(); h++) {
           pma::Hit3D* h3d = (*trk)[h];
           if (!h3d->IsEnabled()) continue;
 
           recob::TrackHitMeta metadata(cnt++, h3d->Dx());
           trk2hit->addSingle(trkPtr, h3d->Hit2DPtr(), metadata);
           trk2hit_oldway->addSingle(
             trkPtr, h3d->Hit2DPtr()); // ****** REMEMBER to remove when FindMany improved ******
         }
 
         art::PtrVector<recob::Hit> sp_hits;
         spStart = allsp->size();
         //rs: so make also associations to space points in the order of trajectory points
         for (size_t h = 0; h < trk->size(); ++h) {
           pma::Hit3D* h3d = (*trk)[h];
           if (!h3d->IsEnabled()) continue;
 
           double hx = h3d->Point3D().X();
           double hy = h3d->Point3D().Y();
           double hz = h3d->Point3D().Z();
 
           if ((h == 0) || (std::fabs(sp_pos[0] - hx) > 1.0e-5) ||
               (std::fabs(sp_pos[1] - hy) > 1.0e-5) || (std::fabs(sp_pos[2] - hz) > 1.0e-5)) {
             if (sp_hits.size()) // hits assigned to the previous sp
             {
               util::CreateAssn(evt, *allsp, sp_hits, *sp2hit);
               sp_hits.clear();
             }
             sp_pos[0] = hx;
             sp_pos[1] = hy;
             sp_pos[2] = hz;
             allsp->push_back(recob::SpacePoint(sp_pos, sp_err, 1.0));
           }
           sp_hits.push_back(h3d->Hit2DPtr());
         }
 
         if (sp_hits.size()) // hits assigned to the last sp
         {
           util::CreateAssn(evt, *allsp, sp_hits, *sp2hit);
         }
         spEnd = allsp->size();
 
         if (spEnd > spStart) util::CreateAssn(evt, *tracks, *allsp, *trk2sp, spStart, spEnd);
       }
 
       auto vsel = pmalgTracker.getVertices(
         fSaveOnlyBranchingVtx);            // vtx pos's with vector of connected track idxs
       auto ksel = pmalgTracker.getKinks(); // pairs of kink position - associated track idx
       std::map<size_t, art::Ptr<recob::Vertex>> frontVtxs; // front vertex ptr for each track index
 
       if (fPmaTrackerConfig.RunVertexing()) // save vertices and vtx-trk assns
       {
         double xyz[3];
         for (auto const& v : vsel) {
           xyz[0] = v.first.X();
           xyz[1] = v.first.Y();
           xyz[2] = v.first.Z();
           mf::LogVerbatim("Summary") << "  vtx:" << xyz[0] << ":" << xyz[1] << ":" << xyz[2]
                                      << "  (" << v.second.size() << " tracks)";
 
           size_t vidx = vtxs->size();
           vtxs->push_back(recob::Vertex(xyz, vidx));
 
           auto const vptr = make_vtxptr(vidx);
           if (!v.second.empty()) {
             for (const auto& vEntry : v.second) {
               size_t tidx = vEntry.first;
               bool isFront = vEntry.second;
 
               if (isFront) frontVtxs[tidx] = vptr; // keep ptr of the front vtx
 
               auto const tptr = make_trkptr(tidx);
               vtx2trk->addSingle(vptr, tptr);
             }
           }
           else
             mf::LogWarning("PMAlgTrackMaker") << "No tracks found at this vertex.";
         }
         mf::LogVerbatim("Summary") << vtxs->size() << " vertices ready";
 
         for (auto const& k : ksel) {
           xyz[0] = k.first.X();
           xyz[1] = k.first.Y();
           xyz[2] = k.first.Z();
           mf::LogVerbatim("Summary") << "  kink:" << xyz[0] << ":" << xyz[1] << ":" << xyz[2];
 
           size_t kidx = kinks->size();
           size_t tidx = k.second; // track idx on which this kink was found
 
           kinks->push_back(
             recob::Vertex(xyz, tidx)); // save index of track (will have color of trk in evd)
 
           auto const tptr = make_trkptr(tidx);
           auto const kptr = make_kinkptr(kidx);
           trk2kink->addSingle(tptr, kptr);
         }
         mf::LogVerbatim("Summary") << ksel.size() << " kinks ready";
       }
 
       if (fSavePmaNodes) {
         double xyz[3];
         for (size_t t = 0; t < result.size(); ++t) {
           auto const& trk = *(result[t].Track());
           for (auto const* node : trk.Nodes()) {
             xyz[0] = node->Point3D().X();
             xyz[1] = node->Point3D().Y();
             xyz[2] = node->Point3D().Z();
             nodes->push_back(recob::Vertex(xyz, t));
           }
         }
       }
 
       for (size_t t = 0; t < result.size(); ++t) {
         size_t parentIdx = recob::PFParticle::kPFParticlePrimary;
         if (result[t].Parent() >= 0) parentIdx = (size_t)result[t].Parent();
 
         std::vector<size_t> daughterIdxs;
         for (size_t idx : result[t].Daughters()) {
           daughterIdxs.push_back(idx);
         }
 
         size_t pfpidx = pfps->size();
         pfps->emplace_back((*tracks)[t].ParticleId(), pfpidx, parentIdx, daughterIdxs);
 
         auto const pfpptr = make_pfpptr(pfpidx);
         auto const tptr = make_trkptr(t);
         pfp2trk->addSingle(pfpptr, tptr);
 
         // add assns to FRONT vertex of each particle
         if (fPmaTrackerConfig.RunVertexing()) {
           art::Ptr<recob::Vertex> vptr = frontVtxs[t];
           if (!vptr.isNull())
             pfp2vtx->addSingle(pfpptr, vptr);
           else
             mf::LogWarning("PMAlgTrackMaker") << "Front vertex for PFParticle is missing.";
         }
       }
       mf::LogVerbatim("Summary") << pfps->size()
                                  << " PFParticles created for reconstructed tracks.";
       mf::LogVerbatim("Summary") << "Adding " << result.parents().size() << " primary PFParticles.";
       for (size_t t = 0; t < result.parents().size(); ++t) {
         std::vector<size_t> daughterIdxs;
         for (size_t idx : result.parents()[t].Daughters()) {
           daughterIdxs.push_back(idx);
         }
 
         size_t pfpidx = pfps->size();
         size_t parentIdx = recob::PFParticle::kPFParticlePrimary;
         pfps->emplace_back(0, pfpidx, parentIdx, daughterIdxs);
 
         // add assns to END vertex of primary
         if (fPmaTrackerConfig.RunVertexing() && !daughterIdxs.empty()) {
           auto const pfpptr = make_pfpptr(pfpidx);
           art::Ptr<recob::Vertex> vptr =
             frontVtxs[daughterIdxs.front()]; // same vertex for all daughters
           if (!vptr.isNull())
             pfp2vtx->addSingle(pfpptr, vptr);
           else
             mf::LogWarning("PMAlgTrackMaker") << "Front vertex for PFParticle is missing.";
         }
       }
       mf::LogVerbatim("Summary") << pfps->size() << " PFParticles created in total.";
     }
 
     // for (const auto & ct : *cosmicTags) { std::cout << "Cosmic tag: " << ct << std::endl; }
 
     evt.put(std::move(tracks));
     evt.put(std::move(allsp));
     evt.put(std::move(vtxs));
     evt.put(std::move(kinks), kKinksName);
     evt.put(std::move(nodes), kNodesName);
     evt.put(std::move(t0s));
     evt.put(std::move(cosmicTags));
 
     evt.put(std::move(trk2hit_oldway)); // ****** REMEMBER to remove when FindMany improved ******
     evt.put(std::move(trk2hit));
     evt.put(std::move(trk2sp));
     evt.put(std::move(trk2t0));
     evt.put(std::move(trk2ct));
 
     evt.put(std::move(sp2hit));
     evt.put(std::move(vtx2trk));
     evt.put(std::move(trk2kink), kKinksName);
 
     evt.put(std::move(pfps));
     evt.put(std::move(pfp2clu));
     evt.put(std::move(pfp2vtx));
     evt.put(std::move(pfp2trk));
   }

Member Data Documentation

std::vector<TH1F*> trkf::PMAlgTrackMaker::fAdcInPassingPoints

private

Definition at line 160 of file PMAlgTrackMaker_module.cc.

std::vector<TH1F*> trkf::PMAlgTrackMaker::fAdcInRejectedPoints

private

Definition at line 160 of file PMAlgTrackMaker_module.cc.

art::InputTag trkf::PMAlgTrackMaker::fCluModuleLabel

private

Definition at line 140 of file PMAlgTrackMaker_module.cc.

art::InputTag trkf::PMAlgTrackMaker::fEmModuleLabel

private

Definition at line 141 of file PMAlgTrackMaker_module.cc.

geo::GeometryCore const* trkf::PMAlgTrackMaker::fGeom

private

Definition at line 157 of file PMAlgTrackMaker_module.cc.

art::InputTag trkf::PMAlgTrackMaker::fHitModuleLabel

private

Definition at line 138 of file PMAlgTrackMaker_module.cc.

pma::ProjectionMatchingAlg::Config trkf::PMAlgTrackMaker::fPmaConfig

private

Definition at line 143 of file PMAlgTrackMaker_module.cc.

pma::PMAlgStitching::Config trkf::PMAlgTrackMaker::fPmaStitchConfig

private

Definition at line 147 of file PMAlgTrackMaker_module.cc.

pma::PMAlgCosmicTagger::Config trkf::PMAlgTrackMaker::fPmaTaggingConfig

private

Definition at line 145 of file PMAlgTrackMaker_module.cc.

pma::PMAlgTracker::Config trkf::PMAlgTrackMaker::fPmaTrackerConfig

private

Definition at line 144 of file PMAlgTrackMaker_module.cc.

pma::PMAlgVertexing::Config trkf::PMAlgTrackMaker::fPmaVtxConfig

private

Definition at line 146 of file PMAlgTrackMaker_module.cc.

bool trkf::PMAlgTrackMaker::fSaveOnlyBranchingVtx

private

Definition at line 149 of file PMAlgTrackMaker_module.cc.

bool trkf::PMAlgTrackMaker::fSavePmaNodes

private

Definition at line 150 of file PMAlgTrackMaker_module.cc.

art::InputTag trkf::PMAlgTrackMaker::fWireModuleLabel

private

Definition at line 139 of file PMAlgTrackMaker_module.cc.

const std::string trkf::PMAlgTrackMaker::kKinksName = "kink"

staticprivate

Definition at line 153 of file PMAlgTrackMaker_module.cc.

const std::string trkf::PMAlgTrackMaker::kNodesName = "node"

staticprivate

Definition at line 154 of file PMAlgTrackMaker_module.cc.

The documentation for this class was generated from the following file:

larreco/larreco/TrackFinder/PMAlgTrackMaker_module.cc

Private Attributes
art::InputTag	fHitModuleLabel

art::InputTag	fWireModuleLabel

art::InputTag	fCluModuleLabel

art::InputTag	fEmModuleLabel

pma::ProjectionMatchingAlg::Config	fPmaConfig

pma::PMAlgTracker::Config	fPmaTrackerConfig

pma::PMAlgCosmicTagger::Config	fPmaTaggingConfig

pma::PMAlgVertexing::Config	fPmaVtxConfig

pma::PMAlgStitching::Config	fPmaStitchConfig

bool	fSaveOnlyBranchingVtx

bool	fSavePmaNodes

geo::GeometryCore const *	fGeom

std::vector< TH1F * >	fAdcInPassingPoints

std::vector< TH1F * >	fAdcInRejectedPoints

Classes

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation