#include <CrossingPtBasedLinearizationPointFinder.h>

Inheritance diagram for CrossingPtBasedLinearizationPointFinder:

Classes
struct	CompareTwoTracks

Public Member Functions
CrossingPtBasedLinearizationPointFinder *	clone () const override

	CrossingPtBasedLinearizationPointFinder (const CrossingPtBasedLinearizationPointFinder &)

	CrossingPtBasedLinearizationPointFinder (const ModeFinder3d &algo, const signed int n_pairs=5)

	CrossingPtBasedLinearizationPointFinder (const RecTracksDistanceMatrix *m, const ModeFinder3d &algo, const signed int n_pairs=-1)

GlobalPoint	getLinearizationPoint (const std::vector< FreeTrajectoryState > &) const override

GlobalPoint	getLinearizationPoint (const std::vector< reco::TransientTrack > &) const override

	~CrossingPtBasedLinearizationPointFinder () override

Public Member Functions inherited from LinearizationPointFinder
virtual	~LinearizationPointFinder ()

Protected Attributes
const RecTracksDistanceMatrix *	theMatrix

signed int	theNPairs

const bool	useMatrix

Private Member Functions
GlobalPoint	find (const std::vector< std::pair< GlobalPoint, float > > &) const

std::vector< reco::TransientTrack >	getBestTracks (const std::vector< reco::TransientTrack > &) const

GlobalPoint	useAllTracks (const std::vector< reco::TransientTrack > &) const

GlobalPoint	useFullMatrix (const std::vector< reco::TransientTrack > &) const

Private Attributes
ModeFinder3d *	theAlgo

Detailed Description

A linearization point finder. It works the following way:

Calculate in an optimal way 'n_pairs' different crossing points. Optimal in this context means the following: a. Try to use as many different tracks as possible; avoid using the same track all the time. b. Use the most energetic tracks. c. Try not to group the most energetic tracks together. Try to group more energetic tracks with less energetic tracks. We assume collimated bundles here, so this is why. d. Perform optimally. Do not sort more tracks (by total energy, see b) than necessary. e. If n_pairs >= (number of all possible combinations), do not leave any combinations out. ( a. and e. are almost but not entirely fulfilled in the current impl )
Apply theAlgo on the n points.

Definition at line 26 of file CrossingPtBasedLinearizationPointFinder.h.

Constructor & Destructor Documentation

◆ CrossingPtBasedLinearizationPointFinder() [1/3]

CrossingPtBasedLinearizationPointFinder::CrossingPtBasedLinearizationPointFinder	(	const ModeFinder3d &	algo,
		const signed int	n_pairs = `5`
	)

Parameters

n_pairs how many track pairs will be considered (maximum) a value of -1 means full combinatorics.

Definition at line 91 of file CrossingPtBasedLinearizationPointFinder.cc.

93 : useMatrix(false), theNPairs(n_pairs), theMatrix(nullptr), theAlgo(algo.clone()) {}

Referenced by clone().

◆ CrossingPtBasedLinearizationPointFinder() [2/3]

CrossingPtBasedLinearizationPointFinder::CrossingPtBasedLinearizationPointFinder	(	const RecTracksDistanceMatrix *	m,
		const ModeFinder3d &	algo,
		const signed int	n_pairs = `-1`
	)

This constructor exploits the information stored in a RecTracksDistanceMatrix object.

Parameters

n_pairs how many track pairs will be considered (maximum) a value of -1 means full combinatorics.

Definition at line 95 of file CrossingPtBasedLinearizationPointFinder.cc.

98 : useMatrix(m->hasCrossingPoints()), theNPairs(n_pairs), theMatrix(m), theAlgo(algo.clone()) {}

◆ CrossingPtBasedLinearizationPointFinder() [3/3]

CrossingPtBasedLinearizationPointFinder::CrossingPtBasedLinearizationPointFinder ( const CrossingPtBasedLinearizationPointFinder & o )

Definition at line 100 of file CrossingPtBasedLinearizationPointFinder.cc.

     : useMatrix(o.useMatrix),
       theNPairs(o.theNPairs),
       theMatrix(o.theMatrix /* nope, we dont clone!! */),
       theAlgo(o.theAlgo->clone()) {}

◆ ~CrossingPtBasedLinearizationPointFinder()

CrossingPtBasedLinearizationPointFinder::~CrossingPtBasedLinearizationPointFinder ( )

override

Definition at line 107 of file CrossingPtBasedLinearizationPointFinder.cc.

107 { delete theAlgo; }

References theAlgo.

Member Function Documentation

◆ clone()

CrossingPtBasedLinearizationPointFinder* CrossingPtBasedLinearizationPointFinder::clone ( ) const

inlineoverridevirtual

Clone method

Implements LinearizationPointFinder.

Reimplemented in FsmwLinearizationPointFinder, SMSLinearizationPointFinder, HSMLinearizationPointFinder, LMSLinearizationPointFinder, and SubsetHSMLinearizationPointFinder.

Definition at line 52 of file CrossingPtBasedLinearizationPointFinder.h.

                                                                   {
     return new CrossingPtBasedLinearizationPointFinder(*this);
   };

