[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;
  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;}
  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          fdEdx[knSlices];         //  dE/dx measurements for tracklet
  Double_t         fCross[4];            // spatial parameters of the pad row crossing
  Double_t         fProb[AliPID::kSPECIES]; //  PID probabilities

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