[u/mrichter/AliRoot.git] / TRD / AliTRDseedV1.h

#ifndef ALITRDSEEDV1_H
#define ALITRDSEEDV1_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice                               */

/* $Id$ */

////////////////////////////////////////////////////////////////////////////
//                                                                        //
//  The TRD track seed                                                    //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

#ifndef ALITRDSEED_H
#include "AliTRDseed.h"
#endif

#ifndef ALITRDGEOMETRY_H
#include "AliTRDgeometry.h"
#endif

#ifndef ALIPID_H
#include "AliPID.h"
#endif

#ifndef ALIRIEMAN_H
#include "AliRieman.h"
#endif

class TTreeSRedirector;

class AliRieman;

class AliTRDtrackingChamber;
class AliTRDcluster;
class AliTRDtrackV1;
class AliTRDReconstructor;
class AliTRDseedV1 : public AliTRDseed
{

  public:

  enum {
    knSlices = 10
  };
  // bits from 0-13 are reserved by ROOT (see TObject.h)
  enum AliTRDtrackletStatus {
    kOwner    = BIT(14)
  , kRowCross = BIT(15) 
  };

  AliTRDseedV1(Int_t det = -1);
  ~AliTRDseedV1();
  AliTRDseedV1(const AliTRDseedV1 &ref);
  AliTRDseedV1& operator=(const AliTRDseedV1 &ref);

  Bool_t	  AttachClustersIter(
              AliTRDtrackingChamber *chamber, Float_t quality, 
              Bool_t kZcorr = kFALSE, AliTRDcluster *c=0x0);
  Bool_t	  AttachClusters(
              AliTRDtrackingChamber *chamber, Bool_t kZcorr = kFALSE);
  void      Bootstrap(const AliTRDReconstructor *rec);
  void      CookdEdx(Int_t nslices);
  Bool_t    Fit(Bool_t tilt=kTRUE);

  Bool_t    Init(AliTRDtrackV1 *track);
  inline void      Init(const AliRieman *fit);
  Bool_t    IsEqual(const TObject *inTracklet) const;
  Bool_t    IsOwner() const          { return TestBit(kOwner);}
  Bool_t    IsRowCross() const       { return TestBit(kRowCross);}

  inline Float_t   GetChi2Z(const Float_t z = 999.) const;
  inline Float_t   GetChi2Y(const Float_t y = 999.) const;
  void      GetCovAt(Double_t x, Double_t *cov) const;
  void      GetCovRef(Double_t *cov) const { memcpy(cov, &fRefCov[0], 3*sizeof(Double_t));}
  Double_t* GetCrossXYZ()            { return &fCross[0];}
  Double_t  GetCrossSz2() const      { return fCross[3];}
  Float_t   GetdX() const            { return fdX;}
  Float_t*  GetdEdx()                { return &fdEdx[0];}
  Float_t   GetdQdl(Int_t ic) const;
  Int_t     GetDetector() const      { return fDet;}
  Double_t  GetMomentum() const      { return fMom;}
  Int_t     GetN() const             { return fN2;}
  Float_t   GetQuality(Bool_t kZcorr) const;
  Int_t     GetPlane() const         { return AliTRDgeometry::GetLayer(fDet);    }

  Double_t* GetProbability();
  Double_t  GetSnp() const           { return fSnp;}
  Double_t  GetTgl() const           { return fTgl;}
  Float_t   GetXref() const          { return fXref;}
  Double_t  GetYat(Double_t x) const { return fYfit[0] + fYfit[1] * (x-fX0);}
  Double_t  GetZat(Double_t x) const { return fZfit[0] + fZfit[1] * (x-fX0);}
  
  inline AliTRDcluster* NextCluster();
  inline AliTRDcluster* PrevCluster();
  void      Print(Option_t *o = "") const;
  inline void ResetClusterIter(Bool_t forward = kTRUE);

  void      SetMomentum(Double_t mom){ fMom = mom;}
  void      SetOwner();
  void      SetDetector(Int_t d)     { fDet = d;  }
  void      SetDX(Float_t inDX)      { fdX = inDX;}
  void      SetSnp(Double_t snp)     { fSnp = snp;}
  void      SetTgl(Double_t tgl)     { fTgl = tgl;}
  void      SetReconstructor(const AliTRDReconstructor *rec) {fReconstructor = rec;}
protected:

