pma::PMAlgVertexing Class Reference

#include "PMAlgVertexing.h"

Classes
struct	Config

Public Member Functions
	PMAlgVertexing (const Config &config)
void	reconfigure (const Config &config)
	PMAlgVertexing (const fhicl::ParameterSet &pset)
virtual	~PMAlgVertexing (void)
void	reset (void)
size_t	run (pma::TrkCandidateColl &trk_input)
size_t	run (pma::TrkCandidateColl &trk_input, const std::vector< TVector3 > &vtx_input)
std::vector< std::pair< TVector3, std::vector< std::pair< size_t, bool > > > >	getVertices (const pma::TrkCandidateColl &tracks, bool onlyBranching=false) const
std::vector< std::pair< TVector3, size_t > >	getKinks (const pma::TrkCandidateColl &tracks) const

Private Member Functions
bool	has (const std::vector< size_t > &v, size_t idx) const
std::vector< pma::VtxCandidate >	firstPassCandidates (void)
std::vector< pma::VtxCandidate >	secondPassCandidates (void)
size_t	makeVertices (std::vector< pma::VtxCandidate > &candidates)
std::vector< std::pair< double, double > >	getdQdx (const pma::Track3D &trk) const
	Get dQ/dx sequence to detect various features. More...
double	convolute (size_t idx, size_t len, double *adc, double const *shape) const
	Get convolution value. More...
bool	isSingleParticle (pma::Track3D *trk1, pma::Track3D *trk2) const
	Check if colinear in 3D and dQ/dx with no significant step. More...
void	mergeBrokenTracks (pma::TrkCandidateColl &trk_input) const
void	splitMergedTracks (pma::TrkCandidateColl &trk_input) const
	Split track and add vertex and reoptimize when dQ/dx step detected. More...
void	findKinksOnTracks (pma::TrkCandidateColl &trk_input) const
	Remove penalty on the angle if kink detected and reopt track. More...
void	cleanTracks (void)
void	sortTracks (const pma::TrkCandidateColl &trk_input)
void	collectTracks (pma::TrkCandidateColl &result)

Private Attributes
pma::TrkCandidateColl	fOutTracks
pma::TrkCandidateColl	fShortTracks
pma::TrkCandidateColl	fEmTracks
pma::TrkCandidateColl	fExcludedTracks
double	fMinTrackLength
bool	fFindKinks
double	fKinkMinDeg
double	fKinkMinStd

Detailed Description

Definition at line 29 of file PMAlgVertexing.h.

Constructor & Destructor Documentation

pma::PMAlgVertexing::PMAlgVertexing

(

const Config &

config

)

Definition at line 14 of file PMAlgVertexing.cxx.

References reconfigure().

{
        this->reconfigure(config); 
}

pma::PMAlgVertexing::PMAlgVertexing ( const fhicl::ParameterSet &  pset )

inline

Definition at line 61 of file PMAlgVertexing.h.

References ~PMAlgVertexing().

                                                      :
                PMAlgVertexing(fhicl::Table<Config>(pset, {})())
        {}

pma::PMAlgVertexing::~PMAlgVertexing ( void  )

virtual

Definition at line 29 of file PMAlgVertexing.cxx.

References cleanTracks().

Referenced by PMAlgVertexing().

{
        cleanTracks();
}

Member Function Documentation

void pma::PMAlgVertexing::cleanTracks ( void  )

private

Definition at line 35 of file PMAlgVertexing.cxx.

References pma::TrkCandidateColl::clear(), fEmTracks, fExcludedTracks, fOutTracks, fShortTracks, and pma::TrkCandidateColl::tracks().

Referenced by reset(), sortTracks(), and ~PMAlgVertexing().

{
        for (auto & t : fOutTracks.tracks()) t.DeleteTrack();
        fOutTracks.clear();

        for (auto & t : fShortTracks.tracks()) t.DeleteTrack();
        fShortTracks.clear();

        for (auto & t : fEmTracks.tracks()) t.DeleteTrack();
        fEmTracks.clear();

        for (auto & t : fExcludedTracks.tracks()) t.DeleteTrack();
        fExcludedTracks.clear();
}

void pma::PMAlgVertexing::collectTracks ( pma::TrkCandidateColl &  result )

private

Definition at line 51 of file PMAlgVertexing.cxx.

