Inheritance diagram for trkf::CosmicTracker:

Public Types
using	ModuleType = EDProducer

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

Public Member Functions
	CosmicTracker (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 &evt)

Private Attributes
cluster::ClusterMatchTQ	fClusterMatch

trkf::CosmicTrackerAlg	fCTAlg

std::string	fClusterModuleLabel
	label for input cluster collection More...

std::string	fSortDir
	sort space points More...

bool	fStitchTracks
	Stitch tracks from different TPCs. More...

double	fAngCut
	Angle cut for track merging. More...

bool	fTrajOnly
	Only use trajectory points from TrackTrajectoryAlg for debugging. More...

Detailed Description

Definition at line 200 of file CosmicTracker_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::CosmicTracker::CosmicTracker ( fhicl::ParameterSet const & pset )

explicit

Definition at line 226 of file CosmicTracker_module.cc.

References fAngCut, fClusterMatch, fClusterModuleLabel, fCTAlg, fSortDir, fStitchTracks, and fTrajOnly.

     : EDProducer{pset}
     , fClusterMatch(pset.get<fhicl::ParameterSet>("ClusterMatch"))
     , fCTAlg(pset.get<fhicl::ParameterSet>("CTAlg"))
   {
     fClusterModuleLabel = pset.get<std::string>("ClusterModuleLabel");
     fSortDir = pset.get<std::string>("SortDirection", "+z");
     fStitchTracks = pset.get<bool>("StitchTracks");
     fAngCut = pset.get<double>("AngCut");
     fTrajOnly = pset.get<bool>("TrajOnly");
 
     produces<std::vector<recob::Track>>();
     produces<std::vector<recob::SpacePoint>>();
     produces<art::Assns<recob::Track, recob::Cluster>>();
     produces<art::Assns<recob::Track, recob::SpacePoint>>();
     produces<art::Assns<recob::SpacePoint, recob::Hit>>();
     produces<art::Assns<recob::Track, recob::Hit>>();
   }

Member Function Documentation

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 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 art::Modifier::fillProductDescriptions ( )

inherited

Definition at line 10 of file Modifier.cc.

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

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

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

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

privatevirtual

Implements art::EDProducer.

Definition at line 246 of file CosmicTracker_module.cc.

