LArSoft: pma::Track3D Class Reference

std::vector< pma::Hit3D * > fHits

Definition: PmaTrack3D.h:385

unsigned int pma::Track3D::BackCryo ( ) const

inline

Definition at line 122 of file PmaTrack3D.h.

Referenced by pma::ProjectionMatchingAlg::guideEndpoints(), pma::ProjectionMatchingAlg::mergeTracks(), pma::PMAlgStitching::StitchTracks(), and ems::EMShower3D::Validate().

122 { return fNodes.back()->Cryo(); }

std::vector< pma::Node3D * > fNodes

Definition: PmaTrack3D.h:396

unsigned int pma::Track3D::BackTPC ( ) const

inline

Definition at line 121 of file PmaTrack3D.h.

Referenced by pma::ProjectionMatchingAlg::guideEndpoints(), pma::ProjectionMatchingAlg::mergeTracks(), pma::PMAlgStitching::StitchTracks(), and ems::EMShower3D::Validate().

121 { return fNodes.back()->TPC(); }

std::vector< pma::Node3D * > fNodes

Definition: PmaTrack3D.h:396

bool pma::Track3D::CanFlip ( ) const

Check if the track can be flipped without breaking any other track.

Definition at line 644 of file PmaTrack3D.cxx.

References CanFlip(), fNodes, n, NextSegment(), pma::Segment3D::Parent(), and pma::SortedObjectBase::Prev().

Referenced by AttachBackToSameTPC(), AttachTo(), AttachToSameTPC(), CanFlip(), pma::TrkCandidateColl::flipTreesByDQdx(), pma::VtxCandidate::JoinTracks(), and Split().

 {
   if (!fNodes.size()) { return false; }
 
   pma::Node3D* n = fNodes.front();
   if (n->Prev()) {
     pma::Segment3D* s = static_cast<pma::Segment3D*>(n->Prev());
     pma::Track3D* t = s->Parent();
     if (t->NextSegment(n)) { return false; } // cannot flip if starts from middle of another track
     else {
       return t->CanFlip();
     } // check root
   }
   else {
     return true;
   }
 }

bool pma::Track3D::CheckEndSegment ( pma::Track3D::ETrackEnd endCode )

private

Definition at line 3177 of file PmaTrack3D.cxx.

References fNodes, fSegments, GetObjFunction(), kBegin, kEnd, MakeProjection(), RebuildSegments(), and SwapVertices().

Referenced by Optimize().

 {
   unsigned int v1, v2;
   switch (endCode) {
   case pma::Track3D::kBegin:
     if (fSegments.front()->IsFrozen()) return false;
     if (fNodes.front()->NextCount() > 1) return false;
     v1 = 0;
     v2 = 1;
     break;
   case pma::Track3D::kEnd:
     if (fSegments.back()->IsFrozen()) return false;
     if (fNodes.back()->NextCount() > 1) return false;
     v1 = fNodes.size() - 1;
     v2 = fNodes.size() - 2;
     break;
   default: return false;
   }
   if (fNodes[v1]->TPC() != fNodes[v2]->TPC()) return false;
 
   double g1, g0 = GetObjFunction();
 
   if (SwapVertices(v1, v2)) RebuildSegments();
   MakeProjection();
   g1 = GetObjFunction();
 
   if (g1 >= g0) {
     if (SwapVertices(v1, v2)) RebuildSegments();
     MakeProjection();
     return false;
   }
   else
     return true;
 }

void pma::Track3D::CleanupTails ( )

Cut out tails with no hits assigned.

Definition at line 2384 of file PmaTrack3D.cxx.

References fNodes, fSegments, MakeProjection(), pma::SortedBranchBase::NextCount(), NextSegment(), pma::Element3D::NHits(), and PrevSegment().

Referenced by pma::PMAlgTracker::reassignHits_1().

 {
   unsigned int nhits = 0;
   while (!nhits && (fNodes.size() > 2) && !fNodes.front()->IsBranching()) {
     pma::Node3D* vtx = fNodes.front();
     nhits = vtx->NHits();
 
     pma::Segment3D* seg = NextSegment(vtx);
     nhits += seg->NHits();
 
     if (!nhits) {
       if (vtx->NextCount() < 2) delete vtx;
       fNodes.erase(fNodes.begin());
 
       delete seg;
       fSegments.erase(fSegments.begin());
 
       MakeProjection();
     }
   }
 
   nhits = 0;
   while (!nhits && (fNodes.size() > 2) && !fNodes.back()->IsBranching()) {
     pma::Node3D* vtx = fNodes.back();
     nhits = vtx->NHits();
 
     pma::Segment3D* seg = PrevSegment(vtx);
     nhits += seg->NHits();
 
     if (!nhits) {
       if (vtx->NextCount() < 1) delete fNodes.back();
       fNodes.pop_back();
 
       delete seg;
       fSegments.pop_back();
 
       MakeProjection();
     }
   }
 }

void pma::Track3D::ClearNodes ( )

private

Definition at line 112 of file PmaTrack3D.cxx.

References fNodes.

Referenced by InitFromHits(), InitFromMiddle(), and InitFromRefPoints().

 {
   for (size_t i = 0; i < fNodes.size(); i++)
     delete fNodes[i];
   fNodes.clear();
 }

size_t pma::Track3D::CompleteMissingWires	(	detinfo::DetectorPropertiesData const &	detProp,
		unsigned int	view
	)

Definition at line 1170 of file PmaTrack3D.cxx.

References util::abs(), pma::Hit3D::Cryo(), d, DriftsOfWireIntersection(), fHits, MakeProjection(), NextHit(), pma::Hit3D::PeakTime(), push_back(), size(), SortHits(), pma::Hit3D::TPC(), pma::Hit3D::View2D(), w, and pma::Hit3D::Wire().

Referenced by trkf::PMAlgTrajFitter::produce(), and trkf::PMAlgTrackMaker::produce().

 {
   int dPrev, dw, w, wx, wPrev, i = NextHit(-1, view);
 
   pma::Hit3D* hitPrev = nullptr;
   pma::Hit3D* hit = nullptr;
 
   std::vector<pma::Hit3D*> missHits;
 
   while (i < (int)size()) {
     hitPrev = hit;
     hit = fHits[i];
 
     if (hit->View2D() == view) {
       w = hit->Wire();
       if (hitPrev) {
         wPrev = hitPrev->Wire();
         dPrev = (int)hitPrev->PeakTime();
         if (abs(w - wPrev) > 1) {
           if (w > wPrev)
             dw = 1;
           else
             dw = -1;
           wx = wPrev + dw;
           int k = 1;
           while (wx != w) {
             int peakTime = 0;
             unsigned int iWire = wx;
             std::vector<float> drifts = DriftsOfWireIntersection(detProp, wx, view);
             if (drifts.size()) {
               peakTime = drifts[0];
               for (size_t d = 1; d < drifts.size(); d++)
                 if (fabs(drifts[d] - dPrev) < fabs(peakTime - dPrev)) peakTime = drifts[d];
             }
             else {
               mf::LogVerbatim("pma::Track3D") << "Track does not intersect with the wire " << wx;
               break;
             }
             pma::Hit3D* hmiss =
               new pma::Hit3D(detProp, iWire, view, hit->TPC(), hit->Cryo(), peakTime, 1.0, 1.0);
             missHits.push_back(hmiss);
             wx += dw;
             k++;
           }
         }
       }
     }
     else
       hit = hitPrev;
 
     i = NextHit(i, view, true);
     while ((i < (int)size()) && (hit->TPC() != fHits[i]->TPC())) {
       hitPrev = hit;
       hit = fHits[i];
       i = NextHit(i, view, true);
     }
   }
 
   if (missHits.size()) {
     for (size_t hi = 0; hi < missHits.size(); hi++) {
       push_back(missHits[hi]);
     }
 
     MakeProjection();
     SortHits();
   }
 
   return missHits.size();
 }

std::vector< unsigned int > pma::Track3D::Cryos ( ) const

Definition at line 466 of file PmaTrack3D.cxx.

References fHits.

Referenced by Initialize(), pma::ProjectionMatchingAlg::validate(), pma::ProjectionMatchingAlg::validate_on_adc(), and pma::ProjectionMatchingAlg::validate_on_adc_test().

 {
   std::vector<unsigned int> cryo_idxs;
   for (auto hit : fHits) {
     unsigned int cryo = hit->Cryo();
 
     bool found = false;
     for (size_t j = 0; j < cryo_idxs.size(); j++)
       if (cryo_idxs[j] == cryo) {
         found = true;
         break;
       }
 
     if (!found) cryo_idxs.push_back(cryo);
   }
   return cryo_idxs;
 }

void pma::Track3D::DeleteSegments ( )

private

Definition at line 2367 of file PmaTrack3D.cxx.

References fSegments.

Referenced by ExtendWith(), and RebuildSegments().

 {
   for (size_t i = 0; i < fSegments.size(); i++)
     delete fSegments[i];
   fSegments.clear();
 }

unsigned int pma::Track3D::DisableSingleViewEnds ( )

Definition at line 2688 of file PmaTrack3D.cxx.

References fHits, fNodes, pma::Element3D::Hit(), index_of(), pma::Hit3D::IsEnabled(), MakeProjection(), NextSegment(), pma::Element3D::NHits(), pma::Element3D::NPoints(), PrevSegment(), RebuildSegments(), pma::Hit3D::SetEnabled(), size(), SortHits(), and pma::Hit3D::View2D().

Referenced by pma::PMAlgTracker::reassignSingleViewEnds_1(), and pma::ProjectionMatchingAlg::twoViewFraction().

 {
   SortHits();
 
   unsigned int nDisabled = 0;
 
   std::array<int, 4> hasHits{{}};
 
   pma::Hit3D* nextHit = nullptr;
   int hitIndex = -1;
 
   bool rebuild = false, stop = false;
   int nViews = 0;
 
   do {
     pma::Node3D* vtx = fNodes.front();
     pma::Segment3D* seg = NextSegment(vtx);
     if (!seg) break;
 
     if (vtx->NPoints() + seg->NPoints() > 0) hasHits[3] = 1;
 
     for (size_t i = 0; i < vtx->NHits(); i++) {
       hitIndex = index_of(&(vtx->Hit(i)));
       if ((hitIndex >= 0) && (hitIndex + 1 < (int)size()))
         nextHit = fHits[hitIndex + 1];
       else
         nextHit = 0;
 
       if (vtx->Hit(i).IsEnabled()) hasHits[vtx->Hit(i).View2D()] = 1;
       if (nextHit && nextHit->IsEnabled()) hasHits[nextHit->View2D()] = 1;
       nViews = hasHits[0] + hasHits[1] + hasHits[2] + hasHits[3];
       if (nViews < 2) {
         if (vtx->Hit(i).IsEnabled()) {
           vtx->Hit(i).SetEnabled(false);
           nDisabled++;
         }
       }
     }
     for (size_t i = 0; i < seg->NHits(); i++) {
       hitIndex = index_of(&(seg->Hit(i)));
       if ((hitIndex >= 0) && (hitIndex + 1 < (int)size()))
         nextHit = fHits[hitIndex + 1];
       else
         nextHit = 0;
 
       if (seg->Hit(i).IsEnabled()) hasHits[seg->Hit(i).View2D()] = 1;
       if (nextHit && nextHit->IsEnabled()) hasHits[nextHit->View2D()] = 1;
       nViews = hasHits[0] + hasHits[1] + hasHits[2] + hasHits[3];
       if (nViews < 2) {
         if (seg->Hit(i).IsEnabled()) {
           seg->Hit(i).SetEnabled(false);
           nDisabled++;
         }
       }
     }
 
     if (fNodes.size() < 3) break;
 
     nViews = hasHits[1] + hasHits[2] + hasHits[3];
     if (hasHits[0] || (nViews > 1))
       stop = true;
     else if (!fNodes.front()->IsBranching()) {
       pma::Node3D* vtx_front = fNodes.front();
       fNodes.erase(fNodes.begin());
       delete vtx_front;
       rebuild = true;
     }
 
   } while (!stop);
 
   stop = false;
   nViews = 0;
   hasHits.fill(0);
 
   do {
     pma::Node3D* vtx = fNodes.back();
     pma::Segment3D* seg = PrevSegment(vtx);
     if (!seg) break;
 
     if (vtx->NPoints() || seg->NPoints()) hasHits[3] = 1;
 
     for (int i = vtx->NHits() - 1; i >= 0; i--) {
       hitIndex = index_of(&(vtx->Hit(i)));
       if ((hitIndex >= 0) && (hitIndex - 1 >= 0))
         nextHit = fHits[hitIndex - 1];
       else
         nextHit = 0;
 
       if (vtx->Hit(i).IsEnabled()) hasHits[vtx->Hit(i).View2D()] = 1;
       if (nextHit && nextHit->IsEnabled()) hasHits[nextHit->View2D()] = 1;
       nViews = hasHits[0] + hasHits[1] + hasHits[2] + hasHits[3];
       if (nViews < 2) {
         if (vtx->Hit(i).IsEnabled()) {
           vtx->Hit(i).SetEnabled(false);
           nDisabled++;
         }
       }
     }
     for (int i = seg->NHits() - 1; i >= 0; i--) {
       hitIndex = index_of(&(seg->Hit(i)));
       if ((hitIndex >= 0) && (hitIndex - 1 >= 0))
         nextHit = fHits[hitIndex - 1];
       else
         nextHit = 0;
 
       if (seg->Hit(i).IsEnabled()) hasHits[seg->Hit(i).View2D()] = 1;
       if (nextHit && nextHit->IsEnabled()) hasHits[nextHit->View2D()] = 1;
       nViews = hasHits[0] + hasHits[1] + hasHits[2] + hasHits[3];
       if (nViews < 2) {
         if (seg->Hit(i).IsEnabled()) {
           seg->Hit(i).SetEnabled(false);
           nDisabled++;
         }
       }
     }
 
     if (fNodes.size() < 3) break;
 
     nViews = hasHits[1] + hasHits[2] + hasHits[3];
     if (hasHits[0] || (nViews > 1))
       stop = true;
     else if (!fNodes.back()->IsBranching()) {
       pma::Node3D* vtx_back = fNodes.back();
       fNodes.pop_back();
       delete vtx_back;
       rebuild = true;
     }
 
   } while (!stop);
 
   if (rebuild) {
     RebuildSegments();
     MakeProjection();
   }
 
   return nDisabled;
 }