References pma::TrkCandidateColl::clear(), fEmTracks, fExcludedTracks, fOutTracks, fShortTracks, pma::TrkCandidateColl::push_back(), pma::TrkCandidateColl::size(), and pma::TrkCandidateColl::tracks().

Referenced by run().

{
        mf::LogVerbatim("pma::PMAlgVertexing") << "clean input: " << result.size() << std::endl;
        for (auto & t : result.tracks()) t.DeleteTrack();
        result.clear();

        mf::LogVerbatim("pma::PMAlgVertexing") << "fill input from out: " << fOutTracks.size() << std::endl;
        for (auto const & t : fOutTracks.tracks()) result.push_back(t);
        fOutTracks.clear();

        mf::LogVerbatim("pma::PMAlgVertexing") << "fill input from short: " << fShortTracks.size() << std::endl;
        for (auto const & t : fShortTracks.tracks()) result.push_back(t);
        fShortTracks.clear();

        mf::LogVerbatim("pma::PMAlgVertexing") << "fill input from em: " << fEmTracks.size() << std::endl;
        for (auto const & t : fEmTracks.tracks()) result.push_back(t);
        fEmTracks.clear();

        mf::LogVerbatim("pma::PMAlgVertexing") << "copy back excluded tracks: " << fExcludedTracks.size() << std::endl;
        for (auto const & t : fExcludedTracks.tracks()) result.push_back(t);
        fExcludedTracks.clear();
}

double pma::PMAlgVertexing::convolute ( size_t  idx, size_t  len, double *  adc, double const *  shape  ) const

private

Get convolution value.

Definition at line 379 of file PMAlgVertexing.cxx.

References pmtana::mean().

Referenced by has(), and isSingleParticle().

{
        size_t half = len >> 1;
        double v, mean = 0.0, stdev = 0.0;
        for (size_t i = 0; i < len; i++)
        {
                v = adc[idx - half + i];
                mean += v; stdev += v * v;
        }
        mean /= len;
        stdev /= len;
        stdev -= mean;

        double sum = 0.0;
        for (size_t i = 0; i < len; i++)
                sum += (adc[idx - half + i] - mean) * shape[i];

        return sum / sqrt(stdev);
}

void pma::PMAlgVertexing::findKinksOnTracks ( pma::TrkCandidateColl &  trk_input ) const

private

Remove penalty on the angle if kink detected and reopt track.

Definition at line 523 of file PMAlgVertexing.cxx.

References e, fKinkMinDeg, fKinkMinStd, has(), pmtana::mean(), min, n, pma::Track3D::Nodes(), pma::Track3D::Optimize(), and pma::TrkCandidateColl::size().

Referenced by has(), and run().

{
        if (trk_input.size() < 1) return;

        mf::LogVerbatim("pma::PMAlgVertexing") << "Find kinks on tracks, reopt with no penalty on angle where kinks.";
        for (size_t t = 0; t < trk_input.size(); ++t)
        {
                pma::Track3D* trk = trk_input[t].Track();
                if (trk->Nodes().size() < 5) continue;

                trk->Optimize(0, 1.0e-5, false);

                std::vector<size_t> tested_nodes;
                bool kinkFound = true;
                while (kinkFound)
                {
                        int kinkIdx = -1, nnodes = 0;
                        double mean = 0.0, stdev = 0.0, min = 1.0, max_a = 0.0;
                        for (size_t n = 1; n < trk->Nodes().size() - 1; ++n)
                        {
                                auto const & node = *(trk->Nodes()[n]);

                                if (node.IsVertex() || node.IsTPCEdge()) continue;
                                nnodes++;

                                double c = -node.SegmentCosTransverse();
                                double a = 180.0 * (1 - std::acos(node.SegmentCosTransverse()) / TMath::Pi());
                                mean += c; stdev += c * c;
                                if ((c < min) && !has(tested_nodes, n))
                                {
                                        if ((n > 1) && (n < trk->Nodes().size() - 2)) kinkIdx = n;
                                        min = c; max_a = a;
                                }
                        }

                        kinkFound = false;
                        if ((nnodes > 2) && (kinkIdx > 0) && (max_a > fKinkMinDeg))
                        {
                                mean /= nnodes; stdev /= nnodes;
                                stdev -= mean * mean;

                                double thr = 1.0 - fKinkMinStd * stdev;
                                if (min < thr)
                                {
                                        mf::LogVerbatim("pma::PMAlgVertexing") << "   kink a: " << max_a << "deg";
                                        trk->Nodes()[kinkIdx]->SetVertex(true);
                                        tested_nodes.push_back(kinkIdx);
                                        kinkFound = true;

                                        trk->Optimize(0, 1.0e-5, false, false);
                                        double c = -trk->Nodes()[kinkIdx]->SegmentCosTransverse();
                                        double a = 180.0 * (1 - std::acos(trk->Nodes()[kinkIdx]->SegmentCosTransverse()) / TMath::Pi());

                                        if ((a <= fKinkMinDeg) || (c >= thr)) // not a significant kink after precise optimization
                                        {
                                                mf::LogVerbatim("pma::PMAlgVertexing") << "     -> tag removed after reopt";
                                                trk->Nodes()[kinkIdx]->SetVertex(false); // kinkIdx is saved in tested_nodes to avoid inf loop
                                        }
                                }
                        }
                }

                mf::LogVerbatim("pma::PMAlgVertexing") << "-------- done --------";
        }
}