References util::begin(), recob::tracking::convertCollToPoint(), recob::tracking::convertCollToVector(), util::CreateAssn(), DEFINE_ART_MODULE, dir, trkPoint::dir, util::end(), fAngCut, fClusterMatch, fClusterModuleLabel, fCTAlg, art::fill_ptr_vector(), fSortDir, fStitchTracks, fTrajOnly, art::ProductRetriever::getByLabel(), trkPoint::hit, hits(), util::kBogusD, cluster::ClusterMatchTQ::MatchedClusters(), MatchTrack(), trkPoint::pos, art::PtrVector< T >::push_back(), art::Event::put(), sp_sort_x0(), sp_sort_x1(), sp_sort_y0(), sp_sort_y1(), sp_sort_z0(), sp_sort_z1(), spt_sort_x0(), spt_sort_x1(), spt_sort_y0(), spt_sort_y1(), spt_sort_z0(), spt_sort_z1(), trkf::CosmicTrackerAlg::SPTReco(), tmp, trkf::CosmicTrackerAlg::trajHit, trkf::CosmicTrackerAlg::trajPos, trkf::CosmicTrackerAlg::trkDir, and trkf::CosmicTrackerAlg::trkPos.

   {
 
     // get services
     art::ServiceHandle<geo::Geometry const> geom;
 
     std::unique_ptr<std::vector<recob::Track>> tcol(new std::vector<recob::Track>);
     std::unique_ptr<std::vector<recob::SpacePoint>> spcol(new std::vector<recob::SpacePoint>);
     std::unique_ptr<art::Assns<recob::Track, recob::SpacePoint>> tspassn(
       new art::Assns<recob::Track, recob::SpacePoint>);
     std::unique_ptr<art::Assns<recob::Track, recob::Cluster>> tcassn(
       new art::Assns<recob::Track, recob::Cluster>);
     std::unique_ptr<art::Assns<recob::Track, recob::Hit>> thassn(
       new art::Assns<recob::Track, recob::Hit>);
     std::unique_ptr<art::Assns<recob::SpacePoint, recob::Hit>> shassn(
       new art::Assns<recob::SpacePoint, recob::Hit>);
 
     //double timetick = detprop->SamplingRate()*1e-3;    //time sample in us
     //double presamplings = detprop->TriggerOffset(); // presamplings in ticks
     //double plane_pitch = geom->PlanePitch(0,1);   //wire plane pitch in cm
     //double wire_pitch = geom->WirePitch();    //wire pitch in cm
     //double Efield_drift = larprop->Efield(0);  // Electric Field in the drift region in kV/cm
     //double Temperature = detprop->Temperature();  // LAr Temperature in K
 
     //double driftvelocity = larprop->DriftVelocity(Efield_drift,Temperature);    //drift velocity in the drift region (cm/us)
     //double timepitch = driftvelocity*timetick;                         //time sample (cm)
 
     // get input Cluster object(s).
     art::Handle<std::vector<recob::Cluster>> clusterListHandle;
     std::vector<art::Ptr<recob::Cluster>> clusterlist;
     if (evt.getByLabel(fClusterModuleLabel, clusterListHandle))
       art::fill_ptr_vector(clusterlist, clusterListHandle);
 
     art::FindManyP<recob::Hit> fm(clusterListHandle, evt, fClusterModuleLabel);
 
     // find matched clusters
     auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
     auto const detProp =
       art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataFor(evt, clockData);
     auto const matchedclusters = fClusterMatch.MatchedClusters(detProp, clusterlist, fm);
 
     // get track space points
     std::vector<std::vector<trkPoint>> trkpts(matchedclusters.size());
     for (size_t itrk = 0; itrk < matchedclusters.size(); ++itrk) { //loop over tracks
 
       std::vector<art::Ptr<recob::Hit>> hitlist;
       for (size_t iclu = 0; iclu < matchedclusters[itrk].size(); ++iclu) { //loop over clusters
 
         std::vector<art::Ptr<recob::Hit>> hits = fm.at(matchedclusters[itrk][iclu]);
         for (size_t ihit = 0; ihit < hits.size(); ++ihit) {
           hitlist.push_back(hits[ihit]);
         }
       }
       // reconstruct space points and directions
       fCTAlg.SPTReco(clockData, detProp, hitlist);
       if (!fTrajOnly) {
         if (!fCTAlg.trkPos.size()) continue;
         for (size_t i = 0; i < hitlist.size(); ++i) {
           trkPoint trkpt;
           trkpt.pos = fCTAlg.trkPos[i];
           trkpt.dir = fCTAlg.trkDir[i];
           trkpt.hit = hitlist[i];
           trkpts[itrk].push_back(trkpt);
         }
         if (fSortDir == "+x") std::sort(trkpts[itrk].begin(), trkpts[itrk].end(), sp_sort_x0);
         if (fSortDir == "-x") std::sort(trkpts[itrk].begin(), trkpts[itrk].end(), sp_sort_x1);
         if (fSortDir == "+y") std::sort(trkpts[itrk].begin(), trkpts[itrk].end(), sp_sort_y0);
         if (fSortDir == "-y") std::sort(trkpts[itrk].begin(), trkpts[itrk].end(), sp_sort_y1);
         if (fSortDir == "+z") std::sort(trkpts[itrk].begin(), trkpts[itrk].end(), sp_sort_z0);
         if (fSortDir == "-z") std::sort(trkpts[itrk].begin(), trkpts[itrk].end(), sp_sort_z1);
       }
 
       if (fTrajOnly) { //debug only
         if (!fCTAlg.trajPos.size()) continue;
         size_t spStart = spcol->size();
         std::vector<recob::SpacePoint> spacepoints;
         for (size_t ipt = 0; ipt < fCTAlg.trajPos.size(); ++ipt) {
           art::PtrVector<recob::Hit> sp_hits;
           double hitcoord[3];
           hitcoord[0] = fCTAlg.trajPos[ipt].X();
           hitcoord[1] = fCTAlg.trajPos[ipt].Y();
           hitcoord[2] = fCTAlg.trajPos[ipt].Z();
           double err[6] = {util::kBogusD};
           recob::SpacePoint mysp(hitcoord,
                                  err,
                                  util::kBogusD,
                                  spStart + spacepoints.size()); //3d point at end of track
           spacepoints.push_back(mysp);
           spcol->push_back(mysp);
           util::CreateAssn(evt, *spcol, fCTAlg.trajHit[ipt], *shassn);
         } // ihit
         size_t spEnd = spcol->size();
         if (fSortDir == "+x") {
           std::sort(spacepoints.begin(), spacepoints.end(), spt_sort_x0);
           std::sort(spcol->begin() + spStart, spcol->begin() + spEnd, spt_sort_x0);
         }
         if (fSortDir == "-x") {
           std::sort(spacepoints.begin(), spacepoints.end(), spt_sort_x1);
           std::sort(spcol->begin() + spStart, spcol->begin() + spEnd, spt_sort_x1);
         }
         if (fSortDir == "+y") {
           std::sort(spacepoints.begin(), spacepoints.end(), spt_sort_y0);
           std::sort(spcol->begin() + spStart, spcol->begin() + spEnd, spt_sort_y0);
         }
         if (fSortDir == "-y") {
           std::sort(spacepoints.begin(), spacepoints.end(), spt_sort_y1);
           std::sort(spcol->begin() + spStart, spcol->begin() + spEnd, spt_sort_y1);
         }
         if (fSortDir == "+z") {
           std::sort(spacepoints.begin(), spacepoints.end(), spt_sort_z0);
           std::sort(spcol->begin() + spStart, spcol->begin() + spEnd, spt_sort_z0);
         }
         if (fSortDir == "-z") {
           std::sort(spacepoints.begin(), spacepoints.end(), spt_sort_z1);
           std::sort(spcol->begin() + spStart, spcol->begin() + spEnd, spt_sort_z1);
         }
 
         if (spacepoints.size() > 0) {
 
           // make a vector of the trajectory points along the track
           std::vector<TVector3> xyz(spacepoints.size());
           for (size_t s = 0; s < spacepoints.size(); ++s) {
             xyz[s] = TVector3(spacepoints[s].XYZ());
           }
           //Calculate track direction cosines
           TVector3 startpointVec, endpointVec, DirCos;
           startpointVec = xyz[0];
           endpointVec = xyz.back();
           DirCos = endpointVec - startpointVec;
           //SetMag casues a crash if the magnitude of the vector is zero
           try {
             DirCos.SetMag(1.0); //normalize vector
           }
           catch (...) {
             std::cout << "The Spacepoint is infinitely small" << std::endl;
             continue;
           }
           std::vector<TVector3> dircos(spacepoints.size(), DirCos);
 
           tcol->push_back(
             recob::Track(recob::TrackTrajectory(recob::tracking::convertCollToPoint(xyz),
                                                 recob::tracking::convertCollToVector(dircos),
                                                 recob::Track::Flags_t(xyz.size()),
                                                 false),
                          0,
                          -1.,
                          0,
                          recob::tracking::SMatrixSym55(),
                          recob::tracking::SMatrixSym55(),
                          tcol->size()));
 
           // make associations between the track and space points
           util::CreateAssn(evt, *tcol, *spcol, *tspassn, spStart, spEnd);
 
           // and the hits and track
           std::vector<art::Ptr<recob::Hit>> trkhits;
           for (size_t ihit = 0; ihit < hitlist.size(); ++ihit) {
             trkhits.push_back(hitlist[ihit]);
           }
           util::CreateAssn(evt, *tcol, trkhits, *thassn);
         }
       }
     } //itrk
 
     // by default creates a spacepoint and direction for each hit
     if (!fTrajOnly) {
       std::vector<std::vector<unsigned int>> trkidx;
       //stitch tracks from different TPCs
       if (fStitchTracks) {
         for (size_t itrk1 = 0; itrk1 < trkpts.size(); ++itrk1) {
           for (size_t itrk2 = itrk1 + 1; itrk2 < trkpts.size(); ++itrk2) {
             if (MatchTrack(trkpts[itrk1], trkpts[itrk2], fAngCut)) {
               int found1 = -1;
               int found2 = -1;
               for (size_t i = 0; i < trkidx.size(); ++i) {
                 for (size_t j = 0; j < trkidx[i].size(); ++j) {
                   if (trkidx[i][j] == itrk1) found1 = i;
                   if (trkidx[i][j] == itrk2) found2 = i;
                 }
               }
               if (found1 == -1 && found2 == -1) {
                 std::vector<unsigned int> tmp;
                 tmp.push_back(itrk1);
                 tmp.push_back(itrk2);
                 trkidx.push_back(tmp);
               }
               else if (found1 == -1 && found2 != -1) {
                 trkidx[found2].push_back(itrk1);
               }
               else if (found1 != -1 && found2 == -1) {
                 trkidx[found1].push_back(itrk2);
               }
               else if (found1 != found2) { //merge two vectors
                 trkidx[found1].insert(
                   trkidx[found1].end(), trkidx[found2].begin(), trkidx[found2].end());
                 trkidx.erase(trkidx.begin() + found2);
               }
             } //found match
           }   //itrk2
         }     //itrk1
         for (size_t itrk = 0; itrk < trkpts.size(); ++itrk) {
           bool found = false;
           for (size_t i = 0; i < trkidx.size(); ++i) {
             for (size_t j = 0; j < trkidx[i].size(); ++j) {
               if (trkidx[i][j] == itrk) found = true;
             }
           }
           if (!found) {
             std::vector<unsigned int> tmp;
             tmp.push_back(itrk);
             trkidx.push_back(tmp);
           }
         }
       } //stitch
       else {
         trkidx.resize(trkpts.size());
         for (size_t i = 0; i < trkpts.size(); ++i) {
           trkidx[i].push_back(i);
         }
       }
 
       //make recob::track and associations
       for (size_t i = 0; i < trkidx.size(); ++i) {
         //all track points
         std::vector<trkPoint> finaltrkpts;
         //all the clusters associated with the current track
         std::vector<art::Ptr<recob::Cluster>> clustersPerTrack;
         //all hits
         std::vector<art::Ptr<recob::Hit>> hitlist;
         for (size_t j = 0; j < trkidx[i].size(); ++j) {
           for (size_t k = 0; k < trkpts[trkidx[i][j]].size(); ++k) {
             finaltrkpts.push_back(trkpts[trkidx[i][j]][k]);
             hitlist.push_back(trkpts[trkidx[i][j]][k].hit);
           } //k
           for (size_t iclu = 0; iclu < matchedclusters[trkidx[i][j]].size(); ++iclu) {
             art::Ptr<recob::Cluster> cluster(clusterListHandle,
                                              matchedclusters[trkidx[i][j]][iclu]);
             clustersPerTrack.push_back(cluster);
           }
 
         } //j
         if (fStitchTracks) {
           if (fSortDir == "+x") std::sort(finaltrkpts.begin(), finaltrkpts.end(), sp_sort_x0);
           if (fSortDir == "-x") std::sort(finaltrkpts.begin(), finaltrkpts.end(), sp_sort_x1);
           if (fSortDir == "+y") std::sort(finaltrkpts.begin(), finaltrkpts.end(), sp_sort_y0);
           if (fSortDir == "-y") std::sort(finaltrkpts.begin(), finaltrkpts.end(), sp_sort_y1);
           if (fSortDir == "+z") std::sort(finaltrkpts.begin(), finaltrkpts.end(), sp_sort_z0);
           if (fSortDir == "-z") std::sort(finaltrkpts.begin(), finaltrkpts.end(), sp_sort_z1);
         }
         size_t spStart = spcol->size();
         std::vector<recob::SpacePoint> spacepoints;
         for (size_t ipt = 0; ipt < finaltrkpts.size(); ++ipt) {
           art::PtrVector<recob::Hit> sp_hits;
           sp_hits.push_back(finaltrkpts[ipt].hit);
           double hitcoord[3];
           hitcoord[0] = finaltrkpts[ipt].pos.X();
           hitcoord[1] = finaltrkpts[ipt].pos.Y();
           hitcoord[2] = finaltrkpts[ipt].pos.Z();
           double err[6] = {util::kBogusD};
           recob::SpacePoint mysp(hitcoord,
                                  err,
                                  util::kBogusD,
                                  spStart + spacepoints.size()); //3d point at end of track
           spacepoints.push_back(mysp);
           spcol->push_back(mysp);
           util::CreateAssn(evt, *spcol, sp_hits, *shassn);
         } // ipt
         size_t spEnd = spcol->size();
         if (spacepoints.size() > 0) {
           // make a vector of the trajectory points along the track
           std::vector<TVector3> xyz(spacepoints.size());
           std::vector<TVector3> dircos(spacepoints.size());
           for (size_t s = 0; s < spacepoints.size(); ++s) {
             xyz[s] = TVector3(spacepoints[s].XYZ());
             dircos[s] = finaltrkpts[s].dir;
             //flip direction if needed.
             if (spacepoints.size() > 1) {
               if (s == 0) {
                 TVector3 xyz1 = TVector3(spacepoints[s + 1].XYZ());
                 TVector3 dir = xyz1 - xyz[s];
                 if (dir.Angle(dircos[s]) > 0.8 * TMath::Pi()) { dircos[s] = -dircos[s]; }
               }
               else {
                 TVector3 dir = xyz[s] - xyz[s - 1];
                 if (dir.Angle(dircos[s]) > 0.8 * TMath::Pi()) { dircos[s] = -dircos[s]; }
               }
             }
           }
           tcol->push_back(
             recob::Track(recob::TrackTrajectory(recob::tracking::convertCollToPoint(xyz),
                                                 recob::tracking::convertCollToVector(dircos),
                                                 recob::Track::Flags_t(xyz.size()),
                                                 false),
                          0,
                          -1.,
                          0,
                          recob::tracking::SMatrixSym55(),
                          recob::tracking::SMatrixSym55(),
                          tcol->size()));
 
           // make associations between the track and space points
           util::CreateAssn(evt, *tcol, *spcol, *tspassn, spStart, spEnd);
 
           // now the track and clusters
           util::CreateAssn(evt, *tcol, clustersPerTrack, *tcassn);
 
           // and the hits and track
           std::vector<art::Ptr<recob::Hit>> trkhits;
           for (size_t ihit = 0; ihit < hitlist.size(); ++ihit) {
             trkhits.push_back(hitlist[ihit]);
           }
           util::CreateAssn(evt, *tcol, trkhits, *thassn);
         }
 
       } //i
     }
     mf::LogVerbatim("Summary") << std::setfill('-') << std::setw(175) << "-" << std::setfill(' ');
     mf::LogVerbatim("Summary") << "CosmicTracker Summary:";
     for (unsigned int i = 0; i < tcol->size(); ++i)
       mf::LogVerbatim("Summary") << tcol->at(i);
     mf::LogVerbatim("Summary") << "CosmicTracker Summary End:";
 
     evt.put(std::move(tcol));
     evt.put(std::move(spcol));
     evt.put(std::move(tspassn));
     evt.put(std::move(tcassn));
     evt.put(std::move(thassn));
     evt.put(std::move(shassn));
 
     return;
   }

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