#include <CrossingPtBasedLinearizationPointFinder.h>

Inheritance diagram for CrossingPtBasedLinearizationPointFinder:

Classes
struct	CompareTwoTracks

Public Member Functions
virtual CrossingPtBasedLinearizationPointFinder *	clone () const

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

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

	CrossingPtBasedLinearizationPointFinder (const CrossingPtBasedLinearizationPointFinder &)

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

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

	~CrossingPtBasedLinearizationPointFinder ()

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::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 106 of file CrossingPtBasedLinearizationPointFinder.cc.

Referenced by clone().

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

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 112 of file CrossingPtBasedLinearizationPointFinder.cc.

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

CrossingPtBasedLinearizationPointFinder::CrossingPtBasedLinearizationPointFinder ( const CrossingPtBasedLinearizationPointFinder & o )

Definition at line 120 of file CrossingPtBasedLinearizationPointFinder.cc.

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

CrossingPtBasedLinearizationPointFinder::~CrossingPtBasedLinearizationPointFinder ( )

Definition at line 126 of file CrossingPtBasedLinearizationPointFinder.cc.

References theAlgo.

 {
     delete theAlgo;
 }

Member Function Documentation

virtual CrossingPtBasedLinearizationPointFinder* CrossingPtBasedLinearizationPointFinder::clone ( ) const

inlinevirtual

Clone method

Implements LinearizationPointFinder.

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

Definition at line 55 of file CrossingPtBasedLinearizationPointFinder.h.

References CrossingPtBasedLinearizationPointFinder().

                                                                   {
     return new CrossingPtBasedLinearizationPointFinder ( * this );
   };

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 216 of file CrossingPtBasedLinearizationPointFinder.cc.

References input, and runTheMatrix::ret.

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

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

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

private

Definition at line 131 of file CrossingPtBasedLinearizationPointFinder.cc.

References theNPairs, and testEve_cfg::tracks.

Referenced by getLinearizationPoint().

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

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

virtual

Method giving back the Initial Linearization Point.

Implements LinearizationPointFinder.

Definition at line 231 of file CrossingPtBasedLinearizationPointFinder.cc.

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

 {
         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.size() )
         {
             // 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
 }

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

virtual

Reimplemented from LinearizationPointFinder.

Definition at line 210 of file CrossingPtBasedLinearizationPointFinder.cc.

References LinearizationPointFinder::getLinearizationPoint().

 {
     return LinearizationPointFinder::getLinearizationPoint ( tracks );
 }

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

private

Definition at line 154 of file CrossingPtBasedLinearizationPointFinder.cc.

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

Referenced by getLinearizationPoint().

 {
     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.size() )
     {
         return FallbackLinearizationPointFinder().getLinearizationPoint ( tracks );
     }
     return find ( vgp );
 }

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

private

Definition at line 185 of file CrossingPtBasedLinearizationPointFinder.cc.

References RecTracksDistanceMatrix::crossingPoint(), RecTracksDistanceMatrix::distance(), end, find(), FallbackLinearizationPointFinder::getLinearizationPoint(), theMatrix, findQualityFiles::v, x, and y.

Referenced by getLinearizationPoint().

 {
     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.size() )
     {
         return FallbackLinearizationPointFinder().getLinearizationPoint ( tracks );
     }
     return find ( vgp );
 }