std::vector< pma::VtxCandidate > pma::PMAlgVertexing::firstPassCandidates ( void  )

private

Definition at line 110 of file PMAlgVertexing.cxx.

References pma::VtxCandidate::Add(), fOutTracks, pma::VtxCandidate::Mse(), and pma::TrkCandidateColl::size().

Referenced by has(), and run().

{
        std::vector< pma::VtxCandidate > candidates;
        for (size_t t = 0; t < fOutTracks.size() - 1; t++)
        {
                for (size_t u = t + 1; u < fOutTracks.size(); u++)
                {
                        pma::VtxCandidate candidate;
                        if (!candidate.Add(fOutTracks[t])) break; // no segments with length > thr

                        // **************************** try Mse2D / or only Mse ************************************
                        if (candidate.Add(fOutTracks[u]) && (sqrt(candidate.Mse()) < 1.0))
                        //if (candidate.Add(fOutTracks[u]) && (sqrt(candidate.Mse()) < 2.0) && (candidate.Mse2D() < 1.0))
                        {
                                candidates.push_back(candidate);
                        }
                }
        }
        return candidates;
}

std::vector< std::pair< double, double > > pma::PMAlgVertexing::getdQdx ( const pma::Track3D &  trk ) const

private

Get dQ/dx sequence to detect various features.

Definition at line 341 of file PMAlgVertexing.cxx.

References pma::Track3D::GetRawdEdxSequence(), geo::kU, geo::kV, geo::kZ, max, pma::Track3D::NHits(), and pma::Track3D::size().

Referenced by has(), and isSingleParticle().

{
        std::vector< std::pair<double, double> > result;

        unsigned int view = geo::kZ;
        unsigned int nhits = trk.NHits(view);
        unsigned int max = nhits;

        nhits = trk.NHits(geo::kV);
        if (nhits > max) { max = nhits; view = geo::kV; }

        nhits = trk.NHits(geo::kU);
        if (nhits > max) { max = nhits; view = geo::kU; }

        if (max >= 16)
        {
                std::map< size_t, std::vector<double> > dqdx;
                trk.GetRawdEdxSequence(dqdx, view);

                for (size_t i = 0; i < trk.size(); i++)
                {
                        auto it = dqdx.find(i);
                        if (it != dqdx.end())
                        {
                                if (it->second[6] > 0.0) // dx > 0
                                {
                                        double dvalue = it->second[5] / it->second[6];
                                        result.emplace_back(std::pair<double, double>(dvalue, it->second[7]));
                                }
                        }
                }
        }

        return result;
}

std::vector< std::pair< TVector3, size_t > > pma::PMAlgVertexing::getKinks

(

const pma::TrkCandidateColl &

tracks

)

const

Definition at line 634 of file PMAlgVertexing.cxx.

References pma::Node3D::IsBranching(), pma::Node3D::IsVertex(), n, pma::Track3D::Nodes(), pma::Node3D::Point3D(), and pma::TrkCandidateColl::size().

Referenced by pma::PMAlgTrackingBase::getKinks(), and reset().

{
        std::vector< std::pair< TVector3, size_t > > ksel;
        for (size_t t = 0; t < tracks.size(); ++t)
        {
                pma::Track3D const * trk = tracks[t].Track();
                for (size_t n = 1; n < trk->Nodes().size() - 1; ++n)
                {
                        pma::Node3D const * node = trk->Nodes()[n];
                        if (!node->IsBranching() && node->IsVertex())
                        {
                                ksel.emplace_back(std::pair< TVector3, size_t >(node->Point3D(), t));
                        }
                }
        }
        return ksel;
}