  void Copy(TObject &ref) const;

private:
  const AliTRDReconstructor *fReconstructor;//! local reconstructor
  AliTRDcluster    **fClusterIter;          //! clusters iterator
  Char_t           fClusterIdx;             //! clusters iterator
  Int_t            fDet;                    //  TRD detector
  Float_t          fMom;                    //  Momentum estimate for tracklet [GeV/c]
  Float_t          fSnp;                    // sin of track with respect to x direction in XY plane	
  Float_t          fTgl;                    // tg of track with respect to x direction in XZ plane 	
  Float_t          fdX;                     // length of time bin
  Float_t          fXref;                   // average radial position of clusters
  Float_t          fdEdx[knSlices];         // dE/dx measurements for tracklet
  Double_t         fCross[4];               // spatial parameters of the pad row crossing
  Double_t         fRefCov[3];              // covariance matrix of the track in the yz plane
  Double_t         fProb[AliPID::kSPECIES]; //  PID probabilities

  ClassDef(AliTRDseedV1, 3)                 //  New TRD seed 

};

//____________________________________________________________
inline Float_t AliTRDseedV1::GetChi2Z(const Float_t z) const
{
  Float_t z1  = (z == 999.) ? fMeanz : z;
  Float_t chi = fZref[0] - z1;
  return chi*chi;
}

//____________________________________________________________
inline Float_t AliTRDseedV1::GetChi2Y(const Float_t y) const
{
  Float_t y1  = (y == 999.) ? fYfitR[0] : y;
  Float_t chi = fYref[0] - y1;
  return chi*chi;
}

//____________________________________________________________
inline void AliTRDseedV1::Init(const AliRieman *rieman)
{
  fZref[0] = rieman->GetZat(fX0);
  fZref[1] = rieman->GetDZat(fX0);
  fYref[0] = rieman->GetYat(fX0);
  fYref[1] = rieman->GetDYat(fX0);
  fC       = rieman->GetC(); 
  fChi2    = rieman->GetChi2();
}

//____________________________________________________________
inline AliTRDcluster* AliTRDseedV1::NextCluster()
{
// Mimic the usage of STL iterators.
// Forward iterator

  fClusterIdx++; fClusterIter++;
  while(fClusterIdx < AliTRDseed::knTimebins){
    if(!(*fClusterIter)){ 
      fClusterIdx++; 
      fClusterIter++;
      continue;
    }
    return *fClusterIter;
  }
  return 0x0;
}

//____________________________________________________________
inline AliTRDcluster* AliTRDseedV1::PrevCluster()
{
// Mimic the usage of STL iterators.
// Backward iterator

  fClusterIdx--; fClusterIter--;
  while(fClusterIdx >= 0){
    if(!(*fClusterIter)){ 
      fClusterIdx--; 
      fClusterIter--;
      continue;
    }
    return *fClusterIter;
  }
  return 0x0;
}

//____________________________________________________________
inline void AliTRDseedV1::ResetClusterIter(Bool_t forward) 
{
// Mimic the usage of STL iterators.
// Facilitate the usage of NextCluster for forward like 
// iterator (kTRUE) and PrevCluster for backward like iterator (kFALSE)

  if(forward){
    fClusterIter = &fClusters[0]; fClusterIter--; 
    fClusterIdx=-1;
  } else {
    fClusterIter = &fClusters[AliTRDseed::knTimebins-1]; fClusterIter++; 
    fClusterIdx=AliTRDseed::knTimebins;
  }
}

#endif
Commit	Line	Data
e4f2f73d	1	#ifndef ALITRDSEEDV1_H
	2	#define ALITRDSEEDV1_H
	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
e44586fb	4	* See cxx source for full Copyright notice */
e4f2f73d	5
	6	/* $Id$ */
	7
	8	////////////////////////////////////////////////////////////////////////////
	9	// //
	10	// The TRD track seed //
	11	// //
	12	////////////////////////////////////////////////////////////////////////////
	13
	14	#ifndef ALITRDSEED_H
	15	#include "AliTRDseed.h"
	16	#endif
	17
ae4e8b84	18	#ifndef ALITRDGEOMETRY_H
	19	#include "AliTRDgeometry.h"
	20	#endif
	21
0906e73e	22	#ifndef ALIPID_H
	23	#include "AliPID.h"
	24	#endif
	25
e4f2f73d	26	#ifndef ALIRIEMAN_H
	27	#include "AliRieman.h"
	28	#endif
	29
	30	class TTreeSRedirector;
	31
	32	class AliRieman;
	33