double pma::Track3D::Dist2	(	const TVector2 &	p2d,
		unsigned int	view,
		unsigned int	tpc,
		unsigned int	cryo
	)		const

Definition at line 2520 of file PmaTrack3D.cxx.

References larg4::dist(), fNodes, and fSegments.

Referenced by GetNearestTrkInTree(), Split(), TestHitsMse(), pma::ProjectionMatchingAlg::validate(), and pma::ProjectionMatchingAlg::validate_on_adc_test().

 {
   double dist, min_dist = 1.0e12;
 
   int t = (int)tpc, c = (int)cryo;
   auto n0 = fNodes.front();
   if ((n0->TPC() == t) && (n0->Cryo() == c)) {
     dist = n0->GetDistance2To(p2d, view);
     if (dist < min_dist) min_dist = dist;
   }
   auto n1 = fNodes.back();
   if ((n1->TPC() == t) && (n1->Cryo() == c)) {
     dist = n1->GetDistance2To(p2d, view);
     if (dist < min_dist) min_dist = dist;
   }
 
   for (auto s : fSegments)
     if ((s->TPC() == t) && (s->Cryo() == c)) {
       dist = s->GetDistance2To(p2d, view);
       if (dist < min_dist) min_dist = dist;
     }
   return min_dist;
 }

double pma::Track3D::Dist2 ( const TVector3 & p3d ) const

Definition at line 2547 of file PmaTrack3D.cxx.

References fSegments.

 {
   using namespace ranges;
   auto to_distance2 = [&p3d](auto seg) { return seg->GetDistance2To(p3d); };
   return min(fSegments | views::transform(to_distance2));
 }

std::vector< float > pma::Track3D::DriftsOfWireIntersection	(	detinfo::DetectorPropertiesData const &	detProp,
		unsigned int	wire,
		unsigned int	view
	)		const

Definition at line 1138 of file PmaTrack3D.cxx.

References pma::CmToWireDrift(), d, fNodes, X, and Y.

Referenced by CompleteMissingWires().

 {
   std::vector<float> drifts;
   for (size_t i = 0; i < fNodes.size() - 1; i++) {
     int tpc = fNodes[i]->TPC(), cryo = fNodes[i]->Cryo();
     if ((tpc != fNodes[i + 1]->TPC()) || (cryo != fNodes[i + 1]->Cryo())) continue;
 
     TVector2 p0 = pma::CmToWireDrift(detProp,
                                      fNodes[i]->Projection2D(view).X(),
                                      fNodes[i]->Projection2D(view).Y(),
                                      view,
                                      fNodes[i]->TPC(),
                                      fNodes[i]->Cryo());
     TVector2 p1 = pma::CmToWireDrift(detProp,
                                      fNodes[i + 1]->Projection2D(view).X(),
                                      fNodes[i + 1]->Projection2D(view).Y(),
                                      view,
                                      fNodes[i + 1]->TPC(),
                                      fNodes[i + 1]->Cryo());
 
     if ((p0.X() - wire) * (p1.X() - wire) <= 0.0) {
       double frac_w = (wire - p0.X()) / (p1.X() - p0.X());
       double d = p0.Y() + frac_w * (p1.Y() - p0.Y());
       drifts.push_back((float)d);
     }
   }
   return drifts;
 }

bool pma::Track3D::erase ( const art::Ptr< recob::Hit > & hit )

Definition at line 367 of file PmaTrack3D.cxx.

References fHits, and size().

Referenced by RemoveHits().

 {
   for (size_t i = 0; i < size(); i++) {
     if (hit == fHits[i]->fHit) {
       pma::Hit3D* h3d = fHits[i];
       fHits.erase(fHits.begin() + i);
       delete h3d;
       return true;
     }
   }
   return false;
 }

void pma::Track3D::ExtendWith ( pma::Track3D * src )

Extend the track with everything from src, delete the src;.

Definition at line 1711 of file PmaTrack3D.cxx.

References DeleteSegments(), fAssignedPoints, fNodes, fSegments, MakeProjection(), push_back(), release_at(), size(), and SortHits().

 {
   if (src->fNodes.front()->Prev()) {
     throw cet::exception("pma::Track3D")
       << "Cant extend with a track being a daughter of another track." << std::endl;
   }
 
   src->DeleteSegments(); // disconnect from vertices and delete
   for (size_t i = 0; i < src->fNodes.size(); ++i) {
     fNodes.push_back(src->fNodes[i]);
 
     size_t idx = fNodes.size() - 1;
     fSegments.push_back(new pma::Segment3D(this, fNodes[idx - 1], fNodes[idx]));
   }
   src->fNodes.clear(); // just empty the node collection
 
   while (src->size()) {
     push_back(src->release_at(0));
   } // move hits
 
   for (auto p : src->fAssignedPoints) {
     fAssignedPoints.push_back(p);
   } // move 3D reference points
   src->fAssignedPoints.clear();
 
   MakeProjection();
   SortHits();
 
   delete src;
 }

pma::Node3D* pma::Track3D::FirstElement ( ) const

inline

Definition at line 275 of file PmaTrack3D.h.

Referenced by pma::ProjectionMatchingAlg::isContained(), SelectHits(), and pma::PMAlgTracker::validate().

275 { return fNodes.front(); }

std::vector< pma::Node3D * > fNodes

Definition: PmaTrack3D.h:396

bool pma::Track3D::Flip	(	const detinfo::DetectorPropertiesData &	detProp,
		std::vector< pma::Track3D * > &	allTracks
	)

Invert the order of hits and vertices in the track, break other tracks if needed (new tracks are added to the allTracks vector). Returns true if successful or false if any of required track flips was not possible (e.g. resulting track would be composed of hits from a single 2D projection).

Definition at line 527 of file PmaTrack3D.cxx.

References Flip(), fNodes, index_of(), InternalFlip(), n, NextSegment(), pma::Segment3D::Parent(), pma::SortedObjectBase::Prev(), and Split().

Referenced by pma::ProjectionMatchingAlg::alignTracks(), pma::PMAlgTracker::areCoLinear(), AttachBackToSameTPC(), AttachToSameTPC(), pma::ProjectionMatchingAlg::buildSegment(), Flip(), pma::VtxCandidate::JoinTracks(), ems::EMShower3D::Make3DSeg(), ems::EMShower3D::Reoptimize(), pma::TrkCandidateColl::setTreeOriginAtBack(), pma::TrkCandidateColl::setTreeOriginAtFront(), Split(), and pma::PMAlgStitching::StitchTracks().

 {
   if (fNodes.size() < 2) { return true; }
 
   std::vector<pma::Track3D*> toSort;
 
   pma::Node3D* n = fNodes.front();
   if (n->Prev()) {
     pma::Segment3D* s = static_cast<pma::Segment3D*>(n->Prev());
     pma::Track3D* t = s->Parent();
 
     if (t->NextSegment(n)) // starts from middle of another track: need to break that one first
     {
       int idx = t->index_of(n);
       if (idx >= 0) {
         pma::Track3D* u = t->Split(detProp, idx, false); // u is in front of t
         if (u) {
           allTracks.push_back(u);
           if (u->Flip(detProp, allTracks)) {
             InternalFlip(toSort);
             toSort.push_back(this);
           }
           else {
             mf::LogWarning("pma::Track3D")
               << "Flip(): Could not flip after split (but new track is preserved!!).";
             return false;
           }
         }
         else {
           return false;
         } // could not flip/break associated tracks, so give up on this one
       }
       else {
         throw cet::exception("pma::Track3D") << "Node not found." << std::endl;
       }
     }
     else // flip root
     {
       if (t->Flip(detProp, allTracks)) // all ok, so can flip this track
       {
         InternalFlip(toSort);
         toSort.push_back(this);
       }
       else {
         return false;
       } // could not flip/break associated tracks, so give up on this one
     }
   }
   else // simply flip
   {
     InternalFlip(toSort);
     toSort.push_back(this);
   }
 
   for (size_t t = 0; t < toSort.size(); t++) {
     bool sorted = false;
     for (size_t u = 0; u < t; u++)
       if (toSort[u] == toSort[t]) {
         sorted = true;
         break;
       }
     if (!sorted) {
       toSort[t]->MakeProjection();
       toSort[t]->SortHits();
     }
   }
   return true;
 }

void pma::Track3D::Flip ( )

Invert the order of hits and vertices in the track, will fail on configuration that causes breaking another track.

Definition at line 624 of file PmaTrack3D.cxx.

References InternalFlip().

Referenced by AttachTo(), and AutoFlip().

 {
   std::vector<pma::Track3D*> toSort;
   InternalFlip(toSort);
   toSort.push_back(this);
 
   for (size_t t = 0; t < toSort.size(); t++) {
     bool sorted = false;
     for (size_t u = 0; u < t; u++)
       if (toSort[u] == toSort[t]) {
         sorted = true;
         break;
       }
     if (!sorted) {
       toSort[t]->MakeProjection();
       toSort[t]->SortHits();
     }
   }
 }

pma::Hit3D const* pma::Track3D::front ( ) const

inline

Definition at line 87 of file PmaTrack3D.h.

87 { return fHits.front(); }

std::vector< pma::Hit3D * > fHits

Definition: PmaTrack3D.h:385

unsigned int pma::Track3D::FrontCryo ( ) const

inline

Definition at line 119 of file PmaTrack3D.h.

Referenced by pma::ProjectionMatchingAlg::guideEndpoints(), pma::ProjectionMatchingAlg::mergeTracks(), trkf::PMAlgTrajFitter::produce(), trkf::PMAlgTrackMaker::produce(), pma::PMAlgStitching::StitchTracks(), ems::EMShower3D::Validate(), and pma::PMAlgTracker::validate().

119 { return fNodes.front()->Cryo(); }

std::vector< pma::Node3D * > fNodes

Definition: PmaTrack3D.h:396

unsigned int pma::Track3D::FrontTPC ( ) const

inline

Definition at line 118 of file PmaTrack3D.h.

Referenced by pma::ProjectionMatchingAlg::guideEndpoints(), pma::ProjectionMatchingAlg::mergeTracks(), trkf::PMAlgTrajFitter::produce(), trkf::PMAlgTrackMaker::produce(), pma::PMAlgStitching::StitchTracks(), ems::EMShower3D::Validate(), and pma::PMAlgTracker::validate().

118 { return fNodes.front()->TPC(); }

pma::Track3D::fEndSegWeight

std::vector< pma::Node3D * > fNodes

Definition: PmaTrack3D.h:396

bool pma::Track3D::GetBranches	(	std::vector< pma::Track3D const * > &	branches,
		bool	skipFirst = `false`
	)		const

Definition at line 1757 of file PmaTrack3D.cxx.

References fNodes, GetBranches(), n, and pma::Segment3D::Parent().