std::vector< std::pair< TVector3, std::vector< std::pair< size_t, bool > > > > pma::PMAlgVertexing::getVertices	(	const pma::TrkCandidateColl &	tracks,
		bool	onlyBranching = false
	)		const

Definition at line 591 of file PMAlgVertexing.cxx.

References pma::Track3D::front(), pma::Node3D::IsBranching(), n, pma::Track3D::Nodes(), pma::Hit3D::Point3D(), pma::TrkCandidateColl::size(), and lar::dump::vector().

Referenced by pma::PMAlgTrackingBase::getVertices(), and reset().

{
        std::vector< std::pair< TVector3, std::vector< std::pair< size_t, bool > > > > vsel;
        std::vector< pma::Node3D const * > bnodes;

        for (size_t t = 0; t < tracks.size(); ++t)
        {
                pma::Track3D const * trk = tracks[t].Track();
                pma::Node3D const * firstNode = trk->Nodes().front();
                if (!(onlyBranching || firstNode->IsBranching()))
                {
                        std::vector< std::pair< size_t, bool > > tidx;
                        tidx.emplace_back(std::pair< size_t, bool >(t, true));
                        vsel.emplace_back(std::pair< TVector3, std::vector< std::pair< size_t, bool > > >(trk->front()->Point3D(), tidx));
                }

                bool pri = true;
                for (auto node : trk->Nodes())
                        if (node->IsBranching())
                {
                        bool found = false;
                        for (size_t n = 0; n < bnodes.size(); n++)
                                if (node == bnodes[n])
                        {
                                vsel[n].second.emplace_back(std::pair< size_t, bool >(t, pri));
                                found = true; break;
                        }
                        if (!found)
                        {
                                std::vector< std::pair< size_t, bool > > tidx;
                                tidx.emplace_back(std::pair< size_t, bool >(t, pri));
                                vsel.emplace_back(std::pair< TVector3, std::vector< std::pair< size_t, bool > > >(node->Point3D(), tidx));
                                bnodes.push_back(node);
                        }
                        pri = false;
                }
        }

        return vsel;
}

bool pma::PMAlgVertexing::has ( const std::vector< size_t > &  v, size_t  idx  ) const

inlineprivate

Definition at line 89 of file PMAlgVertexing.h.

References convolute(), findKinksOnTracks(), firstPassCandidates(), getdQdx(), isSingleParticle(), makeVertices(), mergeBrokenTracks(), secondPassCandidates(), and splitMergedTracks().

Referenced by findKinksOnTracks().

        {
                for (auto c : v) if (c == idx) return true;
                return false;
        }

bool pma::PMAlgVertexing::isSingleParticle ( pma::Track3D *  trk1, pma::Track3D *  trk2  ) const

private

Check if colinear in 3D and dQ/dx with no significant step.

Definition at line 399 of file PMAlgVertexing.cxx.

References convolute(), getdQdx(), and pma::Track3D::Segments().

Referenced by has(), and mergeBrokenTracks().

