LArSoft: pma::Track3D Class Reference

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

Definition: PmaTrack3D.h:322

pma::Hit3D* const& pma::Track3D::back ( ) const

inline

Definition at line 75 of file PmaTrack3D.h.

References fHits.

75 { return fHits.back(); }

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

Definition: PmaTrack3D.h:322

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

inline

Definition at line 108 of file PmaTrack3D.h.

References fNodes.

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

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

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

Definition: PmaTrack3D.h:330

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

inline

Definition at line 107 of file PmaTrack3D.h.

References fNodes.

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

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

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

Definition: PmaTrack3D.h:330

bool pma::Track3D::CanFlip ( void ) const

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

Definition at line 615 of file PmaTrack3D.cxx.

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

Referenced by AttachBackToSameTPC(), AttachTo(), AttachToSameTPC(), CanFlip(), pma::TrkCandidateColl::flipTreesByDQdx(), HasTPC(), 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 3180 of file PmaTrack3D.cxx.

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

Referenced by Optimize(), and SetMaxHitsPerSeg().

 {
         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 ( void )

Cut out tails with no hits assigned.

Definition at line 2376 of file PmaTrack3D.cxx.

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

Referenced by HasT0(), pma::PMAlgTracker::reassignHits_1(), and pma::PMAlgTracker::reassignHits_2().

 {
         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 ( void )

private

Definition at line 120 of file PmaTrack3D.cxx.

References fNodes.

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

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

size_t pma::Track3D::CompleteMissingWires ( unsigned int view )

Definition at line 1118 of file PmaTrack3D.cxx.

References 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 HasTPC(), trkf::PMAlgTrajFitter::produce(), and trkf::PMAlgTrackMaker::produce().

 {
         int dPrev, dw, w, wx, wPrev, i = NextHit(-1, view);
         //TVector2 projPoint;
 
         pma::Hit3D* hitPrev = 0;
         pma::Hit3D* hit = 0;
 
         std::vector< pma::Hit3D* > missHits;
 
         while (i < (int)size())
         {
                 hitPrev = hit;
                 hit = fHits[i];
 
                 //projPoint = pma::CmToWireDrift(
                 //      hit->Projection2D().X(), hit->Projection2D().Y(),
                 //      hit->View2D(), hit->TPC(), hit->Cryo());
 
                 if (hit->View2D() == view) // &&
                     //(projPoint.Y() >= hit->Hit2DPtr()->StartTick()-1) && // cannot use Hit2DPtr here
                     //(projPoint.Y() <= hit->Hit2DPtr()->EndTick()+1))
                 {
                         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(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(
                                                         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++)
                 {
                         //mf::LogVerbatim("pma::Track3D") << "Fill missing hit on wire " << missHits[hi]->Wire();
                         push_back(missHits[hi]);
                 }
 
                 MakeProjection();
                 SortHits();
         }
 
         return missHits.size();
 }

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

Definition at line 453 of file PmaTrack3D.cxx.

References fHits, and size().

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

 {
         std::vector< unsigned int > cryo_idxs;
         for (size_t i = 0; i < size(); i++)
         {
                 unsigned int cryo = fHits[i]->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 ( void )

private

Definition at line 2359 of file PmaTrack3D.cxx.

References fSegments.

Referenced by ExtendWith(), RebuildSegments(), and SetMaxHitsPerSeg().

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

unsigned int pma::Track3D::DisableSingleViewEnds ( void )

Definition at line 2711 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 AddNode(), pma::PMAlgTracker::reassignSingleViewEnds_1(), pma::PMAlgTracker::reassignSingleViewEnds_2(), and pma::ProjectionMatchingAlg::twoViewFraction().

 {
         SortHits();
 
         unsigned int nDisabled = 0;
 
         int hasHits[4];
 
         pma::Hit3D* nextHit = 0;
         int hitIndex = -1;
 
         bool rebuild = false, stop = false;
         int nViews = 0;
         hasHits[0] = hasHits[1] = hasHits[2] = hasHits[3] = 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[0] = hasHits[1] = hasHits[2] = hasHits[3] = 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 2535 of file PmaTrack3D.cxx.

References fNodes, fSegments, and s.

Referenced by GetNearestTrkInTree(), Length(), 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 2562 of file PmaTrack3D.cxx.

References fSegments.

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

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

Definition at line 1093 of file PmaTrack3D.cxx.

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

Referenced by CompleteMissingWires(), and HasTPC().

 {
         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(
                         fNodes[i]->Projection2D(view).X(), fNodes[i]->Projection2D(view).Y(),
                         view, fNodes[i]->TPC(), fNodes[i]->Cryo());
                 TVector2 p1 = pma::CmToWireDrift(
                         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 359 of file PmaTrack3D.cxx.

References fHits, and size().

Referenced by push_back(), and 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 1684 of file PmaTrack3D.cxx.

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

Referenced by AddNode().

 {
     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 ( void ) const

inline

Definition at line 233 of file PmaTrack3D.h.

References fNodes.

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

233 { return fNodes.front(); }

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

Definition: PmaTrack3D.h:330

bool pma::Track3D::Flip ( 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 499 of file PmaTrack3D.cxx.

References Flip(), fNodes, index_of(), InternalFlip(), n, NextSegment(), pma::Segment3D::Parent(), pma::SortedObjectBase::Prev(), s, 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(idx, false); // u is in front of t
                     if (u)
                     {
                         allTracks.push_back(u);
                         if (u->Flip(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(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 ( void )

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

Definition at line 596 of file PmaTrack3D.cxx.

References InternalFlip().

Referenced by AttachTo(), AutoFlip(), and HasTPC().

 {
         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* & pma::Track3D::front ( )

inline

Definition at line 72 of file PmaTrack3D.h.

References fHits.

72 { return fHits.front(); }

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

Definition: PmaTrack3D.h:322

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

inline

Definition at line 73 of file PmaTrack3D.h.

References fHits.

73 { return fHits.front(); }

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

Definition: PmaTrack3D.h:322

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

inline

Definition at line 105 of file PmaTrack3D.h.

References fNodes.

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

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

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

Definition: PmaTrack3D.h:330

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

inline

Definition at line 104 of file PmaTrack3D.h.

References fNodes.

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

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

pma::Track3D::fEndSegWeight

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

Definition: PmaTrack3D.h:330

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

Definition at line 1727 of file PmaTrack3D.cxx.

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

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

 {
         for (auto trk : branches) if (trk == this)
         {
                 //std::cout << "HAS LOOP" << std::endl;
                 throw cet::exception("pma::Track3D") << "Track tree has loop.";
                 //mf::LogError("pma::Track3D") << "Track tree has loop.";
                 //return false;
         }
 
         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 373 of file PmaTrack3D.cxx.

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

Referenced by pma::convertFrom(), and Length().

 {
     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 ( void ) const

inline

Definition at line 270 of file PmaTrack3D.h.

References fEndSegWeight.

270 { return fEndSegWeight; }

float fEndSegWeight

Definition: PmaTrack3D.h:343

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

inline

Definition at line 276 of file PmaTrack3D.h.

References fMaxHitsPerSeg.

276 { return fMaxHitsPerSeg; }

pma::Track3D::fMaxHitsPerSeg

unsigned int fMaxHitsPerSeg

Definition: PmaTrack3D.h:333

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

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

Definition at line 1774 of file PmaTrack3D.cxx.

References fNodes, fSegments, n, and s.

Referenced by AddRefPoint(), 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 2573 of file PmaTrack3D.cxx.

References 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 = 0;
         double dist, min_dist = 1.0e9;
         for (size_t i = v0; i < v1; i++)
                 //if ((tpc == -1) || (fNodes[i]->TPC() == tpc))
                 if (fNodes[i]->TPC() == tpc)
         {
                 dist = fNodes[i]->GetDistance2To(p2d, view);
                 if (dist < min_dist)
                 {
                         min_dist = dist; pe_min = fNodes[i];
                 }
         }
         for (size_t i = 0; i < fSegments.size(); i++)
                 //if ((tpc == -1) || (fSegments[i]->TPC() == tpc))
                 if (fSegments[i]->TPC() == tpc)
         {
                 if (fSegments[i]->TPC() < 0) continue; // segment between TPC's
 
                 dist = fSegments[i]->GetDistance2To(p2d, view);
                 if (dist < min_dist)
                 {
                         min_dist = dist; pe_min = fSegments[i];
                 }
         }
         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 2615 of file PmaTrack3D.cxx.

References 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 1990 of file PmaTrack3D.cxx.

References d, Dist2(), fNodes, GetNearestTrkInTree(), pma::SortedObjectBase::Next(), pma::SortedBranchBase::Next(), pma::SortedBranchBase::NextCount(), NextSegment(), and pma::Segment3D::Parent().

Referenced by GetNearestTrkInTree(), ReassignHitsInTree(), and SetMaxHitsPerSeg().

 {
         pma::Node3D* vtx = fNodes.front();
         pma::Segment3D* segThis = 0;
         pma::Segment3D* seg = 0;
 
         if (skipFirst)
         {
                 segThis = NextSegment(vtx);
                 if (segThis) vtx = static_cast< pma::Node3D* >(segThis->Next());
         }
 
         pma::Track3D* result = this;
         dist = sqrt( Dist2(p3d_cm) );
 
         pma::Track3D* candidate = 0;
         while (vtx)
         {
                 segThis = NextSegment(vtx);
 
                 double d;
                 for (size_t i = 0; i < vtx->NextCount(); i++)
                 {
                         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 2181 of file PmaTrack3D.cxx.

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

Referenced by AddRefPoint(), GetObjFnInTree(), and TuneFullTree().

 {
         pma::Node3D* vtx = fNodes.front();
         pma::Segment3D* segThis = 0;
         pma::Segment3D* seg = 0;
 
         if (skipFirst)
         {
                 segThis = NextSegment(vtx);
                 if (segThis) vtx = static_cast< pma::Node3D* >(segThis->Next());
         }
 
         double g = 0.0;
         while (vtx)
         {
                 segThis = NextSegment(vtx);
 
                 for (size_t i = 0; i < vtx->NextCount(); i++)
                 {
                         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 1793 of file PmaTrack3D.cxx.

References fEndSegWeight, fNodes, and fPenaltyValue.

Referenced by AddRefPoint(), 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 ( void ) const

inline

Definition at line 273 of file PmaTrack3D.h.

References fPenaltyFactor.

273 { return fPenaltyFactor; }

pma::Track3D::fPenaltyFactor

float fPenaltyFactor

Definition: PmaTrack3D.h:334

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 990 of file PmaTrack3D.cxx.

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

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

 {
         dedx.clear();
 
         if (!size()) return 0.0;
 
         size_t step = 1;
 
         pma::Hit3D* hit = 0;
 
         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 ( void )

Definition at line 1712 of file PmaTrack3D.cxx.

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

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

 {
         pma::Track3D* trk = 0;
 
         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 ( void ) const

inline

Definition at line 215 of file PmaTrack3D.h.

References fT0.

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

215 { return fT0; }

pma::Track3D::fT0

double fT0

Definition: PmaTrack3D.h:346

ETag pma::Track3D::GetTag ( void ) const

inline

Definition at line 53 of file PmaTrack3D.h.

References fTag.

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

53 { return fTag; }

ETag fTag

Definition: PmaTrack3D.h:349

bool pma::Track3D::GetUnconstrainedProj3D	(	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 2638 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 SetMaxHitsPerSeg(), and TestHits().

 {
         TVector2 p2d = pma::WireDriftToCm(
                 hit->WireID().Wire, hit->PeakTime(),
                 hit->WireID().Plane, hit->WireID().TPC, hit->WireID().Cryostat);
 
         pma::Segment3D* seg = 0;
         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 1767 of file PmaTrack3D.cxx.

References fAssignedPoints.

Referenced by AddRefPoint().

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

bool pma::Track3D::HasT0 ( void ) const

inline

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

Definition at line 218 of file PmaTrack3D.h.

References CleanupTails(), fT0Flag, and ShiftEndsToHits().

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

218 {return fT0Flag; }

pma::Track3D::fT0Flag

bool fT0Flag

Definition: PmaTrack3D.h:347

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

inline

Definition at line 54 of file PmaTrack3D.h.

References fTag.

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

54 { return (fTag & value); }

ETag fTag

Definition: PmaTrack3D.h:349

std::string value(boost::any const &)

Definition: printing_helpers.cc:97

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

inline

Definition at line 110 of file PmaTrack3D.h.

References AutoFlip(), CanFlip(), CompleteMissingWires(), dir, DriftsOfWireIntersection(), Flip(), fNodes, GetRawdEdxSequence(), HitDxByView(), hits(), geo::kZ, NextHit(), PrevHit(), TestHits(), TestHitsMse(), pma::Element3D::TPC(), lar::dump::vector(), and WireDriftRange().

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 428 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(), Length(), 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 952 of file PmaTrack3D.cxx.

References kBackward, kForward, and size().

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

 {
         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 893 of file PmaTrack3D.cxx.

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

 {
         pma::Hit3D* nexthit = 0;
         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 333 of file PmaTrack3D.cxx.

References fHits, and size().

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

 {
         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 326 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	(	int	tpc,
		int	cryo,
		float	initEndSegW = `0.05F`
	)

private

Definition at line 126 of file PmaTrack3D.cxx.

References AddNode(), ClearNodes(), pma::Dist2(), fEndSegWeight, fHits, fNodes, front(), MakeProjection(), Optimize(), pma::Hit3D::PeakTime(), SelectAllHits(), size(), UpdateHitsRadius(), pma::Hit3D::View2D(), pma::Hit3D::Wire(), x, y, and z.

Referenced by Initialize(), and SetMaxHitsPerSeg().

 {
         auto const* detprop = lar::providerFrom<detinfo::DetectorPropertiesService>();
         art::ServiceHandle<geo::Geometry> geom;
 
         float wtmp = fEndSegWeight;
         fEndSegWeight = initEndSegW;
 
         // endpoints for the first combination:
         TVector3 v3d_1(0., 0., 0.), v3d_2(0., 0., 0.);
         double x, y, z;
 
         pma::Hit3D* hit0_a = front();
         pma::Hit3D* hit0_b = 0;
 
         pma::Hit3D* hit1_a = front();
         pma::Hit3D* hit1_b = 0;
 
         pma::Hit3D* hit = 0;
         float minX = detprop->ConvertTicksToX(hit0_a->PeakTime(), hit0_a->View2D(), tpc, cryo);
         float maxX = detprop->ConvertTicksToX(hit1_a->PeakTime(), hit1_a->View2D(), tpc, cryo);
         for (size_t i = 1; i < size(); i++)
         {
                 hit = fHits[i];
                 x = detprop->ConvertTicksToX(hit->PeakTime(), hit->View2D(), tpc, cryo);
                 if (x < minX) { minX = x; hit0_a = hit; }
                 if (x > maxX) { maxX = x; hit1_a = hit; }
         }
 
         float diff, minDiff0 = 5000, minDiff1 = 5000;
         for (size_t i = 0; i < size(); i++)
         {
                 hit = fHits[i];
                 x = detprop->ConvertTicksToX(hit->PeakTime(), hit->View2D(), tpc, cryo);
                 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)
         {
                 x = 0.5 * (
                         detprop->ConvertTicksToX(hit0_a->PeakTime(), hit0_a->View2D(), tpc, cryo) +
                         detprop->ConvertTicksToX(hit0_b->PeakTime(), hit0_b->View2D(), tpc, cryo));
                 geom->IntersectionPoint(hit0_a->Wire(), hit0_b->Wire(),
                         hit0_a->View2D(), hit0_b->View2D(), cryo, tpc, y, z);
                 v3d_1.SetXYZ(x, y, z);
 
                 x = 0.5 * (
                         detprop->ConvertTicksToX(hit1_a->PeakTime(), hit1_a->View2D(), tpc, cryo) +
                         detprop->ConvertTicksToX(hit1_b->PeakTime(), hit1_b->View2D(), tpc, cryo));
                 geom->IntersectionPoint(hit1_a->Wire(), hit1_b->Wire(),
                         hit1_a->View2D(), hit1_b->View2D(), cryo, tpc, y, z);
                 v3d_2.SetXYZ(x, y, z);
 
                 ClearNodes();
                 AddNode(v3d_1, tpc, cryo);
                 AddNode(v3d_2, tpc, cryo);
 
                 MakeProjection();
                 UpdateHitsRadius();
                 Optimize(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	(	int	tpc,
		int	cryo
	)

private

Definition at line 299 of file PmaTrack3D.cxx.

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

Referenced by Initialize(), and SetMaxHitsPerSeg().

 {
         art::ServiceHandle<geo::Geometry> geom;
 
         const auto& tpcGeo = geom->TPC(tpc, cryo);
 
         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(v3d_1, tpc, cryo);
         AddNode(v3d_2, tpc, cryo);
 
         MakeProjection();
         UpdateHitsRadius();
 
         Optimize(0, 0.01F);
 }

bool pma::Track3D::InitFromRefPoints	(	int	tpc,
		int	cryo
	)

private

Definition at line 215 of file PmaTrack3D.cxx.

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

Referenced by Initialize(), and SetMaxHitsPerSeg().

 {
         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(*(fAssignedPoints[i]), tpc, cryo);
         }
 
         RebuildSegments();
         MakeProjection();
 
         if (size()) UpdateHitsRadius();
 
         Optimize(0, 0.01F, false, true, 100);
         SelectAllHits();
 
         return true;
 }

bool pma::Track3D::Initialize ( float initEndSegW = 0.05F )

Definition at line 84 of file PmaTrack3D.cxx.

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

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

 {
         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(tpc, cryo)) mf::LogVerbatim("pma::Track3D") << "Track initialized with 3D reference points.";
         else
         {
                 if (InitFromHits(tpc, cryo, initEndSegW)) mf::LogVerbatim("pma::Track3D") << "Track initialized with hit positions.";
                 else { InitFromMiddle(tpc, cryo); mf::LogVerbatim("pma::Track3D") << "Track initialized in the module center."; }
         }
 
         UpdateHitsRadius();
         return true;
 }

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

Definition at line 1342 of file PmaTrack3D.cxx.

References fNodes, and RebuildSegments().

Referenced by AddNode(), and pma::VtxCandidate::JoinTracks().

 {
         //std::cout << " insert after " << at_idx << " in " << fNodes.size() << std::endl;
         pma::Node3D* vtx = new pma::Node3D(p3d, tpc, cryo, false, fNodes[at_idx]->GetDriftShift());
         fNodes.insert(fNodes.begin() + at_idx, vtx);
         //std::cout << " inserted " << std::endl;
 
         if (fNodes.size() > 1) RebuildSegments();
         //std::cout << " rebuild ok " << std::endl;
 }

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

private

Definition at line 565 of file PmaTrack3D.cxx.

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

Referenced by Flip(), InternalFlip(), and SetMaxHitsPerSeg().

 {
         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 1752 of file PmaTrack3D.cxx.

References GetBranches().

Referenced by AddNode(), 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 ( void ) const

inline

Definition at line 234 of file PmaTrack3D.h.

References AddNode(), and fNodes.

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

234 { 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:330

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

inline

Definition at line 81 of file PmaTrack3D.h.

References AddHits(), Cryos(), Dist2(), GetDirection3D(), HasTwoViews(), hits(), geo::kUnknown, Length(), NEnabledHits(), NHits(), RemoveHits(), size(), TPCs(), 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().

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

pma::Track3D::Length

double Length(size_t step=1) const

Definition: PmaTrack3D.h:81

pma::Track3D::size

size_t size() const

Definition: PmaTrack3D.h:76

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

Definition at line 831 of file PmaTrack3D.cxx.

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

 {
         if (size() < 2) return 0.0;
 
         if (start > stop)
         {
                 size_t tmp = stop; stop = start; start = tmp;
         }
         if (start >= size() - 1) return 0.0;
         if (stop >= size()) stop = size() - 1;
 
         double result = 0.0;
         pma::Hit3D *h1 = 0, *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 ( void )

private

Definition at line 2950 of file PmaTrack3D.cxx.

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

Referenced by Optimize(), and SetMaxHitsPerSeg().

 {
         std::vector< std::pair< pma::Hit3D*, pma::Element3D* > > assignments;
         assignments.reserve(fHits.size());
 
         for (auto hi : fHits)
         {
                 pma::Element3D* pe = 0;
 
                 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 d2, min_d2 = s->GetDistance2To(hi->Point2D(), hi->View2D());
                                 int tpc = hi->TPC();
 
                                 pma::Node3D* nnext = static_cast< pma::Node3D* >(s->Next());
                                 if (nnext->TPC() == tpc)
                                 {
                                         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))
                                         {
                                                 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)
                                                 {
                                                         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)
                                 {
                                         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))
                                         {
                                                 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)
                                                 {
                                                         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 ( void )

Definition at line 2912 of file PmaTrack3D.cxx.

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

Referenced by AddNode(), 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 = 0;
 
         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 2123 of file PmaTrack3D.cxx.

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

Referenced by AddRefPoint(), MakeProjectionInTree(), and TuneFullTree().

 {
         pma::Node3D* vtx = fNodes.front();
         pma::Segment3D* segThis = 0;
         pma::Segment3D* seg = 0;
 
         if (skipFirst)
         {
                 segThis = NextSegment(vtx);
                 if (segThis) vtx = static_cast< pma::Node3D* >(segThis->Next());
         }
 
         while (vtx)
         {
                 segThis = NextSegment(vtx);
 
                 for (size_t i = 0; i < vtx->NextCount(); i++)
                 {
                         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 416 of file PmaTrack3D.cxx.

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

Referenced by Length(), and pma::ProjectionMatchingAlg::TestTrk().

 {
         unsigned int n = 0;
         for (size_t i = 0; i < size(); i++)
         {
                 pma::Hit3D* hit = fHits[i];
                 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 861 of file PmaTrack3D.cxx.

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

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

 {
         pma::Hit3D* hit = 0;
         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 966 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(), Segments(), pma::TrkCandidateColl::setTreeId(), pma::TrkCandidateColl::setTreeOriginAtFront(), SortHits(), SortHitsInTree(), SwapVertices(), TuneSinglePass(), and UpdateParamsInTree().

 {
         pma::Segment3D* seg = 0;
         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 406 of file PmaTrack3D.cxx.

References fHits, and n.

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

 {
         unsigned int n = 0;
         for (size_t i = 0; i < fHits.size(); i++)
         {
                 if (fHits[i]->View2D() == view) n++;
         }
         return n;
 }

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

inline

Definition at line 232 of file PmaTrack3D.h.

References fNodes.

232 { return fNodes; }

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

Definition: PmaTrack3D.h:330

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

inline

Definition at line 70 of file PmaTrack3D.h.

References fHits.

70 { return fHits[index]; }

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

Definition: PmaTrack3D.h:322

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

inline

Definition at line 71 of file PmaTrack3D.h.

References fHits.

71 { return fHits[index]; }

Referenced by AddRefPoint(), 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:322

double pma::Track3D::Optimize	(	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 1804 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;
 
         //mf::LogVerbatim("pma::Track3D") << "objective function at opt start: " << 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();
 
                                 //mf::LogVerbatim("pma::Track3D") << "obj fn: " << g0;
                                 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()) stop = true;
                                 }
                                 break;
 
                         default: // grow and optimize until fixed number of vertices is added
                                 if (nNodes > 12)
                                 {
                                         if (AddNode()) { MakeProjection(); nNodes--; }
                                         else { mf::LogVerbatim("pma::Track3D") << "stop (3)"; stop = true; break; }
 
                                         if (AddNode())
                                         {
                                                 MakeProjection(); nNodes--;
                                                 if (AddNode()) nNodes--;
                                         }
                                 }
                                 else if (nNodes > 4)
                                 {
                                         if (AddNode()) { MakeProjection(); nNodes--; }
                                         else { mf::LogVerbatim("pma::Track3D") << "stop (2)"; stop = true; break; }
 
                                         if (AddNode()) nNodes--;
                                 }
                                 else
                                 {
                                         if (AddNode()) { nNodes--; }
                                         else { mf::LogVerbatim("pma::Track3D") << "stop (1)"; stop = true; break; }
                                 }
                                 break;
                 }
 
         } while (!stop);
         //mf::LogVerbatim("pma::Track3D") << "Done (optimized segments: " << fSegments.size() << ").";
 
         MakeProjection();
         return GetObjFunction();
 }

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

Definition at line 877 of file PmaTrack3D.cxx.

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

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

 {
         pma::Hit3D* hit = 0;
         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 980 of file PmaTrack3D.cxx.

References pma::Segment3D::Parent(), and pma::SortedObjectBase::Prev().

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

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

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

inline

Definition at line 66 of file PmaTrack3D.h.

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

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

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

pma::Hit3D::fParent

pma::Track3D * fParent

Definition: PmaHit3D.h:106

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

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

Definition: PmaTrack3D.h:322

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

Definition at line 347 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(hit);
         h3d->fParent = this;
         fHits.push_back(h3d);
         return true;
 }

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

private

Definition at line 2070 of file PmaTrack3D.cxx.

References pma::Hit3D::Cryo(), fHits, fNodes, pma::Hit3D::GetDistToProj(), GetNearestTrkInTree(), HasTwoViews(), pma::SortedObjectBase::Next(), 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(), and SetMaxHitsPerSeg().

 {
         bool skipFirst;
         if (trkRoot) skipFirst = true;
         else { trkRoot = this; skipFirst = false; }
 
         pma::Node3D* vtx = fNodes.front();
         pma::Segment3D* segThis = 0;
         pma::Segment3D* seg = 0;
 
         if (skipFirst)
         {
                 segThis = NextSegment(vtx);
                 if (segThis) vtx = static_cast< pma::Node3D* >(segThis->Next());
         }
 
         while (vtx)
         {
                 segThis = NextSegment(vtx);
 
                 for (size_t i = 0; i < vtx->NextCount(); i++)
                 {
                         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 = 0;
         pma::Track3D* nearestTrk = 0;
         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 ( void )

private

Definition at line 2365 of file PmaTrack3D.cxx.

References DeleteSegments(), fNodes, and fSegments.

Referenced by AddNode(), CheckEndSegment(), DisableSingleViewEnds(), InitFromRefPoints(), InsertNode(), InternalFlip(), RemoveNode(), SetMaxHitsPerSeg(), 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 340 of file PmaTrack3D.cxx.

References fHits.

Referenced by ExtendWith(), ReassignHitsInTree(), pma::ProjectionMatchingAlg::RemoveNotEnabledHits(), SetTag(), 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 399 of file PmaTrack3D.cxx.

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

Referenced by Length(), pma::PMAlgTracker::reassignHits_1(), and pma::PMAlgTracker::reassignHits_2().

 {
         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 1355 of file PmaTrack3D.cxx.

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

Referenced by AddNode().

 {
         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 ( void ) const

inline

Definition at line 227 of file PmaTrack3D.h.

References fSegments, NextSegment(), and PrevSegment().

227 { return fSegments; }

pma::Track3D::fSegments

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

Definition: PmaTrack3D.h:331

bool pma::Track3D::SelectAllHits ( void )

Definition at line 2901 of file PmaTrack3D.cxx.

References fHits.

Referenced by AddNode(), 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 2855 of file PmaTrack3D.cxx.

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

Referenced by AddNode(), trkf::PMAlgTrajFitter::produce(), trkf::PMAlgTrackMaker::produce(), pma::PMAlgTracker::reassignSingleViewEnds_1(), pma::PMAlgTracker::reassignSingleViewEnds_2(), 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 2893 of file PmaTrack3D.cxx.

References fNodes, fSegments, n, and s.

Referenced by AddNode(), and 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 )

inline

Definition at line 271 of file PmaTrack3D.h.

References fEndSegWeight, and fhicl::detail::atom::value().

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

271 { fEndSegWeight = value; }

pma::Track3D::fEndSegWeight

float fEndSegWeight

Definition: PmaTrack3D.h:343

pma::Track3D::fMaxHitsPerSeg

std::string value(boost::any const &)

Definition: printing_helpers.cc:97

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

inline

Definition at line 277 of file PmaTrack3D.h.

References AttachBackToOtherTPC(), AttachBackToSameTPC(), AttachToOtherTPC(), AttachToSameTPC(), AverageDist2(), CheckEndSegment(), ClearNodes(), DeleteSegments(), fMaxHitsPerSeg, GetNearestTrkInTree(), GetUnconstrainedProj3D(), HitDxByView(), InitFromHits(), InitFromMiddle(), InitFromRefPoints(), InternalFlip(), MakeFastProjection(), ReassignHitsInTree(), RebuildSegments(), SwapVertices(), UpdateHitsRadius(), UpdateParams(), and fhicl::detail::atom::value().

277 { fMaxHitsPerSeg = value; }

unsigned int fMaxHitsPerSeg

Definition: PmaTrack3D.h:333

pma::Track3D::fPenaltyFactor

std::string value(boost::any const &)

Definition: printing_helpers.cc:97

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

inline

Definition at line 274 of file PmaTrack3D.h.

References fPenaltyFactor, and fhicl::detail::atom::value().

274 { fPenaltyFactor = value; }

float fPenaltyFactor

Definition: PmaTrack3D.h:334

std::string value(boost::any const &)

Definition: printing_helpers.cc:97

void pma::Track3D::SetT0FromDx ( double dx )

Function to convert dx into dT0.

Definition at line 2309 of file PmaTrack3D.cxx.

References fNodes, fT0, and fT0Flag.

Referenced by AddRefPoint(), and ApplyDriftShiftInTree().

                                      {
 
   // Get all of the services we need
   auto const* detprop = lar::providerFrom<detinfo::DetectorPropertiesService>();
   auto const* detclock = lar::providerFrom<detinfo::DetectorClocksService>();
   auto const* geom = lar::providerFrom<geo::Geometry>();
   const geo::TPCGeo &tpcGeo = geom->TPC(fNodes.front()->TPC(), fNodes.front()->Cryo());
   
   // 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 * detclock->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() << " :: " 
                                  << detclock->TriggerTime() << ", " << detclock->TriggerOffsetTPC() << std::endl;
 
   // Leigh test
 //  mf::LogDebug("pma::Track3D") << " Check x position for T = Trigger Offset " << detprop->ConvertTicksToX(detprop->TriggerOffset(),2,tpcGeo.ID().TPC,tpcGeo.ID().Cryostat) << std::endl;
 //  float apaTime = detprop->GetXTicksOffset(2,tpcGeo.ID().TPC,tpcGeo.ID().Cryostat) - detprop->TriggerOffset();
 //  mf::LogDebug("pma::Track3D") << " Check x position for T = Trigger Offset + DriftTime " << detprop->ConvertTicksToX(detprop->TriggerOffset() + apaTime,2,tpcGeo.ID().TPC,tpcGeo.ID().Cryostat) << std::endl;
 
   // Mark this track as having a measured T0
   fT0Flag = true;
 }

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

inline

Definition at line 56 of file PmaTrack3D.h.

References fTag, Initialize(), release_at(), Track3D(), fhicl::detail::atom::value(), and ~Track3D().

56 { fTag = value; }

ETag fTag

Definition: PmaTrack3D.h:349

std::string value(boost::any const &)

Definition: printing_helpers.cc:97

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

inline

Definition at line 55 of file PmaTrack3D.h.

References fTag.

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

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

pma::Track3D::ETag

ETag

Definition: PmaTrack3D.h:34

ETag fTag

Definition: PmaTrack3D.h:349

std::string value(boost::any const &)

Definition: printing_helpers.cc:97

bool pma::Track3D::ShiftEndsToHits ( void )

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 2422 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 HasT0(), pma::ProjectionMatchingAlg::mergeTracks(), pma::PMAlgTracker::reassignHits_1(), and pma::PMAlgTracker::reassignHits_2().

 {
         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.";
                                                         //std::cout << "ShiftEndsToHits(): Short start segment, node removed." << std::endl;
                                                         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.";
                                                         //std::cout << "ShiftEndsToHits(): Short end segment, node removed." << std::endl;
                                                         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 76 of file PmaTrack3D.h.

References fHits, index_of(), and n.

76 { return fHits.size(); }