Referenced by GetBranches(), IsAttachedTo(), and pma::VtxCandidate::JoinTracks().

 {
   for (auto trk : branches)
     if (trk == this) { throw cet::exception("pma::Track3D") << "Track tree has loop."; }
 
   branches.push_back(this);
 
   size_t i0 = 0;
   if (skipFirst) i0 = 1;
 
   for (size_t i = i0; i < fNodes.size(); ++i)
     for (size_t n = 0; n < fNodes[i]->NextCount(); n++) {
       pma::Segment3D* seg = static_cast<pma::Segment3D*>(fNodes[i]->Next(n));
       if (seg && (seg->Parent() != this)) seg->Parent()->GetBranches(branches, true);
     }
 
   return true;
 }

pma::Vector3D pma::Track3D::GetDirection3D ( size_t index ) const

Get trajectory direction at given hit index.

Definition at line 380 of file PmaTrack3D.cxx.

References fHits, fNodes, fSegments, GetNearestElement(), n, pma::Hit3D::Point2D(), pma::Hit3D::TPC(), and pma::Hit3D::View2D().

Referenced by pma::convertFrom().

 {
   pma::Hit3D* h = fHits[index];
 
   for (auto s : fSegments) {
     if (s->HasHit(h)) return s->GetDirection3D();
   }
   for (auto n : fNodes) {
     if (n->HasHit(h)) return n->GetDirection3D();
   }
 
   auto pe = GetNearestElement(h->Point2D(), h->View2D(), h->TPC());
   if (pe) {
     mf::LogWarning("pma::Track3D")
       << "GetDirection3D(): had to update hit assignment to segment/node.";
     pe->AddHit(h);
     return pe->GetDirection3D();
   }
   else {
     throw cet::exception("pma::Track3D") << "GetDirection3D(): direction of a not assigned hit "
                                          << index << " (size: " << fHits.size() << ")" << std::endl;
   }
 }

float pma::Track3D::GetEndSegWeight ( ) const

inlinenoexcept

Definition at line 319 of file PmaTrack3D.h.

319 { return fEndSegWeight; }

float fEndSegWeight

Definition: PmaTrack3D.h:409

unsigned int pma::Track3D::GetMaxHitsPerSeg ( ) const

inlinenoexcept

Definition at line 325 of file PmaTrack3D.h.

325 { return fMaxHitsPerSeg; }

pma::Track3D::fMaxHitsPerSeg

unsigned int fMaxHitsPerSeg

Definition: PmaTrack3D.h:399

double pma::Track3D::GetMse ( unsigned int view = geo::kUnknown ) const

MSE of hits weighted with hit amplidudes and wire plane coefficients.

Definition at line 1798 of file PmaTrack3D.cxx.

References fNodes, fSegments, and n.

Referenced by pma::PMAlgTracker::extendTrack(), pma::PMAlgTracker::matchCluster(), and pma::ProjectionMatchingAlg::ShortenSeg_().

 {
   double sumMse = 0.0;
   unsigned int nEnabledHits = 0;
   for (auto n : fNodes) {
     sumMse += n->SumDist2(view);
     nEnabledHits += n->NEnabledHits(view);
   }
   for (auto s : fSegments) {
     sumMse += s->SumDist2(view);
     nEnabledHits += s->NEnabledHits(view);
   }
 
   if (nEnabledHits)
     return sumMse / nEnabledHits;
   else
     return 0.0;
 }

pma::Element3D * pma::Track3D::GetNearestElement	(	const TVector2 &	p2d,
		unsigned int	view,
		int	tpc = `-1`,
		bool	skipFrontVtx = `false`,
		bool	skipBackVtx = `false`
	)		const

private

Definition at line 2554 of file PmaTrack3D.cxx.

References larg4::dist(), fNodes, and fSegments.

Referenced by GetDirection3D(), MakeProjection(), and ShiftEndsToHits().

 {
   if (fSegments.front()->TPC() < 0) skipFrontVtx = false;
   if (fSegments.back()->TPC() < 0) skipBackVtx = false;
 
   if (skipFrontVtx && skipBackVtx && (fSegments.size() == 1))
     return fSegments.front(); // no need for searching...
 
   size_t v0 = 0, v1 = fNodes.size();
   if (skipFrontVtx) v0 = 1;
   if (skipBackVtx) --v1;
 
   pma::Element3D* pe_min = nullptr;
   auto min_dist = std::numeric_limits<double>::max();
   for (size_t i = v0; i < v1; i++)
     if (fNodes[i]->TPC() == tpc) {
       double dist = fNodes[i]->GetDistance2To(p2d, view);
       if (dist < min_dist) {
         min_dist = dist;
         pe_min = fNodes[i];
       }
     }
   for (auto segment : fSegments)
     if (segment->TPC() == tpc) {
       if (segment->TPC() < 0) continue; // segment between TPC's
 
       double const dist = segment->GetDistance2To(p2d, view);
       if (dist < min_dist) {
         min_dist = dist;
         pe_min = segment;
       }
     }
   if (!pe_min) throw cet::exception("pma::Track3D") << "Nearest element not found." << std::endl;
   return pe_min;
 }

pma::Element3D * pma::Track3D::GetNearestElement ( const TVector3 & p3d ) const

private

Definition at line 2594 of file PmaTrack3D.cxx.

References larg4::dist(), fNodes, fSegments, and pma::Element3D::GetDistance2To().

 {
   pma::Element3D* pe_min = fNodes.front();
   double dist, min_dist = pe_min->GetDistance2To(p3d);
   for (size_t i = 1; i < fNodes.size(); i++) {
     dist = fNodes[i]->GetDistance2To(p3d);
     if (dist < min_dist) {
       min_dist = dist;
       pe_min = fNodes[i];
     }
   }
   for (size_t i = 0; i < fSegments.size(); i++) {
     dist = fSegments[i]->GetDistance2To(p3d);
     if (dist < min_dist) {
       min_dist = dist;
       pe_min = fSegments[i];
     }
   }
   return pe_min;
 }

pma::Track3D * pma::Track3D::GetNearestTrkInTree	(	const TVector3 &	p3d_cm,
		double &	dist,
		bool	skipFirst = `false`
	)

private

Definition at line 2025 of file PmaTrack3D.cxx.

References d, larg4::dist(), Dist2(), fNodes, GetNearestTrkInTree(), pma::SortedBranchBase::Next(), pma::SortedBranchBase::NextCount(), and NextSegment().

Referenced by GetNearestTrkInTree(), and ReassignHitsInTree().

 {
   pma::Node3D* vtx = fNodes.front();
 
   if (skipFirst) {
     if (auto segThis = NextSegment(vtx)) vtx = static_cast<pma::Node3D*>(segThis->Next());
   }
 
   pma::Track3D* result = this;
   dist = sqrt(Dist2(p3d_cm));
 
   pma::Track3D* candidate = nullptr;
   while (vtx) {
     auto segThis = NextSegment(vtx);
 
     double d;
     for (size_t i = 0; i < vtx->NextCount(); i++) {
       auto seg = static_cast<pma::Segment3D*>(vtx->Next(i));
       if (seg != segThis) {
         candidate = seg->Parent()->GetNearestTrkInTree(p3d_cm, d, true);
         if (d < dist) {
           dist = d;
           result = candidate;
         }
       }
     }
 
     if (segThis)
       vtx = static_cast<pma::Node3D*>(segThis->Next());
     else
       break;
   }
 
   return result;
 }

pma::Track3D* pma::Track3D::GetNearestTrkInTree	(	const TVector2 &	p2d_cm,
		unsigned int	view,
		unsigned int	tpc,
		unsigned int	cryo,
		double &	dist,
		bool	skipFirst = `false`
	)

private

double pma::Track3D::GetObjFnInTree ( bool skipFirst = false )

Definition at line 2204 of file PmaTrack3D.cxx.

References fNodes, GetObjFnInTree(), GetObjFunction(), pma::SortedBranchBase::Next(), pma::SortedBranchBase::NextCount(), NextSegment(), and pma::Segment3D::Parent().

Referenced by GetObjFnInTree(), and TuneFullTree().

 {
   pma::Node3D* vtx = fNodes.front();
 
   if (skipFirst) {
     if (auto segThis = NextSegment(vtx)) vtx = static_cast<pma::Node3D*>(segThis->Next());
   }
 
   double g = 0.0;
   while (vtx) {
     auto segThis = NextSegment(vtx);
 
     for (size_t i = 0; i < vtx->NextCount(); i++) {
       auto seg = static_cast<pma::Segment3D*>(vtx->Next(i));
       if (seg != segThis) g += seg->Parent()->GetObjFnInTree(true);
     }
 
     if (segThis)
       vtx = static_cast<pma::Node3D*>(segThis->Next());
     else
       break;
   }
 
   return g + GetObjFunction();
 }

double pma::Track3D::GetObjFunction ( float penaltyFactor = 1.0F ) const

Objective function optimized in track reconstruction.

Definition at line 1817 of file PmaTrack3D.cxx.

References fEndSegWeight, fNodes, fPenaltyValue, and sum.

Referenced by CheckEndSegment(), GetObjFnInTree(), Optimize(), and TuneSinglePass().

 {
   double sum = 0.0;
   float p = penaltyFactor * fPenaltyValue;
   for (size_t i = 0; i < fNodes.size(); i++) {
     sum += fNodes[i]->GetObjFunction(p, fEndSegWeight);
   }
   return sum / fNodes.size();
 }

float pma::Track3D::GetPenalty ( ) const

inlinenoexcept

Definition at line 322 of file PmaTrack3D.h.

322 { return fPenaltyFactor; }

pma::Track3D::fPenaltyFactor

float fPenaltyFactor

Definition: PmaTrack3D.h:400

double pma::Track3D::GetRawdEdxSequence	(	std::map< size_t, std::vector< double >> &	dedx,
		unsigned int	view = `geo::kZ`,
		unsigned int	skip = `0`,
		bool	inclDisabled = `false`
	)		const

Sequence of <hit_index, (wire, drift, X, Y, Z, dE, dx, range)> values for the track, hits tagged as outliers are skipped by default. Results are pushed into the dedx vector given in the function arguments:

  hit (segment middle if many hits) 2D projection in view:
    dedx[n][0] = wire;
    dedx[n][1] = drift;

  hit (segment middle if many hits) 3D position [cm]:
    dedx[n][2] = X;
    dedx[n][3] = Y;
    dedx[n][4] = Z;

    dedx[n][5] = dE [now ADC], energy assigned to the segment;

    dedx[n][6] = dx [cm], length of the segment.

    dedx[n][7] = range, total length to the track endpoint;

  Parameters:
    dedx  - vector to store results (empty at the begining);
    view  - view (U, V or Z) from which dedx is created;
    skip  - number of hits to skip at the begining (first hit has poorly estimated segment
            length so it can be convenient to set skip=1 and handle first hit charge manually);
    inclDisabled - if true then artificial hits added with CompleteMissingWires() are used,
                   otherwise only true hits found in ADC are used.

  Return value: sum of ADC's of hits skipped at the begining.

Definition at line 1027 of file PmaTrack3D.cxx.

References c1, fHits, HitDxByView(), pma::Hit3D::IsEnabled(), kForward, Length(), NextHit(), pma::Hit3D::PeakTime(), pma::Hit3D::Point3D(), PrevHit(), size(), pma::Hit3D::SummedADC(), and pma::Hit3D::Wire().

Referenced by AutoFlip(), pma::PMAlgVertexing::getdQdx(), and trkf::PMAlgTrackMaker::produce().

 {
   dedx.clear();
 
   if (!size()) return 0.0;
 
   size_t step = 1;
 
   pma::Hit3D* hit = nullptr;
 
   double rv, dr, dR, dq, dEq, qSkipped = 0.0;
 
   size_t j = NextHit(-1, view, inclDisabled), s = skip;
   if (j >= size()) return 0.0F; // no charged hits at all
   while (j < size())            // look for the first hit index
   {
     hit = fHits[j];
     dq = hit->SummedADC();
     if (s) {
       qSkipped += dq;
       s--;
     }
     else
       break;
 
     j = NextHit(j, view, inclDisabled);
   }
 
   size_t jmax = PrevHit(size(), view, inclDisabled);
 
   std::vector<size_t> indexes;
   TVector3 p0(0., 0., 0.), p1(0., 0., 0.);
   TVector2 c0(0., 0.), c1(0., 0.);
   while (j <= jmax) {
     indexes.clear(); // prepare to collect hit indexes used for this dE/dx entry
 
     indexes.push_back(j);
     hit = fHits[j];
 
     p0 = hit->Point3D();
     p1 = hit->Point3D();
 
     c0.Set(hit->Wire(), hit->PeakTime());
     c1.Set(hit->Wire(), hit->PeakTime());
 
     dEq = hit->SummedADC(); // [now it is ADC sum]
 
     dr = HitDxByView(j,
                      view,
                      pma::Track3D::kForward); // protection against hits on the same position
     rv = HitDxByView(j, view);                // dx seen by j-th hit
     fHits[j]->fDx = rv;
     dR = rv;
 
     size_t m = 1; // number of hits with charge > 0
     while (((m < step) || (dR < 0.1) || (dr == 0.0)) && (j <= jmax)) {
       j = NextHit(j, view); // just next, even if tagged as outlier
       if (j > jmax) break;  // no more hits in this view
 
       hit = fHits[j];
       if (!inclDisabled && !hit->IsEnabled()) {
         if (dr == 0.0)
           continue;
         else
           break;
       }
       indexes.push_back(j);
 
       p1 = hit->Point3D();
 
       c1.Set(hit->Wire(), hit->PeakTime());
 
       dq = hit->SummedADC();
 
       dEq += dq;
 
       dr = HitDxByView(j, view, pma::Track3D::kForward);
       rv = HitDxByView(j, view);
       fHits[j]->fDx = rv;
       dR += rv;
       m++;
     }
     p0 += p1;
     p0 *= 0.5;
     c0 += c1;
     c0 *= 0.5;
 
     double range = Length(0, j);
 
     std::vector<double> trk_section;
     trk_section.push_back(c0.X());
     trk_section.push_back(c0.Y());
     trk_section.push_back(p0.X());
     trk_section.push_back(p0.Y());
     trk_section.push_back(p0.Z());
     trk_section.push_back(dEq);
     trk_section.push_back(dR);
     trk_section.push_back(range);
 
     for (auto const idx : indexes)
       dedx[idx] = trk_section;
 
     j = NextHit(j, view, inclDisabled);
   }
 
   return qSkipped;
 }