{
        const double minCos = 0.996194698; // 5 deg (is it ok?)
        double segCos = trk1->Segments().back()->GetDirection3D().Dot( trk2->Segments().front()->GetDirection3D() );
        if (segCos < minCos)
        {
                mf::LogVerbatim("pma::PMAlgVertexing") << "  has large angle, cos: " << segCos;
                return false;
        }

        const size_t stepShapeLen = 16;
        const size_t stepShapeHalf = stepShapeLen >> 1;
        const double stepShape[stepShapeLen] =
                { -1., -1., -1., -1., -1., -1., -1., -1.,
                   1.,  1.,  1.,  1.,  1.,  1.,  1.,  1. };

        auto dqdx1 = getdQdx(*trk1); if (dqdx1.size() < stepShapeHalf) return false;
        auto dqdx2 = getdQdx(*trk2); if (dqdx2.size() < stepShapeHalf) return false;

        const size_t adcLen = stepShapeLen + 2; // 1 sample before/after to check convolution at 3 points in total
        const size_t adcHalf = adcLen >> 1;

        double dqdx[adcLen];
        for (size_t i = 0; i < adcLen; i++) dqdx[i] = 0.0;

        bool has_m = true;
        for (int i = adcHalf - 1, j = dqdx1.size() - 1; i >= 0; i--, j--)
        {
                if (j >= 0) dqdx[i] = dqdx1[j].first;
                else { dqdx[i] = dqdx[i+1]; has_m = false; }
        }
        bool has_p = true;
        for (size_t i = adcHalf, j = 0; i < adcLen; i++, j++)
        {
                if (j < dqdx2.size()) dqdx[i] = dqdx2[j].first;
                else { dqdx[i] = dqdx[i-1]; has_p = false; }
        }

        double sum_m = 0.0; if (has_m) sum_m = convolute(adcHalf - 1, stepShapeLen, dqdx, stepShape);
        double sum_0 = convolute(adcHalf, stepShapeLen, dqdx, stepShape);
        double sum_p = 0.0; if (has_p) sum_p = convolute(adcHalf + 1, stepShapeLen, dqdx, stepShape);

        const double convMin = 0.8;
        if ((fabs(sum_m) >= convMin) ||
            (fabs(sum_0) >= convMin) ||
            (fabs(sum_p) >= convMin))
        {
                mf::LogVerbatim("pma::PMAlgVertexing") << "  has step in conv.values: "
                        << sum_m << ", " << sum_0 << ", " << sum_p;
                return false;
        }
        else
        {
                mf::LogVerbatim("pma::PMAlgVertexing") << "  single particle, conv.values: "
                        << sum_m << ", " << sum_0 << ", " << sum_p;
                return true;
        }
}

size_t pma::PMAlgVertexing::makeVertices ( std::vector< pma::VtxCandidate > &  candidates )

private

Definition at line 153 of file PMAlgVertexing.cxx.

References d, pma::Dist2(), fEmTracks, fMinTrackLength, fOutTracks, and s.

Referenced by has(), and run().

{
        bool merged = true;
        while (merged && (candidates.size() > 1))
        {
                size_t k_best, l_best, k = 0;
                while (k < candidates.size() - 1)
                {
                        size_t l = k + 1;
                        while (l < candidates.size())
                        {
                                if (candidates[l].Has(candidates[k]))
                                {
                                        candidates[k] = candidates[l];
                                        candidates.erase(candidates.begin() + l);
                                }
                                else if (candidates[k].Has(candidates[l]))
                                {
                                        candidates.erase(candidates.begin() + l);
                                }
                                else l++;
                        }
                        k++;
                }

                merged = false;
                double d_thr = 1.0; // 1.0 = max weighted dist. threshold
                double d, dmin = d_thr;

                k = 0;
                while (k < candidates.size() - 1)
                {
                        size_t l = k + 1;
                        while (l < candidates.size())
                        {
                                d = candidates[k].Test(candidates[l]);
                                if (d < dmin) { dmin = d; k_best = k; l_best = l; }
                                l++;
                        }
                        k++;
                }
                if ((dmin < d_thr) && candidates[k_best].MergeWith(candidates[l_best]))
                {
                        candidates.erase(candidates.begin() + l_best);
                        merged = true;
                }
        }

        mf::LogVerbatim("pma::PMAlgVertexing") << "*** Vtx candidates: " << candidates.size();
        std::vector< pma::VtxCandidate > toJoin;
        bool select = true;
        while (select)
        {
                int s, nmax = 0, c_best = -1;
                double a, amax = 0.0;

                for (size_t v = 0; v < candidates.size(); v++)
                {
                        if (candidates[v].HasLoops()) continue;

                        bool maybeCorrelated = false;
                        for (size_t u = 0; u < toJoin.size(); u++)
                                if (toJoin[u].IsAttached(candidates[v]) || // connected with tracks or close centers
                                        (pma::Dist2(toJoin[u].Center(), candidates[v].Center()) < 15.0*15.0))
                                {
                                        maybeCorrelated = true; break;
                                }
                        if (maybeCorrelated) continue;

                        s = (int)candidates[v].Size(2 * fMinTrackLength);
                        a = candidates[v].MaxAngle(1.0);

                        if ((s > nmax) || ((s == nmax) && (a > amax)))
                        {
                                nmax = s; amax = a; c_best = v;
                        }
/*
                        mf::LogVerbatim("pma::PMAlgVertexing")
                                << "center x:" << candidates[v].Center().X()
                                << " y:" << candidates[v].Center().Y()
                                << " z:" << candidates[v].Center().Z();

                        for (size_t i = 0; i < candidates[v].Size(); i++)
                                mf::LogVerbatim("pma::PMAlgVertexing")
                                        << "     trk:" << i << " "
                                        << candidates[v].Track(i).first->size();

                        mf::LogVerbatim("pma::PMAlgVertexing")
                                << " dist 3D:" << sqrt(candidates[v].Mse())
                                << " 2D:" << sqrt(candidates[v].Mse2D())
                                << " max ang:" << a;
*/
                }
                if (c_best >= 0)
                {
                        toJoin.push_back(candidates[c_best]);
                        candidates.erase(candidates.begin() + c_best);
                }
                else select = false;
        }
        mf::LogVerbatim("pma::PMAlgVertexing") << "*** Vtx selected to join: " << toJoin.size();

        size_t njoined = 0;
        for (auto & c : toJoin)
        {
                if (c.JoinTracks(fOutTracks, fEmTracks)) njoined++;
        }

        return njoined;
}

