[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] * (fX0-x);}
  Double_t  GetZat(Double_t x) const { return fZfit[0] + fZfit[1] * (fX0-x);}
  
  inline AliTRDcluster* NextCluster();
  inline AliTRDcluster* PrevCluster();
  void      Print(Option_t *o = "") const;
  inline void ResetClusterIter(Bool_t forward = kTRUE);

  void      SetCovRef(const Double_t *cov) { memcpy(&fRefCov[0], cov, 3*sizeof(Double_t));}
  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;}
0849f128	91	Double_t GetYat(Double_t x) const { return fYfit[0] + fYfit[1] * (fX0-x);}
0849f128	92	Double_t GetZat(Double_t x) const { return fZfit[0] + fZfit[1] * (fX0-x);}
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
0849f128	99	void SetCovRef(const Double_t cov) { memcpy(&fRefCov[0], cov, 3sizeof(Double_t));}
203967fc	100	void SetMomentum(Double_t mom){ fMom = mom;}
29b87567	101	void SetOwner();
203967fc	102	void SetDetector(Int_t d) { fDet = d; }
bee2b41e	103	void SetDX(Float_t inDX) { fdX = inDX;}
203967fc	104	void SetSnp(Double_t snp) { fSnp = snp;}
203967fc	105	void SetTgl(Double_t tgl) { fTgl = tgl;}
3a039a31	106	void SetReconstructor(const AliTRDReconstructor *rec) {fReconstructor = rec;}
e44586fb	107	protected:
e4f2f73d	108
e44586fb	109	void Copy(TObject &ref) const;
e4f2f73d	110
e44586fb	111	private:
0ae89c5d	112	const AliTRDReconstructor *fReconstructor;//! local reconstructor
ae4e8b84	113	AliTRDcluster **fClusterIter; //! clusters iterator
71ea19a3	114	Char_t fClusterIdx; //! clusters iterator
ae4e8b84	115	Int_t fDet; // TRD detector
e44586fb	116	Float_t fMom; // Momentum estimate for tracklet [GeV/c]
	117	Float_t fSnp; // sin of track with respect to x direction in XY plane
	118	Float_t fTgl; // tg of track with respect to x direction in XZ plane
	119	Float_t fdX; // length of time bin
6e4d4425	120	Float_t fXref; // average radial position of clusters
	121	Float_t fdEdx[knSlices]; // dE/dx measurements for tracklet
	122	Double_t fCross[4]; // spatial parameters of the pad row crossing
	123	Double_t fRefCov[3]; // covariance matrix of the track in the yz plane
e44586fb	124	Double_t fProb[AliPID::kSPECIES]; // PID probabilities
e4f2f73d	125
6e4d4425	126	ClassDef(AliTRDseedV1, 3) // New TRD seed
e4f2f73d	127
	128	};
	129
	130	//____________________________________________________________
	131	inline Float_t AliTRDseedV1::GetChi2Z(const Float_t z) const
	132	{
e44586fb	133	Float_t z1 = (z == 999.) ? fMeanz : z;
	134	Float_t chi = fZref[0] - z1;
	135	return chi*chi;
e4f2f73d	136	}
	137
	138	//____________________________________________________________
	139	inline Float_t AliTRDseedV1::GetChi2Y(const Float_t y) const
	140	{
e44586fb	141	Float_t y1 = (y == 999.) ? fYfitR[0] : y;
	142	Float_t chi = fYref[0] - y1;
	143	return chi*chi;
e4f2f73d	144	}
	145
	146	//____________________________________________________________
0906e73e	147	inline void AliTRDseedV1::Init(const AliRieman *rieman)
e4f2f73d	148	{
e44586fb	149	fZref[0] = rieman->GetZat(fX0);
	150	fZref[1] = rieman->GetDZat(fX0);
	151	fYref[0] = rieman->GetYat(fX0);
	152	fYref[1] = rieman->GetDYat(fX0);
55ef6967	153	fC = rieman->GetC();
55ef6967	154	fChi2 = rieman->GetChi2();
e4f2f73d	155	}
e4f2f73d	156
ae4e8b84	157	//____________________________________________________________
	158	inline AliTRDcluster* AliTRDseedV1::NextCluster()
	159	{
71ea19a3	160	// Mimic the usage of STL iterators.
	161	// Forward iterator
	162
ae4e8b84	163	fClusterIdx++; fClusterIter++;
71ea19a3	164	while(fClusterIdx < AliTRDseed::knTimebins){
	165	if(!(*fClusterIter)){
	166	fClusterIdx++;
	167	fClusterIter++;
	168	continue;
	169	}
	170	return *fClusterIter;
	171	}
	172	return 0x0;
	173	}
	174
	175	//____________________________________________________________
	176	inline AliTRDcluster* AliTRDseedV1::PrevCluster()
	177	{
	178	// Mimic the usage of STL iterators.
	179	// Backward iterator
	180
	181	fClusterIdx--; fClusterIter--;
	182	while(fClusterIdx >= 0){
	183	if(!(*fClusterIter)){
	184	fClusterIdx--;
	185	fClusterIter--;
	186	continue;
	187	}
	188	return *fClusterIter;
	189	}
	190	return 0x0;
	191	}
	192
	193	//____________________________________________________________
	194	inline void AliTRDseedV1::ResetClusterIter(Bool_t forward)
	195	{
	196	// Mimic the usage of STL iterators.
	197	// Facilitate the usage of NextCluster for forward like
	198	// iterator (kTRUE) and PrevCluster for backward like iterator (kFALSE)
	199
	200	if(forward){
	201	fClusterIter = &fClusters[0]; fClusterIter--;
	202	fClusterIdx=-1;
	203	} else {
	204	fClusterIter = &fClusters[AliTRDseed::knTimebins-1]; fClusterIter++;
	205	fClusterIdx=AliTRDseed::knTimebins;
	206	}
ae4e8b84	207	}
ae4e8b84	208
e4f2f73d	209	#endif
e4f2f73d	210
47d5d320	211
6e49cfdb	212