pma::Track3D * pma::Track3D::GetRoot ( )

Definition at line 1742 of file PmaTrack3D.cxx.

References fNodes, GetRoot(), and pma::Segment3D::Parent().

Referenced by AttachBackTo(), AttachTo(), GetRoot(), pma::VtxCandidate::IsAttached(), pma::VtxCandidate::JoinTracks(), and pma::PMAlgStitching::StitchTracks().

 {
   pma::Track3D* trk = nullptr;
 
   if (fNodes.size()) {
     pma::Segment3D* seg = static_cast<pma::Segment3D*>(fNodes.front()->Prev());
     if (seg) trk = seg->Parent()->GetRoot();
     if (!trk) trk = this;
   }
   else
     throw cet::exception("pma::Track3D") << "Broken track, no nodes.";
 
   return trk;
 }

double pma::Track3D::GetT0 ( ) const

inline

Definition at line 257 of file PmaTrack3D.h.

Referenced by trkf::PMAlgTrackMaker::produce().

257 { return fT0; }

pma::Track3D::fT0

double fT0

Definition: PmaTrack3D.h:412

ETag pma::Track3D::GetTag ( ) const

inlinenoexcept

Definition at line 66 of file PmaTrack3D.h.

Referenced by trkf::PMAlgTrackMaker::produce().

66 { return fTag; }

pma::Track3D::fTag

ETag fTag

Definition: PmaTrack3D.h:415

bool pma::Track3D::GetUnconstrainedProj3D	(	detinfo::DetectorPropertiesData const &	detProp,
		art::Ptr< recob::Hit >	hit,
		TVector3 &	p3d,
		double &	dist2
	)		const

private

Calculate 3D position corresponding to 2D hit, return true if the 3D point is in the same TPC as the hit, false otherwise. Calculates also distance^2 between the hit and 2D projection of the track. NOTE: results are meaningful only if the function returns true.

Definition at line 2615 of file PmaTrack3D.cxx.

References geo::CryostatID::Cryostat, fSegments, recob::Hit::PeakTime(), geo::PlaneID::Plane, pma::Node3D::SameTPC(), geo::TPCID::TPC, geo::WireID::Wire, pma::WireDriftToCm(), and recob::Hit::WireID().

Referenced by TestHits().

 {
   TVector2 p2d = pma::WireDriftToCm(detProp,
                                     hit->WireID().Wire,
                                     hit->PeakTime(),
                                     hit->WireID().Plane,
                                     hit->WireID().TPC,
                                     hit->WireID().Cryostat);
 
   pma::Segment3D* seg = nullptr;
   double d2, min_d2 = 1.0e100;
   int tpc = (int)hit->WireID().TPC;
   int view = hit->WireID().Plane;
   for (size_t i = 0; i < fSegments.size(); i++) {
     if (fSegments[i]->TPC() != tpc) continue;
 
     d2 = fSegments[i]->GetDistance2To(p2d, view);
     if (d2 < min_d2) {
       min_d2 = d2;
       seg = fSegments[i];
     }
   }
   if (seg) {
     p3d = seg->GetUnconstrainedProj3D(p2d, view);
     dist2 = min_d2;
 
     pma::Node3D* prev = static_cast<pma::Node3D*>(seg->Prev());
     return prev->SameTPC(p3d); // 3D can be beyond the segment endpoints => in other TPC
   }
 
   return false;
 }

bool pma::Track3D::HasRefPoint ( TVector3 * p ) const

Definition at line 1791 of file PmaTrack3D.cxx.

References fAssignedPoints.

 {
   for (auto point : fAssignedPoints)
     if (point == p) return true;
   return false;
 }

bool pma::Track3D::HasT0 ( ) const

inlinenoexcept

Check if the T0 has been set - enables us to distinguish between T0 set very close to zero or not set.

Definition at line 260 of file PmaTrack3D.h.

Referenced by trkf::PMAlgTrackMaker::produce().

260 { return fT0Flag; }

pma::Track3D::fT0Flag

bool fT0Flag

Definition: PmaTrack3D.h:413

bool pma::Track3D::HasTagFlag ( ETag value ) const

inlinenoexcept

Definition at line 67 of file PmaTrack3D.h.

References value.

Referenced by trkf::PMAlgTrackMaker::produce().

67 { return (fTag & value); }

pma::Track3D::fTag

ETag fTag

Definition: PmaTrack3D.h:415

double value

Definition: spectrum.C:18

bool pma::Track3D::HasTPC ( int tpc ) const

inline

Definition at line 124 of file PmaTrack3D.h.

References dir, larg4::dist(), hits(), geo::kZ, pma::Element3D::TPC(), and lar::dump::vector().

Referenced by Split().

   {
     for (auto n : fNodes)
       if (n->TPC() == tpc) return true;
     return false;
   }

bool pma::Track3D::HasTwoViews ( size_t nmin = 1 ) const

Definition at line 439 of file PmaTrack3D.cxx.

References geo::kU, geo::kV, geo::kZ, and NHits().

Referenced by pma::ProjectionMatchingAlg::buildSegment(), pma::PMAlgFitter::buildShowers(), pma::PMAlgFitter::buildTracks(), Initialize(), ReassignHitsInTree(), and Split().

 {
   unsigned int nviews = 0;
   if (NHits(geo::kU) >= nmin) nviews++;
   if (NHits(geo::kV) >= nmin) nviews++;
   if (NHits(geo::kZ) >= nmin) nviews++;
   return nviews > 1;
 }

double pma::Track3D::HitDxByView	(	size_t	index,
		unsigned int	view
	)		const

Length of the track part associated with index'th hit. Calculated as a half distance to the preceding hit plus half distance to the subsequent hit. In case of the first (last) hit - missing part is estimated as 1/4 of the distance to the next (previous) hit. NOTE: only hits from a given view are considered; other hits are accounted for segment lengths but overall dx is calculated between hits in given view.

Definition at line 993 of file PmaTrack3D.cxx.

References kBackward, kForward, and size().

Referenced by GetRawdEdxSequence(), HitDxByView(), and pma::ProjectionMatchingAlg::selectInitialHits().

 {
   if (index < size()) {
     return 0.5 * (HitDxByView(index, view, pma::Track3D::kForward) +
                   HitDxByView(index, view, pma::Track3D::kBackward));
   }
   else {
     mf::LogError("pma::Track3D") << "Hit index out of range.";
     return 0.0;
   }
 }

double pma::Track3D::HitDxByView	(	size_t	index,
		unsigned int	view,
		Track3D::EDirection	dir,
		bool	secondDir = `false`
	)		const

private

Distance to the nearest subsequent (dir = Track3D::kForward) or preceeding (dir = Track3D::kBackward) hit in given view. In case of last (first) hit in this view the half-distance in opposite direction is returned. Parameter secondDir is only for internal protection - please leave the default value.

Definition at line 928 of file PmaTrack3D.cxx.

References pma::Dist2(), fHits, HitDxByView(), kBackward, kForward, Length(), pma::Hit3D::Point3D(), size(), and pma::Hit3D::View2D().

 {
   pma::Hit3D* nexthit = nullptr;
   pma::Hit3D* hit = fHits[index];
 
   if (hit->View2D() != view) {
     mf::LogWarning("pma::Track3D") << "Function used with the hit not matching specified view.";
   }
 
   double dx = 0.0; // [cm]
   bool hitFound = false;
   int i = index;
   switch (dir) {
   case pma::Track3D::kForward:
     while (!hitFound && (++i < (int)size())) {
       nexthit = fHits[i];
       dx += sqrt(pma::Dist2(hit->Point3D(), nexthit->Point3D()));
 
       if (nexthit->View2D() == view)
         hitFound = true;
       else
         hitFound = false;
 
       hit = nexthit;
     }
     if (!hitFound) {
       if (!secondDir)
         dx = 0.5 * HitDxByView(index, view, pma::Track3D::kBackward, true);
       else {
         dx = Length();
         mf::LogWarning("pma::Track3D") << "Single hit in this view.";
       }
     }
     break;
 
   case pma::Track3D::kBackward:
     while (!hitFound && (--i >= 0)) {
       nexthit = fHits[i];
       dx += sqrt(pma::Dist2(hit->Point3D(), nexthit->Point3D()));
 
       if (nexthit->View2D() == view)
         hitFound = true;
       else
         hitFound = false;
 
       hit = nexthit;
     }
     if (!hitFound) {
       if (!secondDir)
         dx = 0.5 * HitDxByView(index, view, pma::Track3D::kForward, true);
       else {
         dx = Length();
         mf::LogWarning("pma::Track3D") << "Single hit in this view.";
       }
     }
     break;
 
   default: mf::LogError("pma::Track3D") << "Direction undefined."; break;
   }
   return dx;
 }

int pma::Track3D::index_of ( const pma::Hit3D * hit ) const

Definition at line 341 of file PmaTrack3D.cxx.

References fHits, and size().

Referenced by DisableSingleViewEnds(), Flip(), and pma::TrkCandidateColl::setTreeOriginAtFront().

 {
   for (size_t i = 0; i < size(); i++)
     if (fHits[i] == hit) return (int)i;
   return -1;
 }

int pma::Track3D::index_of ( const pma::Node3D * n ) const

Definition at line 334 of file PmaTrack3D.cxx.

References fNodes.

 {
   for (size_t i = 0; i < fNodes.size(); ++i)
     if (fNodes[i] == n) return (int)i;
   return -1;
 }

bool pma::Track3D::InitFromHits	(	detinfo::DetectorPropertiesData const &	detProp,
		int	tpc,
		int	cryo,
		float	initEndSegW = `0.05F`
	)

private

Definition at line 119 of file PmaTrack3D.cxx.

References AddNode(), ClearNodes(), detinfo::DetectorPropertiesData::ConvertTicksToX(), pma::Dist2(), fEndSegWeight, fHits, fNodes, geo::GeometryCore::IntersectionPoint(), MakeProjection(), Optimize(), pma::Hit3D::PeakTime(), SelectAllHits(), UpdateHitsRadius(), pma::Hit3D::View2D(), pma::Hit3D::Wire(), geo::WireID::Wire, x, y, and z.