void pma::PMAlgVertexing::mergeBrokenTracks ( pma::TrkCandidateColl &  trk_input ) const

private

Find elastic scattering vertices on tracks, merge back tracks that were split during vertex finding. 3D angle between two tracks and dQ/dx is checked.

Definition at line 458 of file PMAlgVertexing.cxx.

References isSingleParticle(), n, pma::SortedBranchBase::Next(), pma::SortedBranchBase::NextCount(), pma::Track3D::Nodes(), pma::Segment3D::Parent(), pma::SortedObjectBase::Prev(), pma::Track3D::Segments(), and pma::TrkCandidateColl::size().

Referenced by has(), and run().

{
        if (trk_input.size() < 2) return;

        mf::LogVerbatim("pma::PMAlgVertexing") << "Find and merge tracks broken by vertices.";
        bool merged = true;
        while (merged)
        {
                merged = false;
                for (size_t t = 0; t < trk_input.size(); t++)
                {
                        pma::Track3D* trk1 = trk_input[t].Track();
                        pma::Track3D* trk2 = 0;

                        pma::Node3D* node = trk1->Nodes().front();
                        if (node->Prev())
                        {
                                pma::Segment3D* seg = static_cast< pma::Segment3D* >(node->Prev());
                                trk2 = seg->Parent();
                                if ((trk1 != trk2) && isSingleParticle(trk2, trk1)) // note: reverse order
                                {
                                        //merged = true;
                                        break;
                                }
                        }

                        trk2 = 0;
                        double c, maxc = 0.0;
                        pma::Vector3D dir1 = trk1->Segments().back()->GetDirection3D();
                        node = trk1->Nodes().back();
                        for (size_t n = 0; n < node->NextCount(); n++)
                        {
                                pma::Segment3D* seg = static_cast< pma::Segment3D* >(node->Next(n));
                                pma::Track3D* tst = seg->Parent();
                                if (tst != trk1) // should always be true: the last node of trk1 is tested
                                {
                                        c = dir1.Dot( tst->Segments().front()->GetDirection3D() );
                                        if (c > maxc) { maxc = c; trk2 = tst; }
                                }
                        }
                        if ((trk2) && isSingleParticle(trk1, trk2))
                        {
                                //merged = true;
                                break;
                        }
                }
        }
        mf::LogVerbatim("pma::PMAlgVertexing") << "-------- done --------";
}

void pma::PMAlgVertexing::reconfigure

(

const Config &

config

)

Definition at line 19 of file PMAlgVertexing.cxx.

References fFindKinks, pma::PMAlgVertexing::Config::FindKinks, fKinkMinDeg, fKinkMinStd, fMinTrackLength, pma::PMAlgVertexing::Config::KinkMinDeg, pma::PMAlgVertexing::Config::KinkMinStd, and pma::PMAlgVertexing::Config::MinTrackLength.

Referenced by PMAlgVertexing().

{
        fMinTrackLength = config.MinTrackLength();

        fFindKinks = config.FindKinks();
        fKinkMinDeg = config.KinkMinDeg();
        fKinkMinStd = config.KinkMinStd();
}

void pma::PMAlgVertexing::reset ( void  )

inline

Definition at line 67 of file PMAlgVertexing.h.

References cleanTracks(), getKinks(), getVertices(), and run().

{ cleanTracks(); }

size_t pma::PMAlgVertexing::run

(

pma::TrkCandidateColl &

trk_input

)

Copy input tracks, find 3D vertices, connect tracks, break them or flip if needed, reoptimize track structures. Result is returned as a collection of new tracks, that replaces content of trk_input (old tracks are deleted). Vertices can be accessed with getVertices function.

