CDF KITS Project:/ include/ TrackingObjects/ Tracks/ track_cut.hh		[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ]
	Architecture: [ i386 ] Version: [ 4.10.4 ] [ 4.10.5 ] [ 4.8.4 ] [ 4.8.4l3s ] [ 4.8.5 ] [ 4.9.0 ] [ 4.9.1 ] [ 4.9.1.hpt3 ] [ 4.9.1hpt3 ] [ 4.9.1top1 ] [ 5.0.0 ] [ 5.1.0 ] [ 5.1.0beamonly ] [ 5.1.1 ] [ 5.2.0 ] [ 5.3.0 ] [ 5.3.1 ] [ 5.3.1dsp ] [ 5.3.3 ] [ 5.3.3_nt ] [ 5.3.4 ] [ 6.1.1 ] [ 6.1.1b ] [ 6.1.2 ] [ 6.1.3 ] [ 6.1.4 ] [ 6.1.4int3 ] [ 6.1.4mc ] [ 6.1.4mc_a ] [ 6.1.6 ] [ development ]

 // ---------------------------------------------------------------------------------//
 // track_cut.hh                                                                      //
 // Joe Boudreau, Rick Snider & all                                                  //
 // 10/24/00 - Ray Culbertson, added 3D, hits cuts                                   //
 // 10/29/00 - Petar, added PtLessThan, Phi0InRange
 //                                                                                  //
 //----------------------------------------------------------------------------------//
 #ifndef _track_cut_h_
 #define _track_cut_h_
 #include "TrackingObjects/Tracks/CdfTrack.hh" 
 #include "TrackingObjects/Tracks/CdfTrackCutBase.hh"
 #include <string>
 
 class CdfTrackView;
 class EventRecord;
 template class Handle<CdfTrackView>;
 class Hep3Vector;
 class HepPoint3D;
 
 //
 // Predicates for track selection:
 //
 namespace track_cut {
   class SelectAll;
   class SelectDefault;
   class SelectPadTracks;
   class SelectById;
   class HasHelixFit;
   class SelectAlgorithm;
   class PtGreaterThan;
   class AbsEtaLessThan;
   class EtaLessThan;
   class EtaGreaterThan;
   class InConeAround;
   class D0InRange;
   class D0WrtPointInRange;
   class Z0WrtZInRange;
   class HasOnlyCOTHits;
   class HasCOTHits;
   class HasOnlySIHits;
   class HasSIHits;
   class HasSIHitLayers;
   class HasSVXIIHitLayers;
   class HasStereo;
   class Phi0InRange;
   class PtLessThan;
   class MatchesCdfTrack;
   class StdCOTTrack;
   class StdSiTrack;
   class PhysicalError;
 
   // Free function to fill view with tracks
   // passing PAD selection
   //
   bool padTracks( EventRecord * pEvent,
                   Handle<CdfTrackView> & viewHandle, 
                   std::string processName = "PROD" );
 }
 
 
 //
 // Select By Track Type
 //
 class track_cut::SelectDefault: public CdfTrackCut  
 {
 public:
   SelectDefault( const SelectDefault & right );
   SelectDefault();
   virtual ~SelectDefault();
   virtual SelectDefault * clone( void ) const;
   virtual bool operator ()( const CdfTrack & t ) const;
   using CdfTrackCut::operator();
 private:
   const SelectDefault & operator=( const SelectDefault & right );
 };
 
 // Selection for tracks to be saved in pads. This should become
 // SelectDefault eventually.
 //
 class track_cut::SelectPadTracks: public CdfTrackCut  
 {
 public:
   SelectPadTracks( const SelectPadTracks & right );
   SelectPadTracks();
   virtual ~SelectPadTracks();
   virtual SelectPadTracks * clone( void ) const;
   virtual bool operator ()( const CdfTrack & t ) const;
   using CdfTrackCut::operator();
 private:
   const SelectPadTracks & operator=( const SelectPadTracks & right );
 
   static const int   MIN_CT_HITS_PER_GOOD_SL;
   static const int   MIN_GOOD_AXIAL_SL;
   static const int   MIN_GOOD_STEREO_SL;
   static const float MAX_D0;
   static const float MAX_Z0;
 };
 
 //
 // Select Tracks by Id number
 //
 class track_cut::SelectById: public CdfTrackCut  
 {
 public:
   SelectById( const CdfTrack::Id & id );
   SelectById( const SelectById & right );
   SelectById();
   virtual ~SelectById();
   virtual SelectById * clone( void ) const;
   virtual bool operator ()( const CdfTrack & t ) const;
   using CdfTrackCut::operator();
 private:
   const SelectById & operator=( const SelectById & right );
   CdfTrack::Id _id;
 };
 
 //
 // Select Tracks having 3d helix fits
 //
 class track_cut::HasHelixFit: public CdfTrackCut  
 {
 public:
   HasHelixFit( const HasHelixFit & right );
   HasHelixFit();
   virtual ~HasHelixFit();
   virtual HasHelixFit * clone( void ) const;
   virtual bool operator ()( const CdfTrack & t ) const;
   using CdfTrackCut::operator();
 private:
   const HasHelixFit & operator=( const HasHelixFit & right );
 };
 
 //
 // Select By Track Type
 //
 class track_cut::SelectAlgorithm : public CdfTrackCut  
 {
 public:
   SelectAlgorithm( const SelectAlgorithm & right );
   SelectAlgorithm( const CdfTrack::TrackingAlgorithm & alg );
   virtual ~SelectAlgorithm();
   virtual SelectAlgorithm * clone( void ) const;
   virtual bool operator ()( const CdfTrack & t ) const;
   using CdfTrackCut::operator();
 private:
   const SelectAlgorithm & operator=( const SelectAlgorithm & right );
   CdfTrack::TrackingAlgorithm _alg;
 };
 //
 // Select Tracks above a minimum Pt.
 //
 class track_cut::PtGreaterThan : public CdfTrackCut 
 {
 public:
   PtGreaterThan( double minPt );
   PtGreaterThan( const PtGreaterThan & right );
   virtual ~PtGreaterThan();
   virtual PtGreaterThan * clone( void ) const;
   virtual bool operator ()( const CdfTrack & t ) const;
   using CdfTrackCut::operator();
 private:
   PtGreaterThan();
   const PtGreaterThan & operator=( const PtGreaterThan & right );
   double _minPt; 
 };
 //
 // Select Tracks below a maximum Pt.  Although this cut is rarely used in real
 // analysis, it is still useful for tracking studies (e.g. looking at multiple
 // scattering or high dE/dx)...  (added by Petar)
 //
 class track_cut::PtLessThan : public CdfTrackCut 
 {
 public:
   PtLessThan( double maxPt );
   PtLessThan( const PtLessThan & right );
   virtual ~PtLessThan();
   virtual PtLessThan * clone( void ) const;
   virtual bool operator ()( const CdfTrack & t ) const;
   using CdfTrackCut::operator();
 private:
   PtLessThan();
   const PtLessThan & operator=( const PtLessThan & right );
   double _maxPt; 
 };
 
 //
 // Select tracks below a minimum |eta|
 //
 class track_cut::AbsEtaLessThan : public CdfTrackCut 
 {
 public:
   AbsEtaLessThan( double maxEta );
   AbsEtaLessThan( const AbsEtaLessThan & right );
   virtual ~AbsEtaLessThan();
   virtual AbsEtaLessThan * clone( void ) const;
   virtual bool operator ()( const CdfTrack & t ) const;
   using CdfTrackCut::operator();
 private:
   AbsEtaLessThan();
   const AbsEtaLessThan & operator=( const AbsEtaLessThan & right );
   double _maxEta;
 };
 //
 // Select tracks below a maximim eta
 //
 class track_cut::EtaLessThan : public CdfTrackCut 
 {
 public:
   EtaLessThan( double maxEta );
   EtaLessThan( const EtaLessThan & right );
   virtual ~EtaLessThan();
   virtual EtaLessThan * clone( void ) const;
   virtual bool operator ()( const CdfTrack & t ) const;
   using CdfTrackCut::operator();
 private:
   EtaLessThan();
   const EtaLessThan & operator=( const EtaLessThan & right );
   double _maxEta;
 };
 //
 // Select tracks above a minimum eta
 //
 class track_cut::EtaGreaterThan : public CdfTrackCut 
 {
 public:
   EtaGreaterThan( double maxEta );
   EtaGreaterThan( const EtaGreaterThan & right );
   virtual ~EtaGreaterThan();
   virtual EtaGreaterThan * clone( void ) const;
   virtual bool operator ()( const CdfTrack & t ) const;
   using CdfTrackCut::operator();
 private:
   EtaGreaterThan();
   const EtaGreaterThan & operator=( const EtaGreaterThan & right );
   double _minEta;
 };
 
 //
 // Select tracks within a cone in eta-phi space about a vector
 //
 class track_cut::InConeAround : public CdfTrackCut 
 {
 public:
   InConeAround( const Hep3Vector & direction, double conesize );
   InConeAround( const InConeAround & right );
   virtual ~InConeAround();
   virtual InConeAround * clone( void ) const;
   virtual bool operator ()( const CdfTrack & t ) const;
   using CdfTrackCut::operator();
 private:
   const InConeAround & operator=( const InConeAround & right );
   Hep3Vector   _direction;
   const double _conesize; 
 };
 //
 // Select tracks within a D0 range
 //
 class track_cut::D0InRange : public CdfTrackCut 
 {
 public:
   D0InRange(double  min, double max );
   D0InRange( const D0InRange & right );
   virtual ~D0InRange();
   virtual D0InRange * clone( void ) const;
   virtual bool operator ()( const CdfTrack & t ) const;
   using CdfTrackCut::operator();
 private:
   const D0InRange & operator=( const D0InRange & right );
   const double _min;
   const double _max; 
 };
 //
 // Select tracks within a range of D0 w.r.t a point.
 //
 class track_cut::D0WrtPointInRange : public CdfTrackCut 
 {
 public:
   D0WrtPointInRange( const HepPoint3D & point, double min, double max );
   D0WrtPointInRange( const D0WrtPointInRange & right );
   virtual ~D0WrtPointInRange();
   virtual D0WrtPointInRange * clone( void ) const;
   virtual bool operator ()( const CdfTrack & t ) const;
   using CdfTrackCut::operator();
 private:
   const D0WrtPointInRange & operator=( const D0WrtPointInRange & right );
   const HepPoint3D _point;
   const double     _min;
   const double     _max; 
 };
 
 //
 // Select tracks within a max distance from a z position (associated with a vertex)
 //
 class track_cut::Z0WrtZInRange : public CdfTrackCut 
 {
 public:
   Z0WrtZInRange( double zPoint, double maxDist );
   Z0WrtZInRange( const Z0WrtZInRange & right );
   virtual ~Z0WrtZInRange();
   virtual Z0WrtZInRange * clone( void ) const;
   virtual bool operator ()( const CdfTrack & t ) const;
   using CdfTrackCut::operator();
 private:
   const Z0WrtZInRange & operator=( const Z0WrtZInRange & right );
   const double  _zPoint;
   const double  _maxDist; 
 };
 
 // Select tracks that have no silicon hits
 //
 class track_cut::HasOnlyCOTHits : public CdfTrackCut
 {
 public:
   HasOnlyCOTHits();
   virtual ~HasOnlyCOTHits();
   virtual HasOnlyCOTHits * clone() const;
   virtual bool operator () ( const CdfTrack & t ) const;
   using CdfTrackCut::operator();
 private:
 };
 
 
 //
 // Select tracks within >=minAx axial hits, minSt stereo hits, and
 //  >= minAxSL axial superlayers with >= nAxHit hits and
 //  >= minStSL stereo superlayers with >= nStHit hits 
 //  
 //
 class track_cut::HasCOTHits : public CdfTrackCut 
 {
 public:
   HasCOTHits( int minAx, int minSt, int minAxSL, int minStSL, 
               int nAxHit, int nStHit);
   HasCOTHits( const HasCOTHits & right );
   virtual ~HasCOTHits();
   virtual HasCOTHits * clone( void ) const;
   virtual bool operator ()( const CdfTrack & t ) const;
   using CdfTrackCut::operator();
 private:
   const HasCOTHits & operator=( const HasCOTHits & right );
   const int _minAx;
   const int _minSt;
   const int _minAxSL; 
   const int _minStSL;
   const int _nAxHit;
   const int _nStHit;
 };
 
 
 // Select tracks with non-zero silicon hits, zero COT hits
 //
 class track_cut::HasOnlySIHits : public CdfTrackCut
 {
 public:
   HasOnlySIHits();
   HasOnlySIHits( const HasOnlySIHits & right );
   virtual ~HasOnlySIHits();
   virtual HasOnlySIHits * clone() const;
   virtual bool operator () ( const CdfTrack & t ) const;
   using CdfTrackCut::operator();
 private:
 };
 
 //
 // Select tracks with a min number of total, phi, stereo, z, 
 // and sum of stero and z hits
 //
 class track_cut::HasSIHits : public CdfTrackCut 
 {
 public:
   HasSIHits( int minPhi, int minSt, int minZ, int minStZSum );
   HasSIHits( int minSum );
   HasSIHits( const HasSIHits & right );
   virtual ~HasSIHits();
   virtual HasSIHits * clone( void ) const;
   virtual bool operator ()( const CdfTrack & t ) const;
   using CdfTrackCut::operator();
 private:
   const HasSIHits & operator=( const HasSIHits & right );
   const int _minPhi;
   const int _minSt;
   const int _minZ;
   const int _minStZSum;
   const int _minSum;
 };
 
 //
 // Select tracks with a min number of total layers with, phi, stereo, z, 
 // and sum of stero and z hits
 //
 class track_cut::HasSIHitLayers : public CdfTrackCut 
 {
 public:
   HasSIHitLayers( int minPhi, int minSt, int minZ, int minStZSum );
   HasSIHitLayers( const HasSIHitLayers & right );
   virtual ~HasSIHitLayers();
   virtual HasSIHitLayers * clone( void ) const;
   virtual bool operator ()( const CdfTrack & t ) const;
   using CdfTrackCut::operator();
 private:
   const HasSIHitLayers & operator=( const HasSIHitLayers & right );
   const int _minPhi;
   const int _minSt;
   const int _minZ;
   const int _minStZSum;
 };
 
 //
 // Select tracks with a min number of total SVXII layers with, phi, stereo, z, 
 // and sum of stero and z hits
 //
 class track_cut::HasSVXIIHitLayers : public CdfTrackCut 
 {
 public:
   HasSVXIIHitLayers( int minPhi, int minSt, int minZ, int minStZSum );
   HasSVXIIHitLayers( const HasSVXIIHitLayers & right );
   virtual ~HasSVXIIHitLayers();
   virtual HasSVXIIHitLayers * clone( void ) const;
   virtual bool operator ()( const CdfTrack & t ) const;
   using CdfTrackCut::operator();
 private:
   const HasSVXIIHitLayers & operator=( const HasSVXIIHitLayers & right );
   const int _minPhi;
   const int _minSt;
   const int _minZ;
   const int _minStZSum;
 };
 
 //
 // Select tracks with silicon stereo hits
 //
 class track_cut::HasStereo : public CdfTrackCut 
 {
 public:
   HasStereo();
   HasStereo( const HasStereo & right );
   virtual ~HasStereo();
   virtual HasStereo * clone( void ) const;
   virtual bool operator ()( const CdfTrack & t ) const;
   using CdfTrackCut::operator();
 private:
   const HasStereo & operator=( const HasStereo & right );
 };
 
 //
 // Select tracks with \phi0 in a given range. (Phi0 is an UnsignedAngle, so the
 // domain is between 0 and 2*PI).  This kind of cut is rarely used in an offline analysis,
 // but can be useful for certain studies requiring quick-n-dirty check of fiduciality.
 // For example, to select COT tracks that are fiducial in Barrel 4.  (added by Petar)
 //
 class track_cut::Phi0InRange : public CdfTrackCut 
 {
 public:
   Phi0InRange(double  min, double max);
   Phi0InRange( const Phi0InRange & right );
   virtual ~Phi0InRange();
   virtual Phi0InRange * clone( void ) const;
   virtual bool operator ()( const CdfTrack & t ) const;
   using CdfTrackCut::operator();
 private:
   const Phi0InRange & operator=( const Phi0InRange & right );
   const double _min;
   const double _max; 
   const bool   _includes0;   // if the interval includes 0, which happens when min>max.
 };
 
 
 //
 // Same as CdfTrackSelectAll.  Why Repeat it?  Well, we need to avoid a 
 // circular dependency for one thing, and we want SelectAll to be available
 // in the track_cut namespace for another...
 
 class track_cut::SelectAll : public CdfTrackCut 
 {
 public:
   SelectAll();
   SelectAll( const SelectAll & right );
   virtual ~SelectAll();
   virtual SelectAll * clone( void ) const;
   virtual bool operator ()( const CdfTrack & t ) const;
   using CdfTrackCut::operator();
 private:
   const SelectAll & operator=( const D0InRange & right );
 };
 
 //
 // Select track matching another CdfTrack by hit content.  This is useful (we hope)
 // in algorithm comparison, and is specifically invented for the case in which 
 // regional tracking results are compared to global tracking results.  Added by 
 // Jim Loken and Joe Boudreau
 class track_cut::MatchesCdfTrack : public CdfTrackCut 
 {
 public:
 
   // Enumerated data type used to determine which type of matching is used:
   enum Option {COT_HITS,
                SILICON_HITS,
                COT_AND_SILICON_HITS,
                PARAMETERS};
 
   MatchesCdfTrack( const CdfTrack &, 
                    Option opt=COT_AND_SILICON_HITS, 
                    double minFrac=1.00);
   MatchesCdfTrack( const MatchesCdfTrack & right );
   virtual ~MatchesCdfTrack();
   virtual MatchesCdfTrack * clone( void ) const;
   virtual bool operator ()( const CdfTrack & t ) const;
   using CdfTrackCut::operator();
 
 private:
 
   const MatchesCdfTrack & operator=( const MatchesCdfTrack & right );
 
   const CdfTrack & _track;
   const Option     _option;
   const double     _fraction;
 };
 
 //
 // Select Tracks which pass a standard set of cuts appropriate for
 // tracking studies, but different from the cuts used in SelectPadTracks.
 // The COT tracks and SI tracks have different cuts, but may be combined.
 //
 class track_cut::StdCOTTrack : public CdfTrackCut
 {
 public:
   StdCOTTrack( const StdCOTTrack & right );
   StdCOTTrack();
   virtual ~StdCOTTrack();
   virtual StdCOTTrack * clone( void ) const;
   virtual bool operator ()( const CdfTrack & t ) const;
   using CdfTrackCut::operator();
 private:
   const StdCOTTrack & operator=( const StdCOTTrack & right );
 
   static const int   MIN_CT_HITS_PER_GOOD_SL;
   static const int   MIN_GOOD_AXIAL_SL;
   static const int   MIN_GOOD_STEREO_SL;
   static const int   MIN_TOTAL_CT_HITS;
 };
 
 class track_cut::StdSiTrack : public CdfTrackCut
 {
 public:
   StdSiTrack( const StdSiTrack & right );
   StdSiTrack();
   virtual ~StdSiTrack();
   virtual StdSiTrack * clone( void ) const;
   virtual bool operator ()( const CdfTrack & t ) const;
   using CdfTrackCut::operator();
 private:
   const StdSiTrack & operator=( const StdSiTrack & right );
 
   static const int   MIN_AXIAL_SI_HITS;
 };
 
 //
 // Select Tracks with physical fit covariance matrices.
 // (Positive definite diagonal elements)
 //
 class track_cut::PhysicalError : public CdfTrackCut 
 {
 public:
   PhysicalError();
   PhysicalError( const PhysicalError & right );
   virtual ~PhysicalError();
   virtual PhysicalError * clone( void ) const;
   virtual bool operator ()( const CdfTrack & t ) const;
   using CdfTrackCut::operator();
 private:
   const PhysicalError & operator=( const PhysicalError & right );
 };
 
 
 #include "TrackingObjects/Tracks/track_cut.icc"
 
 #endif
 
 
 

This page was automatically generated by the LXR engine. The LXR team