Referenced by Initialize().

 {
   art::ServiceHandle<geo::Geometry const> geom;
   geo::TPCID const tpcid(cryo, tpc);
 
   float wtmp = fEndSegWeight;
   fEndSegWeight = initEndSegW;
 
   // endpoints for the first combination:
   TVector3 v3d_1(0., 0., 0.), v3d_2(0., 0., 0.);
 
   assert(!fHits.empty());
 
   pma::Hit3D* hit0_a = fHits.front();
   pma::Hit3D* hit1_a = fHits.front();
 
   geo::PlaneID const hit0_a_planeid{tpcid, hit0_a->View2D()};
   geo::PlaneID const hit1_a_planeid{tpcid, hit1_a->View2D()};
 
   float minX = detProp.ConvertTicksToX(hit0_a->PeakTime(), hit0_a_planeid);
   float maxX = detProp.ConvertTicksToX(hit1_a->PeakTime(), hit1_a_planeid);
   for (auto hit : fHits) {
     double const x = detProp.ConvertTicksToX(hit->PeakTime(), geo::PlaneID{tpcid, hit->View2D()});
     if (x < minX) {
       minX = x;
       hit0_a = hit;
     }
     if (x > maxX) {
       maxX = x;
       hit1_a = hit;
     }
   }
 
   pma::Hit3D* hit0_b = nullptr;
   pma::Hit3D* hit1_b = nullptr;
 
   float minDiff0 = 5000, minDiff1 = 5000;
   for (auto hit : fHits) {
     double const x = detProp.ConvertTicksToX(hit->PeakTime(), geo::PlaneID{tpcid, hit->View2D()});
     double diff = fabs(x - minX);
     if ((diff < minDiff0) && (hit->View2D() != hit0_a->View2D())) {
       minDiff0 = diff;
       hit0_b = hit;
     }
     diff = fabs(x - maxX);
     if ((diff < minDiff1) && (hit->View2D() != hit1_a->View2D())) {
       minDiff1 = diff;
       hit1_b = hit;
     }
   }
 
   if (hit0_a && hit0_b && hit1_a && hit1_b) {
     geo::PlaneID const hit0_b_planeid{tpcid, hit0_b->View2D()};
     geo::PlaneID const hit1_b_planeid{tpcid, hit1_b->View2D()};
     double x = 0.5 * (detProp.ConvertTicksToX(hit0_a->PeakTime(), hit0_a_planeid) +
                       detProp.ConvertTicksToX(hit0_b->PeakTime(), hit0_b_planeid));
     double y, z;
     geom->IntersectionPoint(geo::WireID{hit0_a_planeid, hit0_a->Wire()},
                             geo::WireID{hit0_b_planeid, hit0_b->Wire()},
                             y,
                             z);
     v3d_1.SetXYZ(x, y, z);
 
     x = 0.5 * (detProp.ConvertTicksToX(hit1_a->PeakTime(), hit1_a_planeid) +
                detProp.ConvertTicksToX(hit1_b->PeakTime(), hit1_b_planeid));
     geom->IntersectionPoint(geo::WireID{hit1_a_planeid, hit1_a->Wire()},
                             geo::WireID{hit1_b_planeid, hit1_b->Wire()},
                             y,
                             z);
     v3d_2.SetXYZ(x, y, z);
 
     ClearNodes();
     AddNode(detProp, v3d_1, tpc, cryo);
     AddNode(detProp, v3d_2, tpc, cryo);
 
     MakeProjection();
     UpdateHitsRadius();
     Optimize(detProp, 0, 0.01F, false, true, 100);
     SelectAllHits();
   }
   else {
     mf::LogVerbatim("pma::Track3D") << "Good hits not found.";
     fEndSegWeight = wtmp;
     return false;
   }
 
   if (pma::Dist2(fNodes.front()->Point3D(), fNodes.back()->Point3D()) < (0.3 * 0.3)) {
     mf::LogVerbatim("pma::Track3D") << "Short initial segment.";
     fEndSegWeight = wtmp;
     return false;
   }
 
   fEndSegWeight = wtmp;
   return true;
 }

void pma::Track3D::InitFromMiddle	(	detinfo::DetectorPropertiesData const &	detProp,
		int	tpc,
		int	cryo
	)

private

Definition at line 307 of file PmaTrack3D.cxx.

References AddNode(), ClearNodes(), MakeProjection(), maxY, geo::BoxBoundedGeo::MinX(), minY, Optimize(), geo::GeometryCore::TPC(), and UpdateHitsRadius().

Referenced by Initialize().

 {
   art::ServiceHandle<geo::Geometry const> geom;
 
   const auto& tpcGeo = geom->TPC(geo::TPCID(cryo, tpc));
 
   double minX = tpcGeo.MinX(), maxX = tpcGeo.MaxX();
   double minY = tpcGeo.MinY(), maxY = tpcGeo.MaxY();
   double minZ = tpcGeo.MinZ(), maxZ = tpcGeo.MaxZ();
 
   TVector3 v3d_1(0.5 * (minX + maxX), 0.5 * (minY + maxY), 0.5 * (minZ + maxZ));
   TVector3 v3d_2(v3d_1);
 
   TVector3 shift(5.0, 5.0, 5.0);
   v3d_1 += shift;
   v3d_2 -= shift;
 
   ClearNodes();
   AddNode(detProp, v3d_1, tpc, cryo);
   AddNode(detProp, v3d_2, tpc, cryo);
 
   MakeProjection();
   UpdateHitsRadius();
 
   Optimize(detProp, 0, 0.01F);
 }

bool pma::Track3D::InitFromRefPoints	(	detinfo::DetectorPropertiesData const &	detProp,
		int	tpc,
		int	cryo
	)

private

Definition at line 218 of file PmaTrack3D.cxx.

References AddNode(), ClearNodes(), fAssignedPoints, MakeProjection(), pmtana::mean(), Optimize(), RebuildSegments(), scale, SelectAllHits(), size(), UpdateHitsRadius(), w, and y.

Referenced by Initialize().

 {
   if (fAssignedPoints.size() < 2) return false;
 
   ClearNodes();
 
   TVector3 mean(0., 0., 0.), stdev(0., 0., 0.), p(0., 0., 0.);
   for (size_t i = 0; i < fAssignedPoints.size(); i++) {
     p = *(fAssignedPoints[i]);
     mean += p;
     p.SetXYZ(p.X() * p.X(), p.Y() * p.Y(), p.Z() * p.Z());
     stdev += p;
   }
   stdev *= 1.0 / fAssignedPoints.size();
   mean *= 1.0 / fAssignedPoints.size();
   p = mean;
   p.SetXYZ(p.X() * p.X(), p.Y() * p.Y(), p.Z() * p.Z());
   stdev -= p;
 
   double sx = stdev.X(), sy = stdev.Y(), sz = stdev.Z();
   if (sx >= 0.0)
     sx = sqrt(sx);
   else
     sx = 0.0;
   if (sy >= 0.0)
     sy = sqrt(sy);
   else
     sy = 0.0;
   if (sz >= 0.0)
     sz = sqrt(sz);
   else
     sz = 0.0;
   stdev.SetXYZ(sx, sy, sz);
 
   double scale = 2.0 * stdev.Mag();
   double iscale = 1.0 / scale;
 
   size_t max_index = 0;
   double norm2, max_norm2 = 0.0;
   std::vector<TVector3> data;
   for (size_t i = 0; i < fAssignedPoints.size(); i++) {
     p = *(fAssignedPoints[i]);
     p -= mean;
     p *= iscale;
     norm2 = p.Mag2();
     if (norm2 > max_norm2) {
       max_norm2 = norm2;
       max_index = i;
     }
     data.push_back(p);
   }
 
   double y = 0.0, kappa = 1.0, prev_kappa, kchg = 1.0;
   TVector3 w(data[max_index]);
 
   while (kchg > 0.0001)
     for (size_t i = 0; i < data.size(); i++) {
       y = (data[i] * w);
       w += (y / kappa) * (data[i] - y * w);
 
       prev_kappa = kappa;
       kappa += y * y;
       kchg = fabs((kappa - prev_kappa) / prev_kappa);
     }
   w *= 1.0 / w.Mag();
 
   TVector3 v1(w), v2(w);
   v1 *= scale;
   v1 += mean;
   v2 *= -scale;
   v2 += mean;
   std::sort(fAssignedPoints.begin(), fAssignedPoints.end(), pma::bSegmentProjLess(v1, v2));
   for (size_t i = 0; i < fAssignedPoints.size(); i++) {
     AddNode(detProp, *(fAssignedPoints[i]), tpc, cryo);
   }
 
   RebuildSegments();
   MakeProjection();
 
   if (size()) UpdateHitsRadius();
 
   Optimize(detProp, 0, 0.01F, false, true, 100);
   SelectAllHits();
 
   return true;
 }

bool pma::Track3D::Initialize	(	detinfo::DetectorPropertiesData const &	detProp,
		float	initEndSegW = `0.05F`
	)

Definition at line 77 of file PmaTrack3D.cxx.

References Cryos(), HasTwoViews(), InitFromHits(), InitFromMiddle(), InitFromRefPoints(), TPCs(), and UpdateHitsRadius().

Referenced by pma::ProjectionMatchingAlg::buildSegment(), and pma::ProjectionMatchingAlg::buildTrack().

 {
   if (!HasTwoViews(2)) {
     mf::LogError("pma::Track3D") << "Need min. 2 hits per view, at least two views.";
     return false;
   }
 
   auto cryos = Cryos();
   if (cryos.size() > 1) {
     mf::LogError("pma::Track3D") << "Only one cryostat for now, please.";
     return false;
   }
   int cryo = cryos.front();
 
   auto tpcs = TPCs();
   if (tpcs.size() > 1) {
     mf::LogError("pma::Track3D") << "Only one TPC, please.";
     return false;
   }
   // single tpc, many tpc's are ok, but need to be handled from ProjectionMatchingAlg::buildMultiTPCTrack()
   int tpc = tpcs.front();
 
   if (InitFromRefPoints(detProp, tpc, cryo))
     mf::LogVerbatim("pma::Track3D") << "Track initialized with 3D reference points.";
   else if (InitFromHits(detProp, tpc, cryo, initEndSegW))
     mf::LogVerbatim("pma::Track3D") << "Track initialized with hit positions.";
   else {
     InitFromMiddle(detProp, tpc, cryo);
     mf::LogVerbatim("pma::Track3D") << "Track initialized in the module center.";
   }
 
   UpdateHitsRadius();
   return true;
 }

void pma::Track3D::InsertNode	(	detinfo::DetectorPropertiesData const &	detProp,
		TVector3 const &	p3d,
		size_t	at_idx,
		unsigned int	tpc,
		unsigned int	cryo
	)

Definition at line 1400 of file PmaTrack3D.cxx.

References fNodes, and RebuildSegments().

Referenced by pma::VtxCandidate::JoinTracks().

 {
   pma::Node3D* vtx =
     new pma::Node3D(detProp, p3d, tpc, cryo, false, fNodes[at_idx]->GetDriftShift());
   fNodes.insert(fNodes.begin() + at_idx, vtx);
 
   if (fNodes.size() > 1) RebuildSegments();
 }

void pma::Track3D::InternalFlip ( std::vector< pma::Track3D * > & toSort )

private

Definition at line 597 of file PmaTrack3D.cxx.

References fNodes, InternalFlip(), pma::Segment3D::Parent(), and RebuildSegments().

Referenced by Flip(), and InternalFlip().

 {
   for (size_t i = 0; i < fNodes.size() - 1; i++)
     if (fNodes[i]->NextCount() > 1) {
       for (size_t j = 0; j < fNodes[i]->NextCount(); j++) {
         pma::Segment3D* s = static_cast<pma::Segment3D*>(fNodes[i]->Next(j));
         if (s->Parent() != this) toSort.push_back(s->Parent());
       }
     }
 
   if (fNodes.back()->NextCount())
     for (size_t j = 0; j < fNodes.back()->NextCount(); j++) {
       pma::Segment3D* s = static_cast<pma::Segment3D*>(fNodes.back()->Next(j));
       toSort.push_back(s->Parent());
     }
 
   if (fNodes.front()->Prev()) {
     pma::Segment3D* s = static_cast<pma::Segment3D*>(fNodes.front()->Prev());
     toSort.push_back(s->Parent());
     s->Parent()->InternalFlip(toSort);
   }
 
   std::reverse(fNodes.begin(), fNodes.end());
   toSort.push_back(this);
   RebuildSegments();
 }

bool pma::Track3D::IsAttachedTo ( pma::Track3D const * trk ) const

Definition at line 1776 of file PmaTrack3D.cxx.

References GetBranches().

Referenced by AttachBackTo(), AttachTo(), pma::VtxCandidate::HasLoops(), and pma::VtxCandidate::IsAttached().

 {
   if (trk == this) return true;
 
   std::vector<pma::Track3D const*> branchesThis, branchesTrk;
 
   if (!trk->GetBranches(branchesTrk)) return true; // has loop - better check the reason
   if (!GetBranches(branchesThis)) return true;     // has loop - better check the reason
 
   for (auto bThis : branchesThis)
     for (auto bTrk : branchesTrk)
       if (bThis == bTrk) return true;
   return false;
 }

pma::Node3D* pma::Track3D::LastElement ( ) const

inline

Definition at line 276 of file PmaTrack3D.h.

Referenced by pma::ProjectionMatchingAlg::isContained(), SelectHits(), and pma::PMAlgTracker::validate().

276 { return fNodes.back(); }