Definition at line 265 of file PMAlgVertexing.cxx.

References collectTracks(), fEmTracks, fFindKinks, findKinksOnTracks(), firstPassCandidates(), fOutTracks, makeVertices(), mergeBrokenTracks(), secondPassCandidates(), pma::TrkCandidateColl::size(), and sortTracks().

Referenced by pma::PMAlgFitter::build(), pma::PMAlgTracker::build(), and reset().

{
        if (fFindKinks) findKinksOnTracks(trk_input);

        if (trk_input.size() < 2)
        {
                mf::LogWarning("pma::PMAlgVertexing") << "need min two source tracks!";
                return 0;
        }

        sortTracks(trk_input); // copy input and split by tag/size

        size_t nvtx = 0;
        mf::LogVerbatim("pma::PMAlgVertexing") << "Pass #1:";
        //std::cout << "Pass #1:" << std::endl;
        if (fOutTracks.size() > 1)
        {
                size_t nfound = 0;
                do
                {
                        auto candidates = firstPassCandidates();
                        if (candidates.size())
                        {
                                nfound = makeVertices(candidates);
                                nvtx += nfound;
                        }
                        else nfound = 0;
                }
                while (nfound > 0);
                mf::LogVerbatim("pma::PMAlgVertexing") << "  " << nvtx << " vertices.";
                //std::cout << "  " << nvtx << " vertices." << std::endl;
        }
        else mf::LogVerbatim("pma::PMAlgVertexing") << " ...short tracks only.";

        mf::LogVerbatim("pma::PMAlgVertexing") << "Pass #2:";
        //std::cout << "Pass #2:" << std::endl;
        if (fOutTracks.size() && fEmTracks.size())
        {
                size_t nfound = 1; // just to start
                while (nfound && fEmTracks.size())
                {
                        auto candidates = secondPassCandidates();
                        if (candidates.size())
                        {
                                nfound = makeVertices(candidates);
                                nvtx += nfound;
                        }
                        else nfound = 0;
                }
                mf::LogVerbatim("pma::PMAlgVertexing") << "  " << nvtx << " vertices.";
                //std::cout << "  " << nvtx << " vertices." << std::endl;
        }
        else mf::LogVerbatim("pma::PMAlgVertexing") << " ...no tracks.";

        collectTracks(trk_input);

        mergeBrokenTracks(trk_input);

        return nvtx;
}

size_t pma::PMAlgVertexing::run	(	pma::TrkCandidateColl &	trk_input,
		const std::vector< TVector3 > &	vtx_input
	)

Copy input tracks, use provided 3D vertices to connect tracks, break tracks or flip if needed, reoptimize track structures. Result is returned as a collection of new tracks, that replaces content of trk_input (old tracks are deleted). Input vertices that were actually associated to tracks are copied to the output collection (use getVertices function).

Definition at line 327 of file PMAlgVertexing.cxx.

References sortTracks().

{
        sortTracks(trk_input); // copy input and split by tag/size

        // ....

        //collectTracks(trk_input); // return output in place of (deleted) input

        return 0;
}

std::vector< pma::VtxCandidate > pma::PMAlgVertexing::secondPassCandidates ( void  )

private

Definition at line 131 of file PMAlgVertexing.cxx.

References pma::VtxCandidate::Add(), fEmTracks, fMinTrackLength, fOutTracks, pma::VtxCandidate::Mse(), and pma::TrkCandidateColl::size().

Referenced by has(), and run().

{
        std::vector< pma::VtxCandidate > candidates;
        for (size_t t = 0; t < fOutTracks.size(); t++)
                if (fOutTracks[t].Track()->Length() > fMinTrackLength)
        {
                for (size_t u = 0; u < fEmTracks.size(); u++)
                {
                        pma::VtxCandidate candidate;
                        if (!candidate.Add(fOutTracks[t])) break; // no segments with length > thr

                        if (fOutTracks[t].Track() == fEmTracks[u].Track()) continue;

                        if (candidate.Add(fEmTracks[u]) && (sqrt(candidate.Mse()) < 1.0))
                        {
                                candidates.push_back(candidate);
                        }
                }
        }
        return candidates;
}

void pma::PMAlgVertexing::sortTracks ( const pma::TrkCandidateColl &  trk_input )

private

Definition at line 75 of file PMAlgVertexing.cxx.

