// -*- mode: c++ -*- //_______________________________________________________________________ // // BrSpectrometerTracks // // BRAHMS Spectrometer Track class // These track are the final result from the combine track and // matching algorithms. The only contain members of the classes // BrMatchedTrack and BrDetectorTrack. The BrDetectorTrack is in // fact the local tracks from the various detectors. // // Author : F.Videbaek videbaek@bnl.gov // Created : 24-Oct-1998 // Version : 1.0 // Changed : 07-Nov-1998 // // //________________________________________________________________________ // // $Id: BrSpectrometerTracks.h,v 1.16 2002/09/06 12:45:38 pchristi Exp $ // $Author: pchristi $ // $Date: 2002/09/06 12:45:38 $ // #ifndef BRAT_BrSpectrometerTracks #define BRAT_BrSpectrometerTracks #define NOTYET #ifndef ROOT_TObject #include "TObject.h" #endif #ifndef BRAT_BrDetectorTrack #include "BrDetectorTrack.h" #endif #ifndef BRAT_BrDetectorVolume #include "BrDetectorVolume.h" #endif #ifndef BRAT_BrMagnetVolume #include "BrMagnetVolume.h" #endif #ifndef BRAT_BrDetectorParamsTof #include "BrDetectorParamsTof.h" #endif //________________________________________________________________________ class BrMatchedTrack : public TObject { private: BrDetectorTrack fFrontTrack; // pointer to front track BrDetectorTrack fBackTrack; // pointer to back track UShort_t fStatus; // Status word (uses bits) UShort_t fTrackGroup; // group number ie. possible ghosttracks belongs to same group. Float_t fMomentum; // Momentum through this magnet Float_t fDang; // Actual value for match in angle Float_t fDaly; // Actual value for match in dy/dz Float_t fDy; // Actual difference for match in vertical position Float_t fPathLength; // matched track length Float_t fMatchChisq; // Chisq for the matching conditions. BrVector3D fEntrance; // Position at magnet entrance (Gap) in global c.s. BrVector3D fExit; // Position at magnet exit (Gap) in global c.s public: enum status {kOk=1, kGhostCandidate=2 , kSigmaCut=4, kFiducialCut=8, kVirtual=16}; BrMatchedTrack(); virtual ~BrMatchedTrack(); //Setter functions void SetID(Int_t i) { SetUniqueID(i); } void SetId(Int_t i) { SetUniqueID(i); } void SetTrackId(Int_t i) { SetUniqueID(i); } void SetP(Double_t p) { fMomentum= p; } void SetMomentum(Double_t p) { fMomentum= p; } void SetExit(BrVector3D v) { fExit = v; } void SetEntrance(BrVector3D v) { fEntrance = v; } void SetDang(Double_t a) { fDang = a; } void SetDaly(Double_t a) { fDaly = a; } void SetDy(Double_t a) { fDy = a; } void SetFrontTrack(BrDetectorTrack* trackp) { fFrontTrack = *trackp; } void SetBackTrack(BrDetectorTrack* trackp) { fBackTrack = *trackp; } void SetStatus(Int_t i) { fStatus = fStatus | i;} void SetMatchedTrackLength(Double_t l) { fPathLength = l; } void SetPathLength(Double_t l) { fPathLength = l; } void SetTrackGroup(Int_t group) { fTrackGroup = group;} void SetMatchChisq(Double_t chisq) { fMatchChisq = chisq;} //Getter functions Int_t GetID() const { return GetUniqueID();} Int_t GetId() const { return GetUniqueID();} Int_t GetTrackId() const { return GetUniqueID();} BrDetectorTrack* GetFrontTrack() const { return (BrDetectorTrack*) &fFrontTrack;} BrDetectorTrack* GetBackTrack() const { return (BrDetectorTrack*) &fBackTrack;} Int_t GetFrontTrackID() const { return fFrontTrack.GetID();} Int_t GetBackTrackID() const { return fBackTrack.GetID();} Double_t GetP() const { return fMomentum;} Double_t GetMomentum() const { return fMomentum;} Int_t GetStatus() const { return fStatus;} Double_t GetDang() const { return fDang;} Double_t GetDaly() const { return fDaly;} Double_t GetDy() const { return fDy;} Double_t GetEntranceX() const { return fEntrance.GetX();} Double_t GetEntranceY() const { return fEntrance.GetY();} Double_t GetEntranceZ() const { return fEntrance.GetZ();} BrVector3D GetEntrance() const { return fEntrance;} Double_t GetExitX() const { return fExit.GetX();} Double_t GetExitY() const { return fExit.GetY();} Double_t GetExitZ() const { return fExit.GetZ();} BrVector3D GetExit() const { return fExit;} Double_t GetPathLength() const { return fPathLength; } Double_t GetMatchedTrackLength() const { return fPathLength; } Double_t GetMatchChisq() const { return fMatchChisq;} virtual void Print(Option_t* op = "") const; // *MENU* ClassDef(BrMatchedTrack,2) // Matched tracks through one magnet class }; //________________________________________________________________________ class BrGlbTrack : public TObject { // members protected: Short_t fPointedSlat; // pointed slat on closest tof plane Float_t fTheta; // polar angle in deg. Float_t fPhi; // azimuthal angle in deg. Float_t fPathLength; // path length in cm Float_t fPartialPath; // D1 to H1 for ffs, TPM1 to TOFW for mrs, front chamber to H2 for bfs BrMatchedTrack fMatchedTrack; // T(PM)1 - D(1,5) -T(PM)2 matched track BrVector3D fProjOnTof; // Track projection on tof plane BrVector3D fTrackVertex; // track vertex (intersection with beam line for Mrs) // intersection with BB plane for Ffs public: BrGlbTrack(); virtual ~BrGlbTrack(); // for backward compatibilty, keep some old methods // setters void SetTrackId(Int_t id) { SetUniqueID(id); } void SetId(Int_t id) { SetUniqueID(id); } void SetTheta(Float_t theta) { fTheta = theta;} void SetPhi(Float_t phi) { fPhi = phi;} void SetMatchedTrack(BrMatchedTrack* t) { fMatchedTrack = *t;} void SetPointedSlat(Int_t slat) { fPointedSlat = slat; } void SetProjOnTof(BrVector3D v) { fProjOnTof = v; } void SetProjOnTofPlane(BrVector3D v) { fProjOnTof = v; } void SetPathLength(Float_t l) { fPathLength = l;} void SetTrackVertex(BrVector3D vtx) { fTrackVertex = vtx; } void SetPartialPath(Float_t l) { fPartialPath = l; } void SetTx(Float_t x) { fTrackVertex.SetX(x); } void SetTy(Float_t y) { fTrackVertex.SetY(y); } void SetTz(Float_t z) { fTrackVertex.SetZ(z); } // getters Int_t GetTrackId() const { return GetUniqueID(); } Int_t GetId() const { return GetUniqueID(); } Int_t GetPointedSlat() const { return fPointedSlat; } Int_t GetStatus() const { return fMatchedTrack.GetStatus(); } Float_t GetTheta() const { return fTheta; } Float_t GetPhi() const { return fPhi; } Float_t GetPathLength() const { return fPathLength;} Float_t GetPartialPath() const { return fPartialPath;} Double_t GetMatchChisq() const { return fMatchedTrack.GetMatchChisq(); } BrVector3D GetProjOnTof() const { return fProjOnTof; } BrVector3D GetTrackVertex() const { return fTrackVertex; } BrVector3D GetEntrance() const { return fMatchedTrack.GetEntrance(); } // local to mag BrVector3D GetExit() const { return fMatchedTrack.GetExit();} // local to mag BrMatchedTrack* GetMatchedTrack() const { return (BrMatchedTrack*) &fMatchedTrack;} BrDetectorTrack* GetFrontTrack() const { return fMatchedTrack.GetFrontTrack(); } BrDetectorTrack* GetBackTrack() const { return fMatchedTrack.GetBackTrack(); } Float_t GetTx() const { return fTrackVertex(0); } Float_t GetTy() const { return fTrackVertex(1); } Float_t GetTz() const { return fTrackVertex(2); } Float_t RelativeOverlap(const BrGlbTrack*, Float_t z1, Float_t z2, Float_t r1, Float_t r2); virtual Float_t GetMomentum() const { return fMatchedTrack.GetMomentum();} virtual void SetMomentum(Float_t p) { fMatchedTrack.SetMomentum(p); } ClassDef(BrGlbTrack, 1) // base class for BrMrsTrack and BrFfsTrack }; //________________________________________________________________________ class BrFfsTrack : public BrGlbTrack { private: Bool_t fD1SwimStatus; // swim back status through D1 (cf Magnet volume) BrLine3D fD1EntranceLine; // entrance direction on D1 front plane (global c.s) BrLine3D fD1ExitLine; // same for exit direction public: BrFfsTrack(); virtual ~BrFfsTrack(); void SetD1EntranceLine(BrLine3D l) { fD1EntranceLine = l; } void SetD1ExitLine(BrLine3D l) { fD1ExitLine = l; } void SetD1H1PathLength(Double_t l) { SetPartialPath(l); } void SetD1SwimStatus(Bool_t b) { fD1SwimStatus = b; } // getter functions: Bool_t GetD1SwimStatus() const { return fD1SwimStatus; } // D1 magnet stuff BrLine3D GetD1EntranceLine() const { return fD1EntranceLine; } // global BrLine3D GetD1ExitLine() const { return fD1ExitLine; } // global BrVector3D GetEntranceD1() const { return fD1EntranceLine.GetOrigin(); } // global BrVector3D GetEntranceD1X() const { return fD1EntranceLine.GetOrigin()[0]; } // global BrVector3D GetEntranceD1Y() const { return fD1EntranceLine.GetOrigin()[1]; } // global BrVector3D GetEntranceD1Z() const { return fD1EntranceLine.GetOrigin()[2]; } // global BrVector3D GetExitD1() const { return fD1ExitLine.GetOrigin();} // global BrVector3D GetExitD1X() const { return fD1ExitLine.GetOrigin()[0];} // global BrVector3D GetExitD1Y() const { return fD1ExitLine.GetOrigin()[1];} // global BrVector3D GetExitD1Z() const { return fD1ExitLine.GetOrigin()[2];} // global // D2 magnet stuff BrVector3D GetEntranceD2() const { return GetEntrance(); } // local to D2 BrVector3D GetEntranceD2X() const { return GetEntrance()[0]; } // local to D2 BrVector3D GetEntranceD2Y() const { return GetEntrance()[1]; } // local to D2 BrVector3D GetEntranceD2Z() const { return GetEntrance()[2]; } // local to D2 BrVector3D GetExitD2() const { return GetExit();} // local to D2 BrVector3D GetExitD2X() const { return GetExit()[0];} // local to D2 BrVector3D GetExitD2Y() const { return GetExit()[1];} // local to D2 BrVector3D GetExitD2Z() const { return GetExit()[2];} // local to D2 Double_t GetD1H1PathLength() const { return GetPartialPath(); } Double_t GetD1ToTOF1TrackLength() const { return GetPartialPath(); } virtual void Print(Option_t* op = "") const; // *MENU* ClassDef(BrFfsTrack, 1) // BRAHMS new Ffs Spectrometer Class }; //________________________________________________________________________ class BrMrsTrack : public BrGlbTrack { private: Short_t fPointedPanel; public: BrMrsTrack(); virtual ~BrMrsTrack(); // setters void SetTpm1TofwPathLength(Double_t l) { SetPartialPath(l); } void SetTPM1ToTOFWTrackLength(Double_t l) { SetPartialPath(l); } void SetPointedPanel(Int_t p) { fPointedPanel = p; } // getters Float_t GetTpm1TofwPathLength() const { return GetPartialPath();} Float_t GetTPM1ToTOFWPathLength() const { return GetPartialPath();} Float_t GetFrontTrackLength() const { return fPathLength - fPartialPath;} Int_t GetPointedPanel() const { return fPointedPanel;} virtual void Print(Option_t* op = "") const; // *MENU* ClassDef(BrMrsTrack, 1) // BRAHMS new MRS Spectrometer Class }; //---------------------------------------------------------- // class BrBfsTrack : public BrGlbTrack { private: BrMatchedTrack fFrontMatchedTrack; // matched track between T2/T3 and T4 Short_t fTof1PointedSlat; // slat pointed by this projection Bool_t fT2WasUsed; // flag to know which front chamber was used BrVector3D fProjOnTof1; public: BrBfsTrack(); virtual ~BrBfsTrack(); // for backward compatibility, some methods remain but the work is done // by the base class. // the matched track in the base class is used for T4-T5 // the only extra stuff here is the T2/T3 - T4 track // and some TOF1 info for an eventual H2 - H1 pid // setters void SetBfsFrontTrack(BrMatchedTrack* t) { fFrontMatchedTrack = *t; } void SetBfsBackTrack(BrMatchedTrack* t) { fMatchedTrack = *t; } void SetT2WasUsed(Bool_t b) { fT2WasUsed = b; } void SetTof1PointedSlat(Int_t s) { fTof1PointedSlat = s; } virtual void SetProjOnTof1(BrVector3D v) { fProjOnTof1 = v; } virtual void SetProjOnTof1(Float_t x, Float_t y, Float_t z) { fProjOnTof1.SetX(x); fProjOnTof1.SetY(y); fProjOnTof1.SetZ(z); } // getters BrMatchedTrack* GetBfsBackTrack() const { return GetMatchedTrack(); } BrDetectorTrack* GetBackDetectorTrack() const { return GetBackTrack(); } BrVector3D GetProjOnTofPlane() const { return GetProjOnTof(); } // in local H2 vol. BrVector3D GetProjOnTof1() const { return fProjOnTof1; } // in local H1 vol. // --- obsolete ---- void SetD1SwimStatus(Bool_t b) {} void SetD2SwimStatus(Bool_t b) {} void SetMomentum(Float_t f) {} Bool_t GetD1SwimStatus() const { return kTRUE; } Bool_t GetD2SwimStatus() const { return kTRUE; } // ----------------- BrDetectorTrack* GetFrontDetectorTrack() const { return fFrontMatchedTrack.GetFrontTrack(); } BrMatchedTrack* GetBfsFrontTrack() const { return (BrMatchedTrack*) &fFrontMatchedTrack; } Int_t GetTof1PointedSlat() const { return fTof1PointedSlat; } virtual Float_t GetMomentum() const { return (GetD3Momentum() + GetD4Momentum()) / 2; } Int_t GetD3Status() const { return fFrontMatchedTrack.GetStatus(); } Int_t GetD4Status() const { return GetStatus(); } Float_t GetD3Momentum() const { return fFrontMatchedTrack.GetMomentum(); } Float_t GetD4Momentum() const { return fMatchedTrack.GetMomentum(); } Float_t GetD3MatchChisq() const { return fFrontMatchedTrack.GetMatchChisq(); } Float_t GetD4MatchChisq() const { return GetMatchChisq(); } BrVector3D GetEntranceD3() const { return fFrontMatchedTrack.GetEntrance(); } BrVector3D GetEntranceD4() const { return GetEntrance(); } BrVector3D GetExitD3() const { return fFrontMatchedTrack.GetExit(); } BrVector3D GetExitD4() const { return GetExit(); } Bool_t T2WasUsed() const { return fT2WasUsed; } virtual void Print(Option_t* op = "") const; // *MENU* ClassDef(BrBfsTrack, 7) // BRAHMS BFS Spectrometer Class }; //---------------------------------------------------------- // class BrFsTrack : public TObject { // this class doesn't derive from BrGlbTrack because it doesn't need // it gathers FFS and BFS track information. If BFS could not find // any FFS track, it is swimmed back to the primary vertex in the // FS tracking module private: BrFfsTrack* fFfsTrack; //! pointer to FFS track BrBfsTrack* fBfsTrack; //! pointer to FFS track Short_t fFfsTrackId; // id of FFS track Short_t fBfsTrackId; // id of BFS track Float_t fMomentum; // average momentum BrVector3D fTrackVertex; // track vertex (projection on BB vtx plane) BrVector3D fTof2Proj; // projection on Tof2 (local) BrVector3D fTof1Proj; // projection on Tof1 (local) Float_t fPathLength; // path length Bool_t fD1Status; // swim status in D1 Float_t fPhi; // azimuthal angle Float_t fTheta; // polar angle Short_t fTof1Slat; // H1 pointed slat Short_t fTof2Slat; // H2 pointed slat public: BrFsTrack(); ~BrFsTrack(); // setters void SetFfsTrack(BrFfsTrack* ffs) { fFfsTrack = ffs; } void SetBfsTrack(BrBfsTrack* bfs) { fBfsTrack = bfs; } void SetBfsTrackId(Int_t id) { fBfsTrackId = id; } void SetFfsTrackId(Int_t id) { fFfsTrackId = id; } void SetMomentum(Float_t p) { fMomentum = p; } void SetPathLength(Float_t l) { fPathLength = l; } void SetTrackVertex(BrVector3D v) { fTrackVertex = v; } void SetTof1Slat(Int_t s) { fTof1Slat = s; } void SetTof2Slat(Int_t s) { fTof2Slat = s; } void SetTof1Proj(BrVector3D v) { fTof1Proj = v; } void SetTof2Proj(BrVector3D v) { fTof2Proj = v; } void SetProjOnTof1(BrVector3D v) { fTof1Proj = v; } void SetProjOnTof2(BrVector3D v) { fTof2Proj = v; } void SetD1SwimStatus(Bool_t s) { fD1Status = s; } void SetD1Status(Bool_t s) { fD1Status = s; } void SetTrackId(Int_t i) { SetUniqueID(i); } void SetId(Int_t i) { SetUniqueID(i); } void SetID(Int_t i) { SetUniqueID(i); } void SetPhi(Float_t phi) { fPhi = phi; } void SetTheta(Float_t theta) { fTheta = theta; } // getters BrFfsTrack* GetFfsTrack() const { return fFfsTrack; } BrBfsTrack* GetBfsTrack() const { return fBfsTrack; } Int_t GetFfsTrackId() const { return fFfsTrackId; } Int_t GetBfsTrackId() const { return fBfsTrackId; } Float_t GetMomentum() const { return fMomentum; } Float_t GetPathLength() const { return fPathLength; } BrVector3D GetTrackVertex() const { return fTrackVertex; } BrVector3D GetTof1Proj() const { return fTof1Proj; } BrVector3D GetTof2Proj() const { return fTof2Proj; } BrVector3D GetProjOnTof1() const { return fTof1Proj; } BrVector3D GetProjOnTof2() const { return fTof2Proj; } Bool_t GetD1SwimStatus() const { return fD1Status; } Bool_t GetD1Status() const { return fD1Status; } Int_t GetTrackId() const { return GetUniqueID(); } Int_t GetId() const { return GetUniqueID(); } Int_t GetID() const { return GetUniqueID(); } Float_t GetPhi() const { return fPhi; } Float_t GetTheta() const { return fTheta; } Int_t GetTof1Slat() const { return fTof1Slat; } Int_t GetTof2Slat() const { return fTof2Slat; } virtual void Print(Option_t* op = "") const; // *MENU* ClassDef(BrFsTrack, 1) // BRAHMS FS Spectrometer Class }; //________________________________________________________________________ //________________________________________________________________________ // OLD class //________________________________________________________________________ class BrFSTrack : public TObject { public: BrFSTrack(); virtual ~BrFSTrack(); //Setter functions virtual void SetId(Int_t id) {fId = id;} virtual void SetTrack12(BrMatchedTrack *track) {fTrack12 = *track;} virtual void SetTrack34(BrMatchedTrack *track) {fTrack34 = *track;} virtual void SetTrack45(BrMatchedTrack *track) {fTrack45 = *track;} virtual void SetTrackT2(BrDetectorTrack *track) {fTrackT2 = *track;} virtual void SetTrackT3(BrDetectorTrack *track) {fTrackT3 = *track;} virtual void SetTrackT4(BrDetectorTrack *track) {fTrackT4 = *track;} virtual void SetTrackT5(BrDetectorTrack *track) {fTrackT5 = *track;} virtual void SetTrackT1(BrDetectorTrack *track) {fTrackT1 = *track;} virtual void SetMomentum(Double_t p) { fMomentum = p;} virtual void SetP(Double_t p) { fMomentum = p;} virtual void SetPhi(Double_t phi) { fPhi = phi;} virtual void SetTheta(Double_t theta) { fTheta = theta;} virtual void SetStatus(Int_t status) { fStatus = status;} virtual void SetQuality(Double_t quality) { fQuality = quality;} virtual void SetTx(Double_t tx) { fTx = tx;} virtual void SetTy(Double_t ty) { fTy = ty;} virtual void SetDxT2(Double_t dxt2) { fDxT2 = dxt2;} virtual void SetDyT2(Double_t dyt2) { fDyT2 = dyt2;} virtual void SetDaxT2(Double_t daxt2) { fDaxT2 = daxt2;} virtual void SetDayT2(Double_t dayt2) { fDayT2 = dayt2;} virtual void SetEntranceD1X(Double_t x) { fEntranceD1X = x;} virtual void SetEntranceD1Y(Double_t y) { fEntranceD1Y = y;} virtual void SetExitD1X(Double_t x) { fExitD1X = x;} virtual void SetExitD1Y(Double_t y) { fExitD1Y = y;} virtual void SetEntranceD2X(Double_t x) { fEntranceD2X = x;} virtual void SetEntranceD2Y(Double_t y) { fEntranceD2Y = y;} virtual void SetExitD2X(Double_t x) { fExitD2X = x;} virtual void SetExitD2Y(Double_t y) { fExitD2Y = y;} virtual void SetVx(Double_t x) { fVx = x;} virtual void SetVy(Double_t y) { fVy = y;} //Getter functions Int_t GetId() { return fId;} BrMatchedTrack* GetTrack12() { return &fTrack12;} BrMatchedTrack* GetTrack34() { return &fTrack34;} BrMatchedTrack* GetTrack45() { return &fTrack45;} BrDetectorTrack* GetTrackT2() { return &fTrackT2;} BrDetectorTrack* GetTrackT3() { return &fTrackT3;} BrDetectorTrack* GetTrackT4() { return &fTrackT4;} BrDetectorTrack* GetTrackT5() { return &fTrackT5;} BrDetectorTrack* GetTrackT1() { return &fTrackT1;} const BrDetectorTrack* GetTtr(int i) const; Double_t GetMomentum() { return fMomentum;} Double_t GetP() { return fMomentum;} Double_t GetPhi() { return fPhi;} Double_t GetTheta() { return fTheta;} Int_t GetStatus() { return fStatus;} Double_t GetQuality() { return fQuality;} Double_t GetTx() { return fTx;} Double_t GetTy() { return fTy;} Double_t GetDxT2() { return fDxT2;} Double_t GetDyT2() { return fDyT2;} Double_t GetDaxT2() { return fDaxT2;} Double_t GetDayT2() { return fDayT2;} Double_t GetEntranceD1X() { return fEntranceD1X;} Double_t GetEntranceD1Y() { return fEntranceD1Y;} Double_t GetExitD1X() { return fExitD1X;} Double_t GetExitD1Y() { return fExitD1Y;} Double_t GetEntranceD2X() { return fEntranceD2X;} Double_t GetEntranceD2Y() { return fEntranceD2Y;} Double_t GetExitD2X() { return fExitD2X;} Double_t GetExitD2Y() { return fExitD2Y;} Double_t GetVx() { return fVx;} Double_t GetVy() { return fVy;} private: // I first thought to keep both a pointer as well as a unique // ID of local tracks // After a while my suggestion is to imbed the actual // best track into the structure // This will make analysis tasks later on much simpler. // Will have to implement proper copy constructors. // // The matched tracks do not contain the detector traks only // two ID's so it there is only little redundancy here. // // Estimated size // 2*36 bytes + 4*20 bytes (needs update) Int_t fId; BrMatchedTrack fTrack12; // Matched track in D2 BrMatchedTrack fTrack34; // Matched track in D3 BrMatchedTrack fTrack45; // Matched track in D4 BrDetectorTrack fTrackT2; // Matched Detector track in T2 BrDetectorTrack fTrackT3; // Actual track in T3 BrDetectorTrack fTrackT4; // Actual track in T4 BrDetectorTrack fTrackT5; // Actual track in T5 BrDetectorTrack fTrackT1; // Actual track in T1 // (may/ may not be filled properly! or empty) // This is q question how to do. Double_t fMomentum; // Momentum as derived from D3,D4; Double_t fPhi; // Azimuth angle of track Double_t fTheta; // Polar angle of Track Int_t fStatus; // Status variables (to be defined...) Double_t fQuality; // Quality factor (to be defined) Double_t fTx; // projected vertex position // (at nominal z=0 plane in spec systeM) Double_t fTy; // as above but for Y. Double_t fDxT2; // Matching deviation in T2; horizontal position Double_t fDyT2; // Matching deviation in T2; vertical position Double_t fDaxT2; // Matching deviation in T2; slope dx/dz Double_t fDayT2; // Matching deviation in T2; slope dy/dz Double_t fEntranceD1X; // Entrance position for track in D1 Double_t fEntranceD1Y; // Note that the positions for the other magnets Double_t fExitD1X; // are given in the matched tracks Double_t fExitD1Y; Double_t fEntranceD2X; Double_t fEntranceD2Y; Double_t fExitD2X; Double_t fExitD2Y; Double_t fVx;// projected nominal vertex (x) (at z=0 in spectrometer system) Double_t fVy;// projected nominal vertex (y) (at z=0 in spectrometer system) ClassDef(BrFSTrack,1) // BRAHMS Frward Spectrometer Class }; #endif // // $Log: BrSpectrometerTracks.h,v $ // Revision 1.16 2002/09/06 12:45:38 pchristi // Fixed bug in spectrometer tracks // // Revision 1.15 2002/08/30 17:37:58 videbaek // Added Pront method to BrMatchedTracks. This method // will also be called from Mrs track printing with A. // // Revision 1.14 2002/04/09 02:02:06 ouerdane // updated BrBfsTrack and introduced new class BrFsTrack // // Revision 1.13 2002/03/06 21:03:54 ekman // BrBfsTrack: Removed fBfsMomentum member. Changed GetMomentum method to return the average // of D3 and D4 momentum (as it was before...because it was right!). Changed SetMomentum // methods to MayNotUse since it doesn't make sense. // // Revision 1.12 2002/03/01 11:55:32 ufstasze // Class version number incremented by 1. // // Revision 1.11 2002/03/01 10:27:07 ufstasze // Found bug in BrBfsTrack. To removed it added // one float private member to BrBfsTrack (fBfsMomentum) and // two public methods to set and retrieve it: // SetMomentum() and GetMomentum(). // // Revision 1.10 2001/12/20 15:27:25 ouerdane // Added a new status bit in BrMatchedTrack: kVirtual (bit = 16) for BFS tracking (cf BrBfsTrackingModule) // // Revision 1.9 2001/12/13 12:34:32 ouerdane // Added magnet swim back status (D1 and D2) and projection on H1 in BrBfsTrack // // Revision 1.8 2001/11/05 06:50:43 ouerdane // changed the spectrometer track classes and updated the matched track to deal with these new classes // // Revision 1.7 2001/10/19 15:25:13 ouerdane // Added member fD1SwimStatus and getter method in BrFfsTrack, version numer is now 4 // // Revision 1.6 2001/10/02 10:46:08 brahmlib // Fixed small mistake in BrFfsTrack // // Revision 1.5 2001/10/02 01:50:56 ouerdane // Added track length and vertex(Brvector3D) member in all classes except BrBfsTrack for the vertex // Incremented version number (2->3 for MRS, 1-2 for theothers) // // Revision 1.4 2001/09/07 14:07:38 staszel // Added Front and Back detector tracks to BrBfsTrack private members. // // Revision 1.3 2001/09/06 09:39:18 staszel // T3T4 replaced by BfsFront and T4T5 replaced by BfsBack. // // Revision 1.2 2001/08/07 13:44:15 ouerdane // Added BrBfsTrack (cf brahms_app/do_app/dc for the tracking module) // // Revision 1.1.1.1 2001/06/21 14:55:03 hagel // Initial revision of brat2 // // Revision 1.22 2001/06/19 19:39:44 trine // Added function RelativeOverlap(....) to BrMrsTrack and BrFfsTrack // // Revision 1.21 2001/06/01 17:19:14 videbaek // This is an update of BrModuleMatchTrack to fix the error for infinite loops in // the Ghostbusting. By looking at code as well as trine's comments I decided // to do a complete re-write of CleanUpTracks(), and works according to specs. // In addition the BrMatchedTracks have added members to save important info // on the CleanUp procedure (chisq, and trackgroup) in case one wants to go back // and redo, ghostbusting etc. // // Revision 1.20 2001/05/09 01:37:04 videbaek // Imporved tracking in the magnet matching. See e-mail for further // comments. There are also comments in the code. // Changed members in BrMatchedTrack. May affect reading of old files. // // Revision 1.19 2000/12/21 14:58:53 videbaek // added histograms and setting of track variables // // Revision 1.18 2000/12/18 21:53:45 ouerdane // Made fHelix a pointer to BrHelix, // Removed private members fEntranceX, Y, Z etc. Use now BrVector3D fEntrance, // etc. Replaced removed members in Getters and Setters by fEntrance.GetX(), etc. // // Revision 1.17 2000/12/18 19:32:45 ouerdane // Modified persistency of some private members in BrMatchedTrack and BrHelix, // namely // - fMagnetVolume in BrHelix // - fHelix in BrMatchedTrack // // These members are not written to disk anymore (if //! really means so in the // header files) // // The reason for that is that each time a matched track was read out from // a root file, the memory was filled up with BrMagnetVolume pointers. // Concerning the BrHelix, I think that's not really critical to have it // saved. // // Revision 1.16 2000/12/06 22:21:08 videbaek // Several modification to the BrMrsTrackingModule, particluar logic for finding TOF panel // position and slat. Tracks are only assigned a hit if inside 'area in x. The logic also takes care (in an not // optimal way of the 20-21-21-21 slat configuration. // The TrackToVertex now calculate tx,Ty and Tz in IP system rather than MIDS local. // Tracklength from TPM1 to this vertex is added to track. // // Revision 1.15 2000/11/22 21:20:36 videbaek // Modification to handle Init() calls properly. // Also changes for detector/Magnetvolumes. // // Revision 1.14 2000/10/31 19:38:09 ouerdane // A few changes in the matching and global tracking classes: // Matching: // --------- // BrModuleMatchTrack now calculates the length from the track position // in the front tracking chamber to the track position to the back // tracking chamber. It calculates the helix branch inside the intermediate // magnetic field, the entrance and exit points at the magnetic gap front and // back planes (in global coordinates). // Note that it uses the local track positions given by // BrDetectorTrack::GetPos() // The result is stored in a private member of BrMatchedTrack, namely // fMatchedTrackLength that a user can get thanks to // BrMtachedTrack::GetMatchedTrackLength() // (the corresponding setter method exists too). // the helix object is also stored as a private member of the matched track // and is accessible via BrMatchedTrack::GetHelix() // // Global tracking: // --------------- // BrMrsTrackingModule and BrFfsTrackingModule now calculate: // FFS: track length from front plane of D1 to TOF1 plane // MRS: track length from TPM1 track position to TOFW panel // (gets the matched track length and add the piece from TPM2 to TOFW) // The methods are called: // FFS: EvalD1ToTOFWTrackLength() // MRS: EvalTPM1ToTOFWTrackLength() // // Both of these modules calculate the number of the pointed slat on the // time of flight detector (TOFW or TOF1) as well as the coordinates // of the track projection on these TOF detectors. // The results are stored in private members of BrMrsTrack and BrFFTrack, // namely fPointedSlat, fProjOnTOF1 and fProjOnTOFW, fD1ToTOF1TrackLength // fTPM1ToTOFWTrackLength. These values are accessible with the getter methods // (setters exist too). // // --------------- // The previous TrackLength methods have been removed (they were not appropriate // because of their location and the assumption concerning the vertex at (0,0,0)) // Also removed the cxx files BrMrsTrack.cxx and BrFfsTrack.cxx (useless). // // All the points (entrance and exit points in a magnet detector) are accessible. // The coordinates are calculated in the global c.s. // // Revision 1.13 2000/09/20 15:58:32 ouerdane // Added new methods in BrMrsTrack and BrFfsTrack: // void PathLength() // BrHelix HelixBranch() // Added new private members as well: fLength and fHelix // Note that the length assumes a vertex at (0,0,0) and should be // changed in the future // // Revision 1.12 2000/09/13 16:48:37 ouerdane // Added BrFfsTrack class (looks a lot like BrMrsTrack). // // Revision 1.11 2000/05/16 16:41:43 cholm // Bug correction: BrMatchedTrack::Get() all // returned fEntranceX - probably from too quitck cut'n'paste // // Revision 1.10 2000/04/28 21:18:24 videbaek // Updates to BrLocalTrack. Added fit method; Status is changed. Uses // MarkAsBad, IsBad instead of fixed 999. // Cleanup of BrModuleMatchtrack. Added histohgrams. // // Revision 1.9 1999/06/09 17:24:44 videbaek // remove apost. from comment lines // // Revision 1.8 1999/04/12 19:20:50 hagel // Added GetTtr(Int_t i) // // Revision 1.7 1999/03/07 00:00:46 hagel // 1. Implemented BrFSTrackingModule. Started with // BrMrsTrackingModule and made appropriate changes to handle the // forward spectrometer. It uses the new // // Revision 1.6 1999/02/26 21:14:40 hagel // Minor changes to make compatible with BrFSTrackingModule // // Revision 1.5 1999/02/23 23:18:17 jhlee // add GetTheta and GetPhi for MRS // // Revision 1.4 1999/01/21 23:23:28 hagel // 1. Changed convention for checking includes. Current convention is: // BRAT_Br...... eg BRAT_BrModule ala ROOT. // 2. Added CVS logs to .h files that didnt have them. // 3. Moved checking of include definition to first line for easier reading // 4. Put checks before all includes in the include files as per BRAT // specifications // 5. Added BrGeantHeader to Geant Makefile // 6. All changes have been checked to compile on NT ala Cygnus // // Revision 1.3 1999/01/15 16:37:03 videbaek // Working version of MRS tracking of mtp1,mtp2 and new general track // classes. Changes also added to BrModuleMatchTrack for this reason. // // Revision 1.2 1998/12/21 20:23:12 videbaek // Included MRS tracking, and track combine module as part of a more // generalized set of Methods and classes. // //