Referenced by pma::VtxCandidate::Add(), pma::PMAlgTracker::areCoLinear(), pma::ProjectionMatchingAlg::buildSegment(), pma::PMAlgFitter::buildShowers(), pma::PMAlgFitter::buildTracks(), pma::VtxCandidate::Compute(), pma::VtxCandidate::ComputeMse2D(), pma::ProjectionMatchingAlg::extendTrack(), pma::PMAlgVertexing::findKinksOnTracks(), pma::PMAlgVertexing::getKinks(), pma::TrkCandidateColl::getTreeCopy(), pma::PMAlgVertexing::getVertices(), pma::VtxCandidate::JoinTracks(), pma::VtxCandidate::MaxAngle(), pma::PMAlgVertexing::mergeBrokenTracks(), pma::PMAlgTracker::mergeCoLinear(), pma::ProjectionMatchingAlg::mergeTracks(), pma::PMAlgCosmicTagger::outOfDriftWindow(), trkf::PMAlgTrackMaker::produce(), pma::TrkCandidateColl::setParentDaughterConnections(), pma::TrkCandidateColl::setTreeId(), pma::TrkCandidateColl::setTreeOriginAtFront(), and pma::PMAlgStitching::StitchTracks().

std::vector< pma::Node3D * > fNodes

Definition: PmaTrack3D.h:396

double pma::Track3D::Length ( size_t step = 1 ) const

inline

Definition at line 94 of file PmaTrack3D.h.

References tca::AddHits(), pma::Dist2(), hits(), geo::kUnknown, Length(), tca::Length(), util::size(), and lar::dump::vector().

Referenced by pma::PMAlgTracker::areCoLinear(), pma::PMAlgFitter::buildShowers(), pma::PMAlgFitter::buildTracks(), GetRawdEdxSequence(), HitDxByView(), Length(), pma::ProjectionMatchingAlg::mergeTracks(), pma::ProjectionMatchingAlg::ShortenSeg_(), and pma::ProjectionMatchingAlg::twoViewFraction().

94 { return Length(0, size() - 1, step); }

pma::Track3D::Length

double Length(size_t step=1) const

Definition: PmaTrack3D.h:94

pma::Track3D::size

size_t size() const

Definition: PmaTrack3D.h:89

double pma::Track3D::Length	(	size_t	start,
		size_t	stop,
		size_t	step = `1`
	)		const

Definition at line 863 of file PmaTrack3D.cxx.

References back(), pma::Dist2(), fHits, h1, pma::Hit3D::Point3D(), size(), and tmp.

 {
   auto const nHits = size();
   if (nHits < 2) return 0.0;
 
   if (start > stop) {
     size_t tmp = stop;
     stop = start;
     start = tmp;
   }
   if (start >= nHits - 1) return 0.0;
   if (stop >= nHits) stop = nHits - 1;
 
   double result = 0.0;
   pma::Hit3D *h1 = nullptr, *h0 = fHits[start];
 
   if (!step) step = 1;
   size_t i = start + step;
   while (i <= stop) {
     h1 = fHits[i];
     result += sqrt(pma::Dist2(h1->Point3D(), h0->Point3D()));
     h0 = h1;
     i += step;
   }
   if (i - step < stop) // last step jumped beyond the stop point
   {                    // so need to add the last short segment
     result += sqrt(pma::Dist2(h0->Point3D(), back()->Point3D()));
   }
   return result;
 }

void pma::Track3D::MakeFastProjection ( )

private

Definition at line 2923 of file PmaTrack3D.cxx.

References fHits, fNodes, fSegments, pma::Element3D::GetDistance2To(), pma::Segment3D::GetDistance2To(), pma::Node3D::GetDistance2To(), n, pma::SortedObjectBase::Next(), NextSegment(), pma::SortedObjectBase::Prev(), PrevSegment(), pma::Element3D::RemoveHitAt(), and pma::Element3D::TPC().

Referenced by Optimize().

 {
   std::vector<std::pair<pma::Hit3D*, pma::Element3D*>> assignments;
   assignments.reserve(fHits.size());
 
   for (auto hi : fHits) {
     pma::Element3D* pe = nullptr;
 
     for (auto s : fSegments) {
       for (size_t j = 0; j < s->NHits(); ++j)
         if (hi == s->Hits()[j]) // look at next/prev vtx,seg,vtx
         {
           pe = s;
           double min_d2 = s->GetDistance2To(hi->Point2D(), hi->View2D());
           int const tpc = hi->TPC();
 
           pma::Node3D* nnext = static_cast<pma::Node3D*>(s->Next());
           if (nnext->TPC() == tpc) {
             double const d2 = nnext->GetDistance2To(hi->Point2D(), hi->View2D());
             if (d2 < min_d2) {
               min_d2 = d2;
               pe = nnext;
             }
 
             pma::Segment3D* snext = NextSegment(nnext);
             if (snext && (snext->TPC() == tpc)) {
               double const d2 = snext->GetDistance2To(hi->Point2D(), hi->View2D());
               if (d2 < min_d2) {
                 min_d2 = d2;
                 pe = snext;
               }
 
               nnext = static_cast<pma::Node3D*>(snext->Next());
               if (nnext->TPC() == tpc) {
                 double const d2 = nnext->GetDistance2To(hi->Point2D(), hi->View2D());
                 if (d2 < min_d2) {
                   min_d2 = d2;
                   pe = nnext;
                 }
               }
             }
           }
 
           pma::Node3D* nprev = static_cast<pma::Node3D*>(s->Prev());
           if (nprev->TPC() == tpc) {
             double const d2 = nprev->GetDistance2To(hi->Point2D(), hi->View2D());
             if (d2 < min_d2) {
               min_d2 = d2;
               pe = nprev;
             }
 
             pma::Segment3D* sprev = PrevSegment(nprev);
             if (sprev && (sprev->TPC() == tpc)) {
               double const d2 = sprev->GetDistance2To(hi->Point2D(), hi->View2D());
               if (d2 < min_d2) {
                 min_d2 = d2;
                 pe = sprev;
               }
 
               nprev = static_cast<pma::Node3D*>(sprev->Prev());
               if (nprev->TPC() == tpc) {
                 double const d2 = nprev->GetDistance2To(hi->Point2D(), hi->View2D());
                 if (d2 < min_d2) {
                   min_d2 = d2;
                   pe = nprev;
                 }
               }
             }
           }
 
           s->RemoveHitAt(j);
           break;
         }
       if (pe) break;
     }
 
     if (!pe)
       for (auto n : fNodes) {
         for (size_t j = 0; j < n->NHits(); ++j)
           if (hi == n->Hits()[j]) // look at next/prev seg,vtx,seg
           {
             pe = n;
             double d2, min_d2 = n->GetDistance2To(hi->Point2D(), hi->View2D());
             int tpc = hi->TPC();
 
             pma::Segment3D* snext = NextSegment(n);
             if (snext && (snext->TPC() == tpc)) {
               d2 = snext->GetDistance2To(hi->Point2D(), hi->View2D());
               if (d2 < min_d2) {
                 min_d2 = d2;
                 pe = snext;
               }
 
               pma::Node3D* nnext = static_cast<pma::Node3D*>(snext->Next());
               if (nnext->TPC() == tpc) {
                 d2 = nnext->GetDistance2To(hi->Point2D(), hi->View2D());
                 if (d2 < min_d2) {
                   min_d2 = d2;
                   pe = nnext;
                 }
 
                 snext = NextSegment(nnext);
                 if (snext && (snext->TPC() == tpc)) {
                   d2 = snext->GetDistance2To(hi->Point2D(), hi->View2D());
                   if (d2 < min_d2) {
                     min_d2 = d2;
                     pe = snext;
                   }
                 }
               }
             }
 
             pma::Segment3D* sprev = PrevSegment(n);
             if (sprev && (sprev->TPC() == tpc)) {
               d2 = sprev->GetDistance2To(hi->Point2D(), hi->View2D());
               if (d2 < min_d2) {
                 min_d2 = d2;
                 pe = sprev;
               }
 
               pma::Node3D* nprev = static_cast<pma::Node3D*>(sprev->Prev());
               if (nprev->TPC() == tpc) {
                 d2 = nprev->GetDistance2To(hi->Point2D(), hi->View2D());
                 if (d2 < min_d2) {
                   min_d2 = d2;
                   pe = nprev;
                 }
 
                 sprev = PrevSegment(nprev);
                 if (sprev && (sprev->TPC() == tpc)) {
                   d2 = sprev->GetDistance2To(hi->Point2D(), hi->View2D());
                   if (d2 < min_d2) {
                     min_d2 = d2;
                     pe = sprev;
                   }
                 }
               }
             }
 
             n->RemoveHitAt(j);
             break;
           }
         if (pe) break;
       }
 
     if (pe)
       assignments.emplace_back(hi, pe);
     else
       mf::LogWarning("pma::Track3D") << "Hit was not assigned to any element.";
   }
 
   for (auto const& a : assignments)
     a.second->AddHit(a.first);
 
   for (auto n : fNodes)
     n->UpdateHitParams();
   for (auto s : fSegments)
     s->UpdateHitParams();
 }

void pma::Track3D::MakeProjection ( )

Definition at line 2887 of file PmaTrack3D.cxx.

References pma::Element3D::AddHit(), pma::Element3D::AddPoint(), fAssignedPoints, fHits, fNodes, fSegments, GetNearestElement(), and n.

Referenced by CheckEndSegment(), CleanupTails(), CompleteMissingWires(), DisableSingleViewEnds(), ExtendWith(), InitFromHits(), InitFromMiddle(), InitFromRefPoints(), pma::VtxCandidate::JoinTracks(), MakeProjectionInTree(), pma::ProjectionMatchingAlg::mergeTracks(), Optimize(), RemoveHits(), ShiftEndsToHits(), and Track3D().

 {
   for (auto n : fNodes)
     n->ClearAssigned(this);
   for (auto s : fSegments)
     s->ClearAssigned(this);
 
   pma::Element3D* pe = nullptr;
 
   bool skipFrontVtx = false, skipBackVtx = false;
 
   // skip outermost vertices if not branching
   if (!(fNodes.front()->IsFrozen()) && !(fNodes.front()->Prev()) &&
       (fNodes.front()->NextCount() == 1)) {
     skipFrontVtx = true;
   }
   if (!(fNodes.front()->IsFrozen()) && (fNodes.back()->NextCount() == 0)) { skipBackVtx = true; }
 
   for (auto h : fHits) // assign hits to nodes/segments
   {
     pe = GetNearestElement(h->Point2D(), h->View2D(), h->TPC(), skipFrontVtx, skipBackVtx);
     pe->AddHit(h);
   }
 
   for (auto p : fAssignedPoints) // assign ref points to nodes/segments
   {
     pe = GetNearestElement(*p);
     pe->AddPoint(p);
   }
 
   for (auto n : fNodes)
     n->UpdateHitParams();
   for (auto s : fSegments)
     s->UpdateHitParams();
 }

void pma::Track3D::MakeProjectionInTree ( bool skipFirst = false )

Definition at line 2154 of file PmaTrack3D.cxx.

References fNodes, MakeProjection(), MakeProjectionInTree(), pma::SortedBranchBase::Next(), pma::SortedBranchBase::NextCount(), NextSegment(), and pma::Segment3D::Parent().

Referenced by MakeProjectionInTree(), and TuneFullTree().

 {
   pma::Node3D* vtx = fNodes.front();
 
   if (skipFirst) {
     if (auto segThis = NextSegment(vtx)) vtx = static_cast<pma::Node3D*>(segThis->Next());
   }
 
   while (vtx) {
     auto segThis = NextSegment(vtx);
 
     for (size_t i = 0; i < vtx->NextCount(); i++) {
       auto seg = static_cast<pma::Segment3D*>(vtx->Next(i));
       if (seg != segThis) seg->Parent()->MakeProjectionInTree(true);
     }
 
     if (segThis)
       vtx = static_cast<pma::Node3D*>(segThis->Next());
     else
       break;
   }
 
   MakeProjection();
 }

unsigned int pma::Track3D::NEnabledHits ( unsigned int view = geo::kUnknown ) const

Definition at line 430 of file PmaTrack3D.cxx.

References fHits, geo::kUnknown, and n.

Referenced by pma::ProjectionMatchingAlg::TestTrk_().

 {
   unsigned int n = 0;
   for (auto hit : fHits) {
     if (hit->IsEnabled() && ((view == geo::kUnknown) || (view == hit->View2D()))) n++;
   }
   return n;
 }

int pma::Track3D::NextHit	(	int	index,
		unsigned int	view = `geo::kZ`,
		bool	inclDisabled = `false`
	)		const

Definition at line 894 of file PmaTrack3D.cxx.

References fHits, pma::Hit3D::IsEnabled(), size(), and pma::Hit3D::View2D().

Referenced by CompleteMissingWires(), GetRawdEdxSequence(), pma::ProjectionMatchingAlg::guideEndpoints(), and pma::ProjectionMatchingAlg::selectInitialHits().

 {
   pma::Hit3D* hit = nullptr;
   if (index < -1) index = -1;
   while (++index < (int)size()) // look for the next index of hit from the view
   {
     hit = fHits[index];
     if (hit->View2D() == view) {
       if (inclDisabled)
         break;
       else if (hit->IsEnabled())
         break;
     }
   }
   return index;
 }

