MathTools/interface/HelixIntersector.h

//--------------------------------------------------------------------------------------------------
// $Id: HelixIntersector.h,v 1.1 2008/09/17 04:01:50 loizides Exp $
//
// Class HelixIntersector
//
// Finds the intersection of two tracks, it they do not intersect it finds the point of closest
// approach.
//
// Author List: C.Paus (stolen from CDF implementation of E. Lipeles,
//                      therefore not all our coding conventions fulfilled) 
//--------------------------------------------------------------------------------------------------

#ifndef MITCOMMON_MATHTOOLS_HELIXINTERSECTOR_H
#define MITCOMMON_MATHTOOLS_HELIXINTERSECTOR_H

#include <iostream>
#include "MitCommon/MathTools/interface/Helix.h"

namespace mithep 
{
  class HelixIntersector {

    public:
      //--------------------------------------------------------------------------------------------
      // Class for track properties at intersection
      //--------------------------------------------------------------------------------------------
      class Intersection;
      class TrackParams : public Helix
      {
          friend class HelixIntersector;
          friend class HelixIntersector::Intersection;

        public:
          // Sets the track and calculates center
          TrackParams(const TVectorD *params, const TVector3 *momentum);

          const  TVector3 &Momentum              () const { return fMomentum; }
          const  TVector3 &Center                () const { return fCenter;   }
          double           ArcLengthToInterection() const { return fArcLen;   }
          double           ZAtIntersection       () const { return fZAtISec;  }

        private:
          // Make it illegal to copy or assign
          TrackParams(const TrackParams &);
          TrackParams & operator = (const TrackParams &);
    
          // Calculates the location dependent quantities at the specified location
          void             SetLocation           (TVector3 &location);

          // Data
          TVector3         fMomentum;
          TVector3         fCenter;
          double           fArcLen;
          double           fZAtISec;
          TVector3         fTrkMom;
      };  

      //--------------------------------------------------------------------------------------------
      // Class for Intesection results
      //--------------------------------------------------------------------------------------------
      class Intersection
      {
          friend class HelixIntersector;

        public:
          // Properties of the vertex
          const TVector3    &Location() const { return fLocation; }
          double             DeltaZ  () const { return fDeltaZ; }
    
          // Combined momenta of the two tracks
          const TVector3    &Momentum() const { return fMomentum; }
    
          // Properties of the vertex daughters
          // i = 0 or 1 for the two daughters
          const TrackParams &TrackParamsI(int i) const { return *(fTrks[i]); }
    
        private:
          Intersection(const TVectorD *tr1, const TVector3 *momentum1,
                       const TVectorD *tr2, const TVector3 *momentum2);
    
          void               SetLocation(TVector3 &loc1, TVector3 &loc2);

          double             fDeltaZ;
          TVector3           fLocation;
          TVector3           fMomentum;
          TrackParams       *fTrks[2];
          TrackParams        fTrk0;
          TrackParams        fTrk1;
      };

      //--------------------------------------------------------------------------------------------
      // HelixIntersector methods
      //--------------------------------------------------------------------------------------------
      // Constructors, does intersection work
      HelixIntersector(const TVectorD *tr1, const TVector3 *momentum1,
                       const TVectorD *tr2, const TVector3 *momentum2);

      // Destructor
      ~HelixIntersector();

      // Intersections or points of closest approach
      //   i = 0 or 1 (1 only if there are real intersections)
      //   ordered by deltaZ (so in general you only want i=0);
      const Intersection& IntersectionI(int i) const { return *(fISecs[i]); }

      // Has intersections
      bool                HasIntersections() const { return fHasIntersections; }

    private:
      // Make it illegal to copy or assign
      HelixIntersector(const HelixIntersector &);
      HelixIntersector   &operator = (const HelixIntersector &);
  