References CrossingPtBasedLinearizationPointFinder().

◆ find()

GlobalPoint CrossingPtBasedLinearizationPointFinder::find ( const std::vector< std::pair< GlobalPoint, float > > & ) const

private

calls (*theAglo) (input) can optionally save input / output in .root file

Definition at line 178 of file CrossingPtBasedLinearizationPointFinder.cc.

                                                                                                         {
   /*
     std::cout << "[CrossingPtBasedLinearizationPointFinder] input size="
          << input.size() << std::endl;*/
   GlobalPoint ret = (*theAlgo)(input);
 #ifdef Use_GraphicsHarvester
  
   graphicsDebug(input);
 #endif
  
   return ret;
 }

References input, and runTheMatrix::ret.

Referenced by getLinearizationPoint(), useAllTracks(), and useFullMatrix().

◆ getBestTracks()

std::vector< reco::TransientTrack > CrossingPtBasedLinearizationPointFinder::getBestTracks ( const std::vector< reco::TransientTrack > & tracks ) const

private

Definition at line 109 of file CrossingPtBasedLinearizationPointFinder.cc.

                                                        {
   unsigned int n_tracks = (2 * (unsigned int)(theNPairs)) < tracks.size() ? 2 * theNPairs : tracks.size();
  
   std::vector<reco::TransientTrack> newtracks = tracks;
   partial_sort(newtracks.begin(), newtracks.begin() + n_tracks, newtracks.end(), CompareTwoTracks());
   newtracks.erase(newtracks.begin() + n_tracks, newtracks.end());
  
   /*
      * old version, when we have a default constructor
      *
     
     std::vector <reco::TransientTrack> newtracks ( n_tracks );
     partial_sort_copy ( tracks.begin(), tracks.end(), newtracks.begin(),
                         newtracks.begin() + n_tracks  , CompareTwoTracks() );
                         */
  
   return newtracks;
 }

References createfilelist::int, theNPairs, and PDWG_EXOHSCP_cff::tracks.

Referenced by getLinearizationPoint().

◆ getLinearizationPoint() [1/2]

GlobalPoint CrossingPtBasedLinearizationPointFinder::getLinearizationPoint ( const std::vector< FreeTrajectoryState > & tracks ) const

overridevirtual

Reimplemented from LinearizationPointFinder.

Definition at line 173 of file CrossingPtBasedLinearizationPointFinder.cc.

                                                         {
   return LinearizationPointFinder::getLinearizationPoint(tracks);
 }

References LinearizationPointFinder::getLinearizationPoint(), and PDWG_EXOHSCP_cff::tracks.

◆ getLinearizationPoint() [2/2]

GlobalPoint CrossingPtBasedLinearizationPointFinder::getLinearizationPoint ( const std::vector< reco::TransientTrack > & tracks ) const

overridevirtual

Method giving back the Initial Linearization Point.

Implements LinearizationPointFinder.

Definition at line 191 of file CrossingPtBasedLinearizationPointFinder.cc.

                                                        {
   if (tracks.size() < 2)
     throw LinPtException("CrossingPtBasedLinPtFinder: too few tracks given.");
   std::vector<PointAndDistance> vgp;
   if (theNPairs == -1) {
     if (useMatrix) {
       return useFullMatrix(tracks);
     } else {
       return useAllTracks(tracks);
     }
   }
  
   if (sum(tracks.size() - 1) < ((unsigned int)(theNPairs))) {
     /*
             std::cout << "[CrossingPtBasedLinearizationPointFinder] we exploit all track pairs"
                  << std::endl;*/
     // we have fewer track pair options than is foreseen
     // in the quota.
     // so we exploit all tracks pairs.
     return useAllTracks(tracks);
   }
  
   std::vector<reco::TransientTrack> goodtracks = getBestTracks(tracks);
  
   // we sort according to momenta.
   if (goodtracks.size() < 2)
     throw LinPtException("CrossingPtBasedLinPtFinder: less than two tracks given");
   // vgp.reserve ( theNPairs - 1 );
   unsigned int t_first = 0;
   unsigned int t_interval = goodtracks.size() / 2;
   unsigned int lim = goodtracks.size() - 1;
  
   /*
         std::cout << "[CrossingPtBasedLinearizationPointFinder] we start: npairs=" << theNPairs
              << std::endl;
         std::cout << "[CrossingPtBasedLinearizationPointFinder] t_interval=" << t_interval << std::endl;
         std::cout << "[CrossingPtBasedLinearizationPointFinder goodtracks.size=" << goodtracks.size()
              << std::endl;*/
  
   // the 'direction' false: intervals will expand
   // true: intervals will shrink
   bool dir = false;
  
   while (vgp.size() < ((unsigned int)(theNPairs))) {
     reco::TransientTrack rt1 = goodtracks[t_first];
     reco::TransientTrack rt2 = goodtracks[t_first + t_interval];
     // std::cout << "Considering now: " << t_first << ", " << t_first+t_interval << std::endl;
     if (useMatrix) {
       PointAndDistance v(theMatrix->crossingPoint(rt1, rt2), theMatrix->distance(rt1, rt2));
       vgp.push_back(v);
     } else {  // No DistanceMatrix available
       TwoTrackMinimumDistance ttmd;
       bool status = ttmd.calculate(rt1.impactPointState(), rt2.impactPointState());
       if (status) {
         std::pair<GlobalPoint, GlobalPoint> pts = ttmd.points();
         PointAndDistance v((pts.second + pts.first) / 2., (pts.second - pts.first).mag());
         vgp.push_back(v);
       }
     }
     if ((t_first + t_interval) < lim) {
       t_first++;
     } else if (dir) {
       t_first = 0;
       t_interval--;
       if (t_interval == 0) {
         /* std::cout << "[CrossingPtBasedLinearizationPointFinder] t_interval=0. break."
                          << std::endl;*/
         break;
       }
     } else {
       t_first = 0;
       t_interval++;
       if (t_interval == goodtracks.size()) {
         /* std::cout << "[CrossingPtBasedLinearizationPointFinder] t_interval="
                          << goodtracks.size() << "(max). start to decrease intervals"
                          << std::endl; */
         dir = true;
         t_interval = goodtracks.size() / 2 - 1;
       }
     }
   }
   if (vgp.empty()) {
     // no crossing points? Fallback to a crossingpoint-less lin pt finder!
     return FallbackLinearizationPointFinder().getLinearizationPoint(tracks);
   }
   return find(vgp);
  
   return GlobalPoint(0., 0., 0.);  // if nothing else, then return 0,0,0
 }