References cleanTracks(), fEmTracks, fExcludedTracks, fMinTrackLength, fOutTracks, pma::Track3D::kCosmic, pma::Track3D::kEmLike, pma::TrkCandidateColl::size(), and pma::TrkCandidateColl::tracks().

Referenced by run().

{
        cleanTracks();

        for (auto const & t : trk_input.tracks())
        {
                pma::Track3D* copy = new pma::Track3D(*(t.Track()));
                int key = t.Key();
                
                if ((t.Track()->GetT0() != 0) ||                    // do not create vertices on cosmic muons, now track with any non-zero t0 is a muon,
                    (t.Track()->HasTagFlag(pma::Track3D::kCosmic))) // tag for track recognized as a cosmic ray is starting to be used
                {
                    fExcludedTracks.tracks().emplace_back(copy, key);
                    continue;
                }

        double l = t.Track()->Length();

                if (t.Track()->GetTag() == pma::Track3D::kEmLike)
                {
                        if (l > 2 * fMinTrackLength) fOutTracks.tracks().emplace_back(copy, key);
                        else fEmTracks.tracks().emplace_back(copy, key);
                }
                else
                {
                        if (l > fMinTrackLength) fOutTracks.tracks().emplace_back(copy, key);
                        else fEmTracks.tracks().emplace_back(copy, key);
                }
        }
        mf::LogVerbatim("pma::PMAlgVertexing") << "long tracks: " << fOutTracks.size() << std::endl;
        mf::LogVerbatim("pma::PMAlgVertexing") << "em and short tracks: " << fEmTracks.size() << std::endl;
        mf::LogVerbatim("pma::PMAlgVertexing") << "excluded cosmic tracks: " << fExcludedTracks.size() << std::endl;
}

void pma::PMAlgVertexing::splitMergedTracks ( pma::TrkCandidateColl &  trk_input ) const

private

Split track and add vertex and reoptimize when dQ/dx step detected.

Definition at line 509 of file PMAlgVertexing.cxx.

References pma::TrkCandidateColl::size().

Referenced by has().

{
        if (trk_input.size() < 1) return;

        mf::LogVerbatim("pma::PMAlgVertexing") << "Find missed vtx by dQ/dx steps along merged tracks.";
        size_t t = 0;
        while (t < trk_input.size())
        {
                t++;
        }
        mf::LogVerbatim("pma::PMAlgVertexing") << "-------- done --------";
}

Member Data Documentation

pma::TrkCandidateColl pma::PMAlgVertexing::fEmTracks

private

Definition at line 118 of file PMAlgVertexing.h.

Referenced by cleanTracks(), collectTracks(), makeVertices(), run(), secondPassCandidates(), and sortTracks().

pma::TrkCandidateColl pma::PMAlgVertexing::fExcludedTracks

private

Definition at line 119 of file PMAlgVertexing.h.

Referenced by cleanTracks(), collectTracks(), and sortTracks().

bool pma::PMAlgVertexing::fFindKinks

private

Definition at line 129 of file PMAlgVertexing.h.

Referenced by reconfigure(), and run().

double pma::PMAlgVertexing::fKinkMinDeg

private

Definition at line 130 of file PMAlgVertexing.h.

Referenced by findKinksOnTracks(), and reconfigure().

double pma::PMAlgVertexing::fKinkMinStd

private

Definition at line 131 of file PMAlgVertexing.h.

Referenced by findKinksOnTracks(), and reconfigure().

double pma::PMAlgVertexing::fMinTrackLength

private

Definition at line 127 of file PMAlgVertexing.h.

Referenced by makeVertices(), reconfigure(), secondPassCandidates(), and sortTracks().

pma::TrkCandidateColl pma::PMAlgVertexing::fOutTracks

private

Definition at line 118 of file PMAlgVertexing.h.

Referenced by cleanTracks(), collectTracks(), firstPassCandidates(), makeVertices(), run(), secondPassCandidates(), and sortTracks().

pma::TrkCandidateColl pma::PMAlgVertexing::fShortTracks

private

Definition at line 118 of file PMAlgVertexing.h.

Referenced by cleanTracks(), and collectTracks().

---

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

• /cvmfs/larsoft.opensciencegrid.org/products/larreco/v07_10_02/source/larreco/RecoAlg/PMAlgVertexing.h
• /cvmfs/larsoft.opensciencegrid.org/products/larreco/v07_10_02/source/larreco/RecoAlg/PMAlgVertexing.cxx