      bool                fHasIntersections;
      Intersection       *fISecs[2];
      Intersection        fISec0;
      Intersection        fISec1;
  };
}
#endif
Revision:	1.2
Committed:	Fri Mar 20 13:33:19 2009 UTC (16 years, 1 month ago) by loizides
Content type:	text/plain
Branch:	MAIN
CVS Tags:	Mit_009c, Mit_009b, Mit_009a, Mit_009
Changes since 1.1:	+5 -5 lines
Log Message:	Cleanup
#	User	Rev	Content
1	loizides	1.1	//--------------------------------------------------------------------------------------------------
2	loizides	1.2	// $Id: HelixIntersector.h,v 1.1 2008/09/17 04:01:50 loizides Exp $
3	loizides	1.1	//
4			// Class HelixIntersector
5			//
6			// Finds the intersection of two tracks, it they do not intersect it finds the point of closest
7			// approach.
8			//
9	loizides	1.2	// Author List: C.Paus (stolen from CDF implementation of E. Lipeles,
10			// therefore not all our coding conventions fulfilled)
11	loizides	1.1	//--------------------------------------------------------------------------------------------------
12
13			#ifndef MITCOMMON_MATHTOOLS_HELIXINTERSECTOR_H
14			#define MITCOMMON_MATHTOOLS_HELIXINTERSECTOR_H
15
16			#include <iostream>
17			#include "MitCommon/MathTools/interface/Helix.h"
18
19			namespace mithep
20			{
21			class HelixIntersector {
22
23			public:
24			//--------------------------------------------------------------------------------------------
25			// Class for track properties at intersection
26			//--------------------------------------------------------------------------------------------
27			class Intersection;
28			class TrackParams : public Helix
29			{
30			friend class HelixIntersector;
31			friend class HelixIntersector::Intersection;
32
33			public:
34			// Sets the track and calculates center
35			TrackParams(const TVectorD params, const TVector3 momentum);
36
37	loizides	1.2	const TVector3 &Momentum () const { return fMomentum; }
38			const TVector3 &Center () const { return fCenter; }
39	loizides	1.1	double ArcLengthToInterection() const { return fArcLen; }
40			double ZAtIntersection () const { return fZAtISec; }
41
42			private:
43			// Make it illegal to copy or assign
44			TrackParams(const TrackParams &);
45			TrackParams & operator = (const TrackParams &);
46
47			// Calculates the location dependent quantities at the specified location
48			void SetLocation (TVector3 &location);
49
50			// Data
51			TVector3 fMomentum;
52			TVector3 fCenter;
53			double fArcLen;
54			double fZAtISec;
55			TVector3 fTrkMom;
56			};
57
58			//--------------------------------------------------------------------------------------------
59			// Class for Intesection results
60			//--------------------------------------------------------------------------------------------
61			class Intersection
62			{
63			friend class HelixIntersector;
64
65			public:
66			// Properties of the vertex
67			const TVector3 &Location() const { return fLocation; }
68			double DeltaZ () const { return fDeltaZ; }
69
70			// Combined momenta of the two tracks
71			const TVector3 &Momentum() const { return fMomentum; }
72
73			// Properties of the vertex daughters
74			// i = 0 or 1 for the two daughters
75			const TrackParams &TrackParamsI(int i) const { return *(fTrks[i]); }
76
77			private:
78			Intersection(const TVectorD tr1, const TVector3 momentum1,
79			const TVectorD tr2, const TVector3 momentum2);
80
81			void SetLocation(TVector3 &loc1, TVector3 &loc2);
82
83			double fDeltaZ;
84			TVector3 fLocation;
85			TVector3 fMomentum;
86			TrackParams *fTrks[2];
87			TrackParams fTrk0;
88			TrackParams fTrk1;
89			};
90
91			//--------------------------------------------------------------------------------------------
92			// HelixIntersector methods
93			//--------------------------------------------------------------------------------------------
94			// Constructors, does intersection work
95			HelixIntersector(const TVectorD tr1, const TVector3 momentum1,
96			const TVectorD tr2, const TVector3 momentum2);
97
98			// Destructor
99			~HelixIntersector();
100
101			// Intersections or points of closest approach
102			// i = 0 or 1 (1 only if there are real intersections)
103			// ordered by deltaZ (so in general you only want i=0);
104			const Intersection& IntersectionI(int i) const { return *(fISecs[i]); }
105
106			// Has intersections
107			bool HasIntersections() const { return fHasIntersections; }
108
109			private:
110			// Make it illegal to copy or assign
111			HelixIntersector(const HelixIntersector &);
112			HelixIntersector &operator = (const HelixIntersector &);
113
114			bool fHasIntersections;
115			Intersection *fISecs[2];
116			Intersection fISec0;
117			Intersection fISec1;
118			};
119			}
120			#endif