pma::Segment3D * pma::Track3D::NextSegment ( pma::Node3D * vtx ) const

Definition at line 1005 of file PmaTrack3D.cxx.

References pma::SortedBranchBase::Next(), pma::SortedBranchBase::NextCount(), and pma::Segment3D::Parent().

Referenced by pma::VtxCandidate::Add(), ApplyDriftShiftInTree(), AttachBackToSameTPC(), AttachToSameTPC(), CanFlip(), CleanupTails(), pma::VtxCandidate::Compute(), pma::VtxCandidate::ComputeMse2D(), DisableSingleViewEnds(), Flip(), GetNearestTrkInTree(), GetObjFnInTree(), pma::TrkCandidateColl::getTreeCopy(), pma::VtxCandidate::JoinTracks(), MakeFastProjection(), MakeProjectionInTree(), ReassignHitsInTree(), pma::TrkCandidateColl::setTreeId(), pma::TrkCandidateColl::setTreeOriginAtFront(), SortHits(), SortHitsInTree(), SwapVertices(), TuneSinglePass(), and UpdateParamsInTree().

 {
   pma::Segment3D* seg = nullptr;
   unsigned int nCount = vtx->NextCount();
   unsigned int k = 0;
   while (k < nCount) {
     seg = static_cast<pma::Segment3D*>(vtx->Next(k));
     if (seg && (seg->Parent() == this)) return seg;
     k++;
   }
   return 0;
 }

unsigned int pma::Track3D::NHits ( unsigned int view ) const

Definition at line 421 of file PmaTrack3D.cxx.

References fHits, and n.

Referenced by AddNode(), pma::ProjectionMatchingAlg::buildTrack(), pma::ProjectionMatchingAlg::extendTrack(), pma::PMAlgVertexing::getdQdx(), HasTwoViews(), and SelectHits().

 {
   unsigned int n = 0;
   for (auto hit : fHits) {
     if (hit->View2D() == view) n++;
   }
   return n;
 }

std::vector<pma::Node3D*> const& pma::Track3D::Nodes ( ) const

inlinenoexcept

Definition at line 274 of file PmaTrack3D.h.

274 { return fNodes; }

std::vector< pma::Node3D * > fNodes

Definition: PmaTrack3D.h:396

pma::Hit3D* pma::Track3D::operator[] ( size_t index )

inline

Definition at line 85 of file PmaTrack3D.h.

85 { return fHits[index]; }

std::vector< pma::Hit3D * > fHits

Definition: PmaTrack3D.h:385

pma::Hit3D const* pma::Track3D::operator[] ( size_t index ) const

inline

Definition at line 86 of file PmaTrack3D.h.

86 { return fHits[index]; }

Referenced by pma::ProjectionMatchingAlg::buildMultiTPCTrack(), pma::ProjectionMatchingAlg::buildSegment(), pma::ProjectionMatchingAlg::buildTrack(), pma::ProjectionMatchingAlg::extendTrack(), pma::PMAlgVertexing::findKinksOnTracks(), pma::ProjectionMatchingAlg::guideEndpoints(), InitFromHits(), InitFromMiddle(), InitFromRefPoints(), pma::ProjectionMatchingAlg::mergeTracks(), and pma::ProjectionMatchingAlg::ShortenSeg_().

std::vector< pma::Hit3D * > fHits

Definition: PmaTrack3D.h:385

double pma::Track3D::Optimize	(	const detinfo::DetectorPropertiesData &	detProp,
		int	nNodes = `-1`,
		double	eps = `0.01`,
		bool	selAllHits = `true`,
		bool	setAllNodes = `true`,
		size_t	selSegHits = `0`,
		size_t	selVtxHits = `0`
	)

Main optimization method.

Definition at line 1827 of file PmaTrack3D.cxx.

References AddNode(), CheckEndSegment(), fEndSegWeight, fMaxSegStop, fMaxSegStopFactor, fMinSegStop, fNodes, fPenaltyValue, fSegments, fSegStopValue, GetObjFunction(), kBegin, kEnd, MakeFastProjection(), MakeProjection(), n, SelectAllHits(), SelectRndHits(), size(), and UpdateParams().

 {
   if (!fNodes.size()) {
     mf::LogError("pma::Track3D") << "Track not initialized.";
     return 0.0;
   }
 
   if (!UpdateParams()) {
     mf::LogError("pma::Track3D") << "Track empty.";
     return 1.0e10;
   }
   double g0 = GetObjFunction(), g1 = 0.0;
   if (g0 == 0.0) return g0;
 
   // set branching flag only at the beginning, optimization is not changing
   // that and new nodes are not branching
   for (auto n : fNodes)
     n->SetVertexToBranching(setAllNodes);
 
   bool stop = false;
   fMinSegStop = fSegments.size();
   fMaxSegStop = (int)(size() / fMaxSegStopFactor) + 1;
   do {
     if (selSegHits || selVtxHits) SelectRndHits(selSegHits, selVtxHits);
 
     bool stepDone = true;
     unsigned int stepIter = 0;
     do {
       double gstep = 1.0;
       unsigned int iter = 0;
       while ((gstep > eps) && (iter < 1000)) {
         if ((fNodes.size() < 4) || (iter % 10 == 0))
           MakeProjection();
         else
           MakeFastProjection();
 
         if (!UpdateParams()) {
           mf::LogError("pma::Track3D") << "Track empty.";
           return 0.0;
         }
 
         for (auto n : fNodes)
           n->Optimize(fPenaltyValue, fEndSegWeight);
 
         g1 = g0;
         g0 = GetObjFunction();
 
         if (g0 == 0.0F) {
           MakeProjection();
           break;
         }
         gstep = fabs(g0 - g1) / g0;
         iter++;
       }
 
       stepIter++;
       if (fNodes.size() > 2) {
         stepDone = !(CheckEndSegment(pma::Track3D::kEnd) || CheckEndSegment(pma::Track3D::kBegin));
       }
     } while (!stepDone && (stepIter < 5));
 
     if (selAllHits) {
       selAllHits = false;
       selSegHits = 0;
       selVtxHits = 0;
       if (SelectAllHits()) continue;
     }
 
     switch (nNodes) {
     case 0: stop = true; break; // just optimize existing vertices
 
     case -1: // grow and optimize until automatic stop condition
       mf::LogVerbatim("pma::Track3D") << "optimized segments: " << fSegments.size();
       if ((fSegments.size() >= fSegStopValue) || (fSegments.size() >= fMaxSegStop)) { stop = true; }
       else {
         if (!AddNode(detProp)) stop = true;
       }
       break;
 
     default: // grow and optimize until fixed number of vertices is added
       if (nNodes > 12) {
         if (AddNode(detProp)) {
           MakeProjection();
           nNodes--;
         }
         else {
           mf::LogVerbatim("pma::Track3D") << "stop (3)";
           stop = true;
           break;
         }
 
         if (AddNode(detProp)) {
           MakeProjection();
           nNodes--;
           if (AddNode(detProp)) nNodes--;
         }
       }
       else if (nNodes > 4) {
         if (AddNode(detProp)) {
           MakeProjection();
           nNodes--;
         }
         else {
           mf::LogVerbatim("pma::Track3D") << "stop (2)";
           stop = true;
           break;
         }
 
         if (AddNode(detProp)) nNodes--;
       }
       else {
         if (AddNode(detProp)) { nNodes--; }
         else {
           mf::LogVerbatim("pma::Track3D") << "stop (1)";
           stop = true;
           break;
         }
       }
       break;
     }
 
   } while (!stop);
 
   MakeProjection();
   return GetObjFunction();
 }

int pma::Track3D::PrevHit	(	int	index,
		unsigned int	view = `geo::kZ`,
		bool	inclDisabled = `false`
	)		const

Definition at line 911 of file PmaTrack3D.cxx.

References fHits, pma::Hit3D::IsEnabled(), size(), and pma::Hit3D::View2D().

Referenced by GetRawdEdxSequence(), and pma::ProjectionMatchingAlg::guideEndpoints().

 {
   pma::Hit3D* hit = nullptr;
   if (index > (int)size()) index = (int)size();
   while (--index >= 0) // look for the prev index of hit from the view
   {
     hit = fHits[index];
     if (hit->View2D() == view) {
       if (inclDisabled)
         break;
       else if (hit->IsEnabled())
         break;
     }
   }
   return index;
 }

pma::Segment3D * pma::Track3D::PrevSegment ( pma::Node3D * vtx ) const

Definition at line 1018 of file PmaTrack3D.cxx.

References pma::SortedObjectBase::Prev().

Referenced by CleanupTails(), DisableSingleViewEnds(), MakeFastProjection(), and SwapVertices().

 {
   if (vtx->Prev()) {
     auto seg = static_cast<pma::Segment3D*>(vtx->Prev());
     if (seg->Parent() == this) return seg;
   }
   return nullptr;
 }

void pma::Track3D::push_back ( pma::Hit3D * hit )

inline

Definition at line 77 of file PmaTrack3D.h.

References pma::Hit3D::fParent, and push_back().

Referenced by AddHits(), CompleteMissingWires(), ExtendWith(), pma::ProjectionMatchingAlg::mergeTracks(), push_back(), ReassignHitsInTree(), and Split().

   {
     hit->fParent = this;
     fHits.push_back(hit);
   }

bool pma::Track3D::push_back	(	const detinfo::DetectorPropertiesData &	detProp,
		const art::Ptr< recob::Hit > &	hit
	)

Definition at line 355 of file PmaTrack3D.cxx.

References fHits, pma::Hit3D::fParent, and push_back().

 {
   for (auto const& trk_hit : fHits) {
     if (trk_hit->fHit == hit) return false;
   }
   pma::Hit3D* h3d = new pma::Hit3D(detProp, hit);
   h3d->fParent = this;
   fHits.push_back(h3d);
   return true;
 }

void pma::Track3D::ReassignHitsInTree ( pma::Track3D * plRoot = nullptr )

private

Definition at line 2105 of file PmaTrack3D.cxx.

References pma::Hit3D::Cryo(), fHits, fNodes, pma::Hit3D::GetDistToProj(), GetNearestTrkInTree(), HasTwoViews(), pma::SortedBranchBase::Next(), pma::SortedBranchBase::NextCount(), NextSegment(), pma::Segment3D::Parent(), pma::Hit3D::Point2D(), push_back(), ReassignHitsInTree(), release_at(), size(), pma::Hit3D::TPC(), and pma::Hit3D::View2D().

Referenced by ReassignHitsInTree().

 {
   bool skipFirst;
   if (trkRoot)
     skipFirst = true;
   else {
     trkRoot = this;
     skipFirst = false;
   }
 
   pma::Node3D* vtx = fNodes.front();
 
   if (skipFirst) {
     if (auto segThis = NextSegment(vtx)) vtx = static_cast<pma::Node3D*>(segThis->Next());
   }
 
   while (vtx) {
     auto segThis = NextSegment(vtx);
 
     for (size_t i = 0; i < vtx->NextCount(); i++) {
       auto seg = static_cast<pma::Segment3D*>(vtx->Next(i));
       if (seg != segThis) seg->Parent()->ReassignHitsInTree(trkRoot);
     }
 
     if (segThis)
       vtx = static_cast<pma::Node3D*>(segThis->Next());
     else
       break;
   }
 
   double d0, dmin;
   pma::Hit3D* hit = nullptr;
   pma::Track3D* nearestTrk = nullptr;
   size_t i = 0;
   while (HasTwoViews(2) && (i < size())) {
     hit = fHits[i];
     d0 = hit->GetDistToProj();
 
     nearestTrk = GetNearestTrkInTree(hit->Point2D(), hit->View2D(), hit->TPC(), hit->Cryo(), dmin);
     if ((nearestTrk != this) && (dmin < 0.5 * d0)) {
       nearestTrk->push_back(release_at(i));
       mf::LogVerbatim("pma::Track3D") << "*** hit moved to another track ***";
     }
     else
       i++;
   }
   if (!size()) { mf::LogError("pma::Track3D") << "ALL hits moved to other tracks."; }
 }

void pma::Track3D::RebuildSegments ( )

private

Definition at line 2374 of file PmaTrack3D.cxx.

References DeleteSegments(), fNodes, and fSegments.

Referenced by AddNode(), CheckEndSegment(), DisableSingleViewEnds(), InitFromRefPoints(), InsertNode(), InternalFlip(), RemoveNode(), ShiftEndsToHits(), Split(), and Track3D().

 {
   DeleteSegments();
 
   fSegments.reserve(fNodes.size() - 1);
   for (size_t i = 1; i < fNodes.size(); i++) {
     fSegments.push_back(new pma::Segment3D(this, fNodes[i - 1], fNodes[i]));
   }
 }