eb38ed55	34	class AliTRDtrackingChamber;
e4f2f73d	35	class AliTRDcluster;
f3d3af1b	36	class AliTRDtrackV1;
3a039a31	37	class AliTRDReconstructor;
e4f2f73d	38	class AliTRDseedV1 : public AliTRDseed
e4f2f73d	39	{
fbb2ea06	40
0906e73e	41	public:
0906e73e	42
e44586fb	43	enum {
	44	knSlices = 10
	45	};
2e2915e7	46	// bits from 0-13 are reserved by ROOT (see TObject.h)
e44586fb	47	enum AliTRDtrackletStatus {
2e2915e7	48	kOwner = BIT(14)
2e2915e7	49	, kRowCross = BIT(15)
e44586fb	50	};
e44586fb	51
ae4e8b84	52	AliTRDseedV1(Int_t det = -1);
e44586fb	53	~AliTRDseedV1();
	54	AliTRDseedV1(const AliTRDseedV1 &ref);
	55	AliTRDseedV1& operator=(const AliTRDseedV1 &ref);
	56
203967fc	57	Bool_t AttachClustersIter(
	58	AliTRDtrackingChamber *chamber, Float_t quality,
	59	Bool_t kZcorr = kFALSE, AliTRDcluster *c=0x0);
	60	Bool_t AttachClusters(
	61	AliTRDtrackingChamber *chamber, Bool_t kZcorr = kFALSE);
	62	void Bootstrap(const AliTRDReconstructor *rec);
	63	void CookdEdx(Int_t nslices);
	64	Bool_t Fit(Bool_t tilt=kTRUE);
	65
	66	Bool_t Init(AliTRDtrackV1 *track);
e44586fb	67	inline void Init(const AliRieman *fit);
203967fc	68	Bool_t IsEqual(const TObject *inTracklet) const;
e44586fb	69	Bool_t IsOwner() const { return TestBit(kOwner);}
	70	Bool_t IsRowCross() const { return TestBit(kRowCross);}
	71
	72	inline Float_t GetChi2Z(const Float_t z = 999.) const;
	73	inline Float_t GetChi2Y(const Float_t y = 999.) const;
	74	void GetCovAt(Double_t x, Double_t *cov) const;
ac6764f5	75	void GetCovRef(Double_t cov) const { memcpy(cov, &fRefCov[0], 3sizeof(Double_t));}
203967fc	76	Double_t* GetCrossXYZ() { return &fCross[0];}
	77	Double_t GetCrossSz2() const { return fCross[3];}
	78	Float_t GetdX() const { return fdX;}
	79	Float_t* GetdEdx() { return &fdEdx[0];}
e44586fb	80	Float_t GetdQdl(Int_t ic) const;
203967fc	81	Int_t GetDetector() const { return fDet;}
	82	Double_t GetMomentum() const { return fMom;}
	83	Int_t GetN() const { return fN2;}
e44586fb	84	Float_t GetQuality(Bool_t kZcorr) const;
ae4e8b84	85	Int_t GetPlane() const { return AliTRDgeometry::GetLayer(fDet); }
ae4e8b84	86
e44586fb	87	Double_t* GetProbability();
	88	Double_t GetSnp() const { return fSnp;}
	89	Double_t GetTgl() const { return fTgl;}
6e4d4425	90	Float_t GetXref() const { return fXref;}
d2b9977a	91	Double_t GetYat(Double_t x) const { return fYfit[0] + fYfit[1] * (x-fX0);}
d2b9977a	92	Double_t GetZat(Double_t x) const { return fZfit[0] + fZfit[1] * (x-fX0);}
e44586fb	93
ae4e8b84	94	inline AliTRDcluster* NextCluster();
71ea19a3	95	inline AliTRDcluster* PrevCluster();
e44586fb	96	void Print(Option_t *o = "") const;
71ea19a3	97	inline void ResetClusterIter(Bool_t forward = kTRUE);
ae4e8b84	98
203967fc	99	void SetMomentum(Double_t mom){ fMom = mom;}
29b87567	100	void SetOwner();
203967fc	101	void SetDetector(Int_t d) { fDet = d; }
bee2b41e	102	void SetDX(Float_t inDX) { fdX = inDX;}
203967fc	103	void SetSnp(Double_t snp) { fSnp = snp;}
203967fc	104	void SetTgl(Double_t tgl) { fTgl = tgl;}
3a039a31	105	void SetReconstructor(const AliTRDReconstructor *rec) {fReconstructor = rec;}
e44586fb	106	protected:
e4f2f73d	107
e44586fb	108	void Copy(TObject &ref) const;
e4f2f73d	109
e44586fb	110	private:
0ae89c5d	111	const AliTRDReconstructor *fReconstructor;//! local reconstructor
ae4e8b84	112	AliTRDcluster **fClusterIter; //! clusters iterator
71ea19a3	113	Char_t fClusterIdx; //! clusters iterator
ae4e8b84	114	Int_t fDet; // TRD detector
e44586fb	115	Float_t fMom; // Momentum estimate for tracklet [GeV/c]
	116	Float_t fSnp; // sin of track with respect to x direction in XY plane
	117	Float_t fTgl; // tg of track with respect to x direction in XZ plane
	118	Float_t fdX; // length of time bin
6e4d4425	119	Float_t fXref; // average radial position of clusters
	120	Float_t fdEdx[knSlices]; // dE/dx measurements for tracklet
	121	Double_t fCross[4]; // spatial parameters of the pad row crossing
	122	Double_t fRefCov[3]; // covariance matrix of the track in the yz plane
e44586fb	123	Double_t fProb[AliPID::kSPECIES]; // PID probabilities
e4f2f73d	124
6e4d4425	125	ClassDef(AliTRDseedV1, 3) // New TRD seed
e4f2f73d	126
	127	};
	128
	129	//____________________________________________________________
	130	inline Float_t AliTRDseedV1::GetChi2Z(const Float_t z) const
	131	{
e44586fb	132	Float_t z1 = (z == 999.) ? fMeanz : z;
	133	Float_t chi = fZref[0] - z1;
	134	return chi*chi;
e4f2f73d	135	}
	136
	137	//____________________________________________________________
	138	inline Float_t AliTRDseedV1::GetChi2Y(const Float_t y) const
	139	{
e44586fb	140	Float_t y1 = (y == 999.) ? fYfitR[0] : y;
	141	Float_t chi = fYref[0] - y1;
	142	return chi*chi;
e4f2f73d	143	}
	144
	145	//____________________________________________________________