References TwoTrackMinimumDistance::calculate(), RecTracksDistanceMatrix::crossingPoint(), DeadROC_duringRun::dir, RecTracksDistanceMatrix::distance(), find(), getBestTracks(), FallbackLinearizationPointFinder::getLinearizationPoint(), reco::TransientTrack::impactPointState(), createfilelist::int, TwoTrackMinimumDistance::points(), RPCpg::pts, mps_update::status, theMatrix, theNPairs, PDWG_EXOHSCP_cff::tracks, useAllTracks(), useFullMatrix(), useMatrix, and findQualityFiles::v.

◆ useAllTracks()

GlobalPoint CrossingPtBasedLinearizationPointFinder::useAllTracks ( const std::vector< reco::TransientTrack > & tracks ) const

private

Definition at line 131 of file CrossingPtBasedLinearizationPointFinder.cc.

                                                        {
   std::vector<PointAndDistance> vgp;
   // vgp.reserve ( ( tracks.size() * ( tracks.size()-1 ) ) / 2 - 1 );
   TwoTrackMinimumDistance ttmd;
   bool status;
   std::vector<reco::TransientTrack>::const_iterator end = tracks.end();
   std::vector<reco::TransientTrack>::const_iterator endm1 = (end - 1);
   for (std::vector<reco::TransientTrack>::const_iterator x = tracks.begin(); x != endm1; ++x) {
     for (std::vector<reco::TransientTrack>::const_iterator y = x + 1; y != end; ++y) {
       status = ttmd.calculate((*x).impactPointState(), (*y).impactPointState());
       if (status) {
         std::pair<GlobalPoint, GlobalPoint> pts = ttmd.points();
         std::pair<GlobalPoint, float> v((pts.second + pts.first) / 2., (pts.second - pts.first).mag());
         vgp.push_back(v);
       }  // If sth goes wrong, we just dont add. Who cares?
     }
   }
   if (vgp.empty()) {
     return FallbackLinearizationPointFinder().getLinearizationPoint(tracks);
   }
   return find(vgp);
 }

References TwoTrackMinimumDistance::calculate(), mps_fire::end, find(), FallbackLinearizationPointFinder::getLinearizationPoint(), TwoTrackMinimumDistance::points(), RPCpg::pts, mps_update::status, PDWG_EXOHSCP_cff::tracks, findQualityFiles::v, x, and y.

Referenced by getLinearizationPoint().

◆ useFullMatrix()

GlobalPoint CrossingPtBasedLinearizationPointFinder::useFullMatrix ( const std::vector< reco::TransientTrack > & tracks ) const

private

Definition at line 155 of file CrossingPtBasedLinearizationPointFinder.cc.

                                                        {
   std::vector<PointAndDistance> vgp;
   vgp.reserve((int)(tracks.size() * (tracks.size() - 1) / 2. - 1));
   std::vector<reco::TransientTrack>::const_iterator end = tracks.end();
   std::vector<reco::TransientTrack>::const_iterator endm1 = (end - 1);
   for (std::vector<reco::TransientTrack>::const_iterator x = tracks.begin(); x != endm1; ++x) {
     for (std::vector<reco::TransientTrack>::const_iterator y = x + 1; y != end; ++y) {
       PointAndDistance v(theMatrix->crossingPoint(*x, *y), theMatrix->distance(*x, *y));
       vgp.push_back(v);
     }
   }
   if (vgp.empty()) {
     return FallbackLinearizationPointFinder().getLinearizationPoint(tracks);
   }
   return find(vgp);
 }