pma::Hit3D * pma::Track3D::release_at ( size_t index )

Definition at line 348 of file PmaTrack3D.cxx.

References fHits.

Referenced by ExtendWith(), ReassignHitsInTree(), pma::ProjectionMatchingAlg::RemoveNotEnabledHits(), and Split().

 {
   pma::Hit3D* h3d = fHits[index];
   fHits.erase(fHits.begin() + index);
   return h3d;
 }

void pma::Track3D::RemoveHits ( const std::vector< art::Ptr< recob::Hit >> & hits )

Remove hits; removes also hit->node/seg assignments.

Definition at line 412 of file PmaTrack3D.cxx.

References erase(), hits(), MakeProjection(), and n.

Referenced by pma::PMAlgTracker::reassignHits_1().

 {
   unsigned int n = 0;
   for (auto const& hit : hits) {
     if (erase(hit)) n++;
   }
   if (n) MakeProjection();
 }

bool pma::Track3D::RemoveNode ( size_t idx )

Definition at line 1413 of file PmaTrack3D.cxx.

References fNodes, pma::SortedBranchBase::NextCount(), pma::SortedObjectBase::Prev(), and RebuildSegments().

 {
   if ((fNodes.size() > 1) && (idx < fNodes.size())) {
     pma::Node3D* vtx = fNodes[idx];
     fNodes.erase(fNodes.begin() + idx);
     RebuildSegments();
 
     if (!vtx->NextCount() && !vtx->Prev()) { delete vtx; }
 
     return true;
   }
   else
     return false;
 }

std::vector<pma::Segment3D*> const& pma::Track3D::Segments ( ) const

inlinenoexcept

Definition at line 269 of file PmaTrack3D.h.

Referenced by pma::PMAlgTracker::areCoLinear(), pma::ProjectionMatchingAlg::buildMultiTPCTrack(), pma::ProjectionMatchingAlg::guideEndpoints(), pma::PMAlgVertexing::isSingleParticle(), pma::PMAlgVertexing::mergeBrokenTracks(), pma::ProjectionMatchingAlg::validate(), pma::ProjectionMatchingAlg::validate_on_adc(), and pma::ProjectionMatchingAlg::validate_on_adc_test().

269 { return fSegments; }

pma::Track3D::fSegments

std::vector< pma::Segment3D * > fSegments

Definition: PmaTrack3D.h:397

bool pma::Track3D::SelectAllHits ( void )

Definition at line 2877 of file PmaTrack3D.cxx.

References fHits.

Referenced by pma::ProjectionMatchingAlg::buildMultiTPCTrack(), pma::ProjectionMatchingAlg::buildTrack(), InitFromHits(), InitFromRefPoints(), and Optimize().

 {
   bool changed = false;
   for (auto h : fHits) {
     changed |= !(h->IsEnabled());
     h->SetEnabled(true);
   }
   return changed;
 }

bool pma::Track3D::SelectHits ( float fraction = 1.0F )

Definition at line 2826 of file PmaTrack3D.cxx.

References fHits, FirstElement(), geo::kU, geo::kV, geo::kZ, LastElement(), NHits(), and pma::Element3D::SelectAllHits().

Referenced by trkf::PMAlgTrajFitter::produce(), trkf::PMAlgTrackMaker::produce(), pma::PMAlgTracker::reassignSingleViewEnds_1(), and pma::ProjectionMatchingAlg::twoViewFraction().

 {
   if (fraction < 0.0F) fraction = 0.0F;
   if (fraction > 1.0F) fraction = 1.0F;
   if (fraction < 1.0F) std::sort(fHits.begin(), fHits.end(), pma::bTrajectory3DDistLess());
 
   size_t nHitsColl = (size_t)(fraction * NHits(geo::kZ));
   size_t nHitsInd2 = (size_t)(fraction * NHits(geo::kV));
   size_t nHitsInd1 = (size_t)(fraction * NHits(geo::kU));
   size_t coll = 0, ind2 = 0, ind1 = 0;
 
   bool b, changed = false;
   for (auto h : fHits) {
     b = h->IsEnabled();
     if (fraction < 1.0F) {
       h->SetEnabled(false);
       switch (h->View2D()) {
       case geo::kZ:
         if (coll++ < nHitsColl) h->SetEnabled(true);
         break;
       case geo::kV:
         if (ind2++ < nHitsInd2) h->SetEnabled(true);
         break;
       case geo::kU:
         if (ind1++ < nHitsInd1) h->SetEnabled(true);
         break;
       }
     }
     else
       h->SetEnabled(true);
 
     changed |= (b != h->IsEnabled());
   }
 
   if (fraction < 1.0F) {
     FirstElement()->SelectAllHits();
     LastElement()->SelectAllHits();
   }
   return changed;
 }

bool pma::Track3D::SelectRndHits	(	size_t	segmax,
		size_t	vtxmax
	)

Definition at line 2867 of file PmaTrack3D.cxx.

References fNodes, fSegments, and n.

Referenced by Optimize().

 {
   bool changed = false;
   for (auto n : fNodes)
     changed |= n->SelectRndHits(vtxmax);
   for (auto s : fSegments)
     changed |= s->SelectRndHits(segmax);
   return changed;
 }

void pma::Track3D::SetEndSegWeight ( float value )

inlinenoexcept

Definition at line 320 of file PmaTrack3D.h.

References value.

Referenced by pma::ProjectionMatchingAlg::buildSegment().

320 { fEndSegWeight = value; }

pma::Track3D::fEndSegWeight

float fEndSegWeight

Definition: PmaTrack3D.h:409

pma::Track3D::fMaxHitsPerSeg

double value

Definition: spectrum.C:18

void pma::Track3D::SetMaxHitsPerSeg ( unsigned int value )

inlinenoexcept

Definition at line 326 of file PmaTrack3D.h.

References larg4::dist(), and value.

326 { fMaxHitsPerSeg = value; }

unsigned int fMaxHitsPerSeg

Definition: PmaTrack3D.h:399

pma::Track3D::fPenaltyFactor

double value

Definition: spectrum.C:18

void pma::Track3D::SetPenalty ( float value )

inlinenoexcept

Definition at line 323 of file PmaTrack3D.h.

References value.

323 { fPenaltyFactor = value; }

float fPenaltyFactor

Definition: PmaTrack3D.h:400

double value

Definition: spectrum.C:18

void pma::Track3D::SetT0FromDx	(	const detinfo::DetectorClocksData &	clockData,
		detinfo::DetectorPropertiesData const &	detProp,
		double	dx
	)

Function to convert dx into dT0.

Definition at line 2326 of file PmaTrack3D.cxx.

References fNodes, fT0, fT0Flag, detinfo::DetectorPropertiesData::GetXTicksCoefficient(), detinfo::ElecClock::TickPeriod(), detinfo::DetectorClocksData::TPCClock(), detinfo::DetectorClocksData::TriggerOffsetTPC(), and detinfo::DetectorClocksData::TriggerTime().

Referenced by ApplyDriftShiftInTree().

 {
   auto const* geom = lar::providerFrom<geo::Geometry>();
   const geo::TPCGeo& tpcGeo = geom->TPC(geo::TPCID(fNodes.front()->Cryo(), fNodes.front()->TPC()));
 
   // GetXTicksCoefficient has a sign that we don't care about. We need to decide
   // the sign for ourselves based on the drift direction of the TPC
   double correctedSign = 0;
   if (tpcGeo.DetectDriftDirection() > 0) {
     if (dx > 0) { correctedSign = 1.0; }
     else {
       correctedSign = -1.0;
     }
   }
   else {
     if (dx > 0) { correctedSign = -1.0; }
     else {
       correctedSign = 1.0;
     }
   }
 
   // The magnitude of x in ticks is fine
   double dxInTicks = fabs(dx / detProp.GetXTicksCoefficient());
   // Now correct the sign
   dxInTicks = dxInTicks * correctedSign;
   // At this stage, we have xInTicks relative to the trigger time
   double dxInTime = dxInTicks * clockData.TPCClock().TickPeriod();
   // Reconstructed times are relative to the trigger (t=0), so this is our T0
   fT0 = dxInTime;
 
   mf::LogDebug("pma::Track3D") << dx << ", " << dxInTicks << ", " << correctedSign << ", " << fT0
                                << ", " << tpcGeo.DetectDriftDirection()
                                << " :: " << clockData.TriggerTime() << ", "
                                << clockData.TriggerOffsetTPC() << std::endl;
 
   // Mark this track as having a measured T0
   fT0Flag = true;
 }

void pma::Track3D::SetTagFlag ( ETag value )

inline

Definition at line 68 of file PmaTrack3D.h.

References Initialize().

Referenced by pma::PMAlgCosmicTagger::outOfDriftWindow().

68 { fTag = (ETag)(fTag | value); }

pma::Track3D::ETag

ETag

Definition: PmaTrack3D.h:44

pma::Track3D::fTag

ETag fTag

Definition: PmaTrack3D.h:415

double value

Definition: spectrum.C:18

bool pma::Track3D::ShiftEndsToHits ( )

Move the first/last Node3D to the first/last hit in the track; returns true if all OK, false if empty segments found.

Definition at line 2425 of file PmaTrack3D.cxx.

References back(), fNodes, front(), GetNearestElement(), pma::Element3D::Length(), MakeProjection(), pma::SortedObjectBase::Next(), pma::SortedBranchBase::NextCount(), pma::SortedObjectBase::Prev(), and RebuildSegments().

Referenced by pma::ProjectionMatchingAlg::mergeTracks(), and pma::PMAlgTracker::reassignHits_1().

 {
   pma::Element3D* el;
   pma::Node3D* vtx;
 
   if (!(fNodes.front()->Prev())) {
     el = GetNearestElement(front()->Point3D());
     vtx = dynamic_cast<pma::Node3D*>(el);
     if (vtx) {
       if (vtx == fNodes.front())
         fNodes.front()->SetPoint3D(front()->Point3D());
       else {
         mf::LogWarning("pma::Track3D") << "First hit is projected to inner node.";
         return false;
       }
     }
     else {
       pma::Segment3D* seg = dynamic_cast<pma::Segment3D*>(el);
       if (seg) {
         if (seg->Prev() == fNodes.front()) {
           double l0 = seg->Length();
           fNodes.front()->SetPoint3D(front()->Point3D());
           if ((seg->Length() < 0.2 * l0) && (fNodes.size() > 2)) {
             pma::Node3D* toRemove = fNodes[1];
             if (toRemove->NextCount() == 1) {
               mf::LogWarning("pma::Track3D")
                 << "ShiftEndsToHits(): Short start segment, node removed.";
               fNodes.erase(fNodes.begin() + 1);
 
               RebuildSegments();
               MakeProjection();
 
               delete toRemove;
             }
             else {
               mf::LogWarning("pma::Track3D") << "Branching node, not removed.";
               return false;
             }
           }
         }
         else {
           mf::LogWarning("pma::Track3D") << "First hit is projected to inner segment.";
           return false;
         }
       }
     }
   }
 
   if (!(fNodes.back()->NextCount())) {
     el = GetNearestElement(back()->Point3D());
     vtx = dynamic_cast<pma::Node3D*>(el);
     if (vtx) {
       if (vtx == fNodes.back())
         fNodes.back()->SetPoint3D(back()->Point3D());
       else {
         mf::LogWarning("pma::Track3D") << "First hit is projected to inner node.";
         return false;
       }
     }
     else {
       pma::Segment3D* seg = dynamic_cast<pma::Segment3D*>(el);
       if (seg) {
         if (seg->Next() == fNodes.back()) {
           double l0 = seg->Length();
           fNodes.back()->SetPoint3D(back()->Point3D());
           if ((seg->Length() < 0.2 * l0) && (fNodes.size() > 2)) {
             size_t idx = fNodes.size() - 2;
             pma::Node3D* toRemove = fNodes[idx];
             if (toRemove->NextCount() == 1) {
               mf::LogWarning("pma::Track3D")
                 << "ShiftEndsToHits(): Short end segment, node removed.";
               fNodes.erase(fNodes.begin() + idx);
 
               RebuildSegments();
               MakeProjection();
 
               delete toRemove;
             }
             else {
               mf::LogWarning("pma::Track3D") << "Branching node, not removed.";
               return false;
             }
           }
         }
         else {
           mf::LogWarning("pma::Track3D") << "First hit is projected to inner segment.";
           return false;
         }
       }
     }
   }
 
   return true;
 }

size_t pma::Track3D::size ( void ) const

inline

Definition at line 89 of file PmaTrack3D.h.

References n.

89 { return fHits.size(); }