0906e73e	146	inline void AliTRDseedV1::Init(const AliRieman *rieman)
e4f2f73d	147	{
e44586fb	148	fZref[0] = rieman->GetZat(fX0);
	149	fZref[1] = rieman->GetDZat(fX0);
	150	fYref[0] = rieman->GetYat(fX0);
	151	fYref[1] = rieman->GetDYat(fX0);
55ef6967	152	fC = rieman->GetC();
55ef6967	153	fChi2 = rieman->GetChi2();
e4f2f73d	154	}
e4f2f73d	155
ae4e8b84	156	//____________________________________________________________
	157	inline AliTRDcluster* AliTRDseedV1::NextCluster()
	158	{
71ea19a3	159	// Mimic the usage of STL iterators.
	160	// Forward iterator
	161
ae4e8b84	162	fClusterIdx++; fClusterIter++;
71ea19a3	163	while(fClusterIdx < AliTRDseed::knTimebins){
	164	if(!(*fClusterIter)){
	165	fClusterIdx++;
	166	fClusterIter++;
	167	continue;
	168	}
	169	return *fClusterIter;
	170	}
	171	return 0x0;
	172	}
	173
	174	//____________________________________________________________
	175	inline AliTRDcluster* AliTRDseedV1::PrevCluster()
	176	{
	177	// Mimic the usage of STL iterators.
	178	// Backward iterator
	179
	180	fClusterIdx--; fClusterIter--;
	181	while(fClusterIdx >= 0){
	182	if(!(*fClusterIter)){
	183	fClusterIdx--;
	184	fClusterIter--;
	185	continue;
	186	}
	187	return *fClusterIter;
	188	}
	189	return 0x0;
	190	}
	191
	192	//____________________________________________________________
	193	inline void AliTRDseedV1::ResetClusterIter(Bool_t forward)
	194	{
	195	// Mimic the usage of STL iterators.
	196	// Facilitate the usage of NextCluster for forward like
	197	// iterator (kTRUE) and PrevCluster for backward like iterator (kFALSE)
	198
	199	if(forward){
	200	fClusterIter = &fClusters[0]; fClusterIter--;
	201	fClusterIdx=-1;
	202	} else {
	203	fClusterIter = &fClusters[AliTRDseed::knTimebins-1]; fClusterIter++;
	204	fClusterIdx=AliTRDseed::knTimebins;
	205	}
ae4e8b84	206	}
ae4e8b84	207
e4f2f73d	208	#endif
e4f2f73d	209
47d5d320	210
6e49cfdb	211