[u/mrichter/AliRoot.git] / PWGPP / TRD / info / AliTRDtrackInfo.h

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

/* $Id: AliTRDtrackInfo.h 27496 2008-07-22 08:35:45Z cblume $ */

////////////////////////////////////////////////////////////////////////////
//                                                                        //
//  Reconstruction QA                                                     //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

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


template <typename Value> class TVectorT;
typedef class TVectorT<Double_t> TVectorD;
class AliTRDseedV1;
class AliTRDtrackV1;
class AliTrackReference;
class AliTrackPointArray;
class AliExternalTrackParam;
class AliTRDtrackInfo : public TObject{
public:
  enum{
    kNTrackRefs = 12
  };
  class AliESDinfo{
    friend class AliTRDtrackInfo;  // Friend class
  public:
    enum EESDinfo{
       kV0       = 0
      ,kElectron = 1
      ,kPion     = 2
      ,kProton   = 3
    };
    AliESDinfo();
    AliESDinfo(const AliESDinfo &esd);
    virtual ~AliESDinfo();
    AliESDinfo& operator=(const AliESDinfo &esd);
    void Delete(const Option_t *);
    Float_t     Eta() const                      { return fEta;}
    Int_t       GetId() const                    { return fId;}
    ULong_t     GetStatus() const                { return fStatus;}
    Int_t       GetKinkIndex() const             { return fKinkIndex;}
    Short_t     GetTOFbc() const                 { return fTOFbc;}
    Float_t     GetTOFbeta() const               { return fTOFbeta;}
    UShort_t    GetTPCncls() const               { return fTPCncls;}
    Float_t     GetTPCdedx() const               { return fTPCdedx;}
    AliTrackPointArray* GetTrackPointArray() const      { return fTPArray; }
    UChar_t     GetPidQuality() const            { return fTRDpidQuality;}
    Int_t       GetNSlices() const               { return fTRDnSlices;}
    Double32_t* GetSliceIter() const             { return fTRDslices;}
    const Double32_t* GetResponseIter() const    { return &fTRDr[0];}
    AliExternalTrackParam* GetOuterParam() const { return fOP;}
    AliExternalTrackParam* GetITSoutParam() const { return fITSout;}
    AliExternalTrackParam* GetTPCoutParam() const { return fTPCout;}
    const Int_t* GetV0pid() const                { return &fTRDv0pid[0];}
    Int_t       GetV0pid(Int_t i) const          { return fTRDv0pid[i];}
    Bool_t      HasV0() const                    { return TESTBIT(fSteer, kV0);}
    Bool_t      IsElectron() const               { return TESTBIT(fSteer, kElectron);}
    Bool_t      IsPion() const                   { return TESTBIT(fSteer, kPion);}
    Bool_t      IsProton() const                 { return TESTBIT(fSteer, kProton);}
    Float_t     Phi() const                      { return fPhi;}
    Float_t     Pt() const                       { return fPt;}
    void        SetElectron(Bool_t e=kTRUE)      { e?SETBIT(fSteer, kElectron):CLRBIT(fSteer, kElectron);}
    void        SetPion(Bool_t e=kTRUE)          { e?SETBIT(fSteer, kPion):CLRBIT(fSteer, kPion);}
    void        SetProton(Bool_t e=kTRUE)        { e?SETBIT(fSteer, kProton):CLRBIT(fSteer, kProton);}
    void        SetV0(Bool_t v=kTRUE)            { v?SETBIT(fSteer, kV0):CLRBIT(fSteer, kV0);}
    void        SetOuterParam(const AliExternalTrackParam *op);
    void        SetITSoutParam(const AliExternalTrackParam *op);
    void        SetTPCoutParam(const AliExternalTrackParam *op);
    void        SetTrackPointArray(const AliTrackPointArray *tps);

  protected:
    UChar_t     fSteer;                   // bit map
    Int_t       fId;                      // ESD track id
    ULong_t     fStatus;                  // ESD track status
    Int_t       fKinkIndex;               // ESD kink index
    UShort_t    fTPCncls;                 // Number of Clusters inside TPC
    Float_t     fTPCdedx;                 // dEdx in TPC
    Float_t     fTOFbeta;                 // time of flight in TOF
    Short_t     fTOFbc;                   // TOF bunch crossing index
    Double32_t  fTRDr[AliPID::kSPECIES];  // TRD radial position
    UChar_t     fTRDpidQuality;           // TRD PID quality
    Int_t       fTRDnSlices;              // number of slices used for PID
    Float_t     fPt;                      // p_t at TRD entrance
    Float_t     fPhi;                     // phi at TRD entrance
    Float_t     fEta;                     // eta at TRD entrance
    Double32_t *fTRDslices;               //[fTRDnSlices]
    AliExternalTrackParam *fOP;           // outer track param
    AliExternalTrackParam *fTPCout;       // outer TPC param
    AliExternalTrackParam *fITSout;       // outer ITS param
    AliTrackPointArray *fTPArray;         // track point array to be used for alignment
    Int_t  fTRDv0pid[AliPID::kSPECIES];   // PID from v0s

    ClassDef(AliESDinfo, 9)     // ESD info related to TRD
  };

  class AliMCinfo{
  friend class AliTRDtrackInfo;
  public:
    //typedef AliTrackReference (const* constAliTrackReference);
    AliMCinfo();
    AliMCinfo(const AliMCinfo &mc);
    virtual ~AliMCinfo();
    AliMCinfo& operator=(const AliMCinfo &mc);
    Float_t GetEta() const                                  { return fEta;}
    Int_t   GetLabel() const                                { return fLabel;}
    Int_t   GetTRDlabel() const                             { return fTRDlabel;}
    Int_t   GetNTrackRefs() const                           { return fNTrackRefs;}
    Int_t   GetPDG() const                                  { return fPDG;}
    Int_t   GetPID() const ;
    Float_t GetPhi() const                                  { return fPhi;}
    Float_t GetPt() const                                   { return fPt;}
    Bool_t  GetDirections(Float_t &x0, Float_t &y0, Float_t &z0, Float_t &dydx, Float_t &dzdx, Float_t &pt, Float_t &p, Float_t &eta, Float_t &phi, UChar_t &s) const;
    AliTrackReference const* GetTrackRef(Int_t ref=0) const { return fTrackRefs[ref];}
    static Double_t GetKalmanStep()                         { return fgKalmanStep;}
    static Bool_t IsKalmanUpdate()                          { return fgKalmanUpdate;}
    Bool_t   PropagateKalman(
        TVectorD *x, TVectorD *y, TVectorD *z,
        TVectorD *dx, TVectorD *dy, TVectorD *dz,
        TVectorD *pt, TVectorD *dpt, TVectorD *budget, TVectorD *c, Double_t mass=-1) const;
    static void SetKalmanStep(Double_t s)                   { fgKalmanStep = s;}
    static void SetKalmanUpdate(Bool_t s=kTRUE)             { fgKalmanUpdate = s;}
  protected:
    Int_t   fLabel;               // ESD label
    Int_t   fTRDlabel;            // TRD label
    Int_t   fPDG;                 // particle code
    Int_t   fNTrackRefs;    	    // number of track refs
    Float_t fEta;                 // particle eta (vertex)
    Float_t fPhi;                 // particle phi (vertex)
    Float_t fPt;                  // particle pt (vertex)
    static Double_t fgKalmanStep; // Kalman step propagation
    static Bool_t fgKalmanUpdate; // Kalman update with TRD tracklets
    AliTrackReference  *fTrackRefs[kNTrackRefs];	// track refs array

    ClassDef(AliMCinfo, 4)      // MC info related to TRD
  };

  AliTRDtrackInfo();
  AliTRDtrackInfo(const AliTRDtrackInfo &trdInfo);
  ~AliTRDtrackInfo();

//  void               Clear(const Option_t *){}
  void               Delete(const Option_t *);
  AliTRDtrackInfo&   operator=(const AliTRDtrackInfo &trdInfo);
  void               AddTrackRef(const AliTrackReference *trackRef);
  Int_t              GetTrackId() const               { return fESD.fId;}
  const AliESDinfo*  GetESDinfo() const               { return &fESD; }
  const AliMCinfo*   GetMCinfo() const                { return fMC; }
  Int_t              GetNumberOfClusters() const;
  Int_t              GetNumberOfClustersRefit() const { return fNClusters;}
  Int_t              GetNTracklets() const;
  Int_t              GetNTrackRefs() const            { return fMC ? fMC->fNTrackRefs:0;} 
  Int_t              GetLabel() const                 { return fMC ? fMC->fLabel:0; }
  Int_t              GetKinkIndex() const             { return fESD.fKinkIndex;}
  Short_t            GetTOFbc() const                 { return fESD.fTOFbc;}
  UShort_t           GetTPCncls() const               { return fESD.fTPCncls;}
  Int_t              GetPDG() const                   { return fMC ? fMC->fPDG : 0; }
  Int_t              GetPID() const                   { return fMC ? fMC->GetPID() : -1; }
  ULong_t            GetStatus() const                { return fESD.fStatus;}
  AliTRDtrackV1*     GetTrack() const                 { return fTRDtrack; }
  AliTrackReference* GetTrackRef(Int_t entry) const;
  AliTrackReference* GetTrackRef(const AliTRDseedV1* const tracklet) const;

  Bool_t             IsCurved() const                 { return TestBit(kCurv);}
  Bool_t             IsPrimary() const                { return TestBit(kPrim);}
  Bool_t             HasESDtrack() const              { return ((fTRDtrack != 0x0) ||(fESD.fOP != 0));}
  Bool_t             HasMCinfo() const                { return (Bool_t)fMC; }

  void               SetElectron(Bool_t c = kTRUE)    { fESD.SetElectron(c);}
  void               SetPion(Bool_t c = kTRUE)        { fESD.SetPion(c);}
  void               SetProton(Bool_t c = kTRUE)      { fESD.SetProton(c);}
  void               SetCurved(Bool_t curv = kTRUE)   { SetBit(kCurv, curv);}
  void               SetLabel(Int_t lab)              { if(fMC) fMC->fLabel = lab; }
  void               SetTRDlabel(Int_t lab)           { if(fMC) fMC->fTRDlabel = lab; }
  void               SetNumberOfClustersRefit(Int_t n){fNClusters = n;}
  inline void        SetMC();
  void               SetMCeta(Float_t eta)            { if(fMC) fMC->fEta = eta; }
  void               SetMCphi(Float_t phi)            { if(fMC) fMC->fPhi = phi; }
  void               SetMCpt(Float_t pt)              { if(fMC) fMC->fPt = pt; }
  void               SetPDG(Int_t pdg)                { if(fMC) fMC->fPDG = pdg; }
  void               SetPrimary(Bool_t prim = kTRUE)  {SetBit(kPrim, prim);}
  void               SetOuterParam(const AliExternalTrackParam *op)  {fESD.SetOuterParam(op);}
  void               SetITSoutParam(const AliExternalTrackParam *op) {fESD.SetITSoutParam(op);}
  void               SetTPCoutParam(const AliExternalTrackParam *op) {fESD.SetTPCoutParam(op);}
  void               SetStatus(ULong_t stat)          { fESD.fStatus = stat;}
  void               SetKinkIndex(Int_t kinkIndex)    { fESD.fKinkIndex = kinkIndex;}
  void               SetTOFbc(Int_t bc)               { fESD.fTOFbc = bc;}
  void               SetTOFbeta(Float_t b)            { fESD.fTOFbeta = b;}
  void               SetTPCncls(UShort_t TPCncls)     { fESD.fTPCncls = TPCncls;}
  void               SetTPCdedx(Float_t dedx)         { fESD.fTPCdedx = dedx;}
  void               SetTrackId(Int_t id)             { fESD.fId = id;}
  void               SetTrack(const AliTRDtrackV1 *track);
  void               SetTrackPointArray(const AliTrackPointArray *tps) {fESD.SetTrackPointArray(tps);}
  void               SetESDpidQuality(UChar_t q)      { fESD.fTRDpidQuality = q;}
  void               SetSlices(Int_t n, Double32_t *s);
  inline void        SetESDpid(Double_t *);
  void               SetESDeta(Float_t eta)           { fESD.fEta = eta;}
  void               SetESDphi(Float_t phi)           { fESD.fPhi = phi;}
  void               SetESDpt(Float_t pt)             { fESD.fPt = pt;}
  inline void        SetV0pid(Int_t *);
  void               SetV0(Bool_t v0=kTRUE)           { fESD.SetV0(v0);}
  
private:
    enum{
      kCurv = 14,
      kPrim = 15
  };
  // this 2 data members have to go to ESD header.
  Int_t              fNClusters;     	// Numer of clusters from refit
  AliTRDtrackV1      *fTRDtrack; 	    // tracklets data array
  AliMCinfo          *fMC;            // MC extract for TRD
  AliESDinfo         fESD;            // ESD extract for TRD

  ClassDef(AliTRDtrackInfo, 4)        // TRD track info
};


//________________________________________________________
inline void AliTRDtrackInfo::SetMC()
{
  if(!fMC) fMC = new AliMCinfo();
}

//________________________________________________________
inline void AliTRDtrackInfo::SetESDpid(Double_t * const r)
{ 
  for(Int_t is = AliPID::kSPECIES; is--;) fESD.fTRDr[is] = r[is];
}

//________________________________________________________
inline void AliTRDtrackInfo::SetV0pid(Int_t * const r)
{ 
  for(Int_t is = AliPID::kSPECIES; is--;) fESD.fTRDv0pid[is] = r[is];
}

#endif
Commit	Line	Data
1ee39b3a	1	#ifndef ALITRDTRACKINFO_H
	2	#define ALITRDTRACKINFO_H
	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
	6	/* $Id: AliTRDtrackInfo.h 27496 2008-07-22 08:35:45Z cblume $ */
	7
	8	////////////////////////////////////////////////////////////////////////////
	9	// //
	10	// Reconstruction QA //
	11	// //
	12	////////////////////////////////////////////////////////////////////////////
	13
1ee39b3a	14	#ifndef ALIPID_H
	15	#include "AliPID.h"
	16	#endif
	17
4226db3e	18
4226db3e	19	template <typename Value> class TVectorT;
ebb644ed	20	typedef class TVectorT<Double_t> TVectorD;
1ee39b3a	21	class AliTRDseedV1;
	22	class AliTRDtrackV1;
	23	class AliTrackReference;
eb05d549	24	class AliTrackPointArray;
1ee39b3a	25	class AliExternalTrackParam;
	26	class AliTRDtrackInfo : public TObject{
	27	public:
	28	enum{
	29	kNTrackRefs = 12
	30	};
	31	class AliESDinfo{
	32	friend class AliTRDtrackInfo; // Friend class
	33	public:
5047978d	34	enum EESDinfo{
	35	kV0 = 0
	36	,kElectron = 1
	37	,kPion = 2
	38	,kProton = 3
	39	};
1ee39b3a	40	AliESDinfo();
	41	AliESDinfo(const AliESDinfo &esd);
	42	virtual ~AliESDinfo();
	43	AliESDinfo& operator=(const AliESDinfo &esd);
8778aca3	44	void Delete(const Option_t *);
eb05d549	45	Float_t Eta() const { return fEta;}
3ceb45ae	46	Int_t GetId() const { return fId;}
	47	ULong_t GetStatus() const { return fStatus;}
	48	Int_t GetKinkIndex() const { return fKinkIndex;}
566c3d46	49	Short_t GetTOFbc() const { return fTOFbc;}
f036f7ec	50	Float_t GetTOFbeta() const { return fTOFbeta;}
3ceb45ae	51	UShort_t GetTPCncls() const { return fTPCncls;}
2b33fd9c	52	Float_t GetTPCdedx() const { return fTPCdedx;}
eb05d549	53	AliTrackPointArray* GetTrackPointArray() const { return fTPArray; }
3ceb45ae	54	UChar_t GetPidQuality() const { return fTRDpidQuality;}
	55	Int_t GetNSlices() const { return fTRDnSlices;}
	56	Double32_t* GetSliceIter() const { return fTRDslices;}
	57	const Double32_t* GetResponseIter() const { return &fTRDr[0];}
1ee39b3a	58	AliExternalTrackParam* GetOuterParam() const { return fOP;}
b9058d72	59	AliExternalTrackParam* GetITSoutParam() const { return fITSout;}
35983729	60	AliExternalTrackParam* GetTPCoutParam() const { return fTPCout;}
3ceb45ae	61	const Int_t* GetV0pid() const { return &fTRDv0pid[0];}
3ceb45ae	62	Int_t GetV0pid(Int_t i) const { return fTRDv0pid[i];}
5047978d	63	Bool_t HasV0() const { return TESTBIT(fSteer, kV0);}
	64	Bool_t IsElectron() const { return TESTBIT(fSteer, kElectron);}
	65	Bool_t IsPion() const { return TESTBIT(fSteer, kPion);}
	66	Bool_t IsProton() const { return TESTBIT(fSteer, kProton);}
eb05d549	67	Float_t Phi() const { return fPhi;}
eb05d549	68	Float_t Pt() const { return fPt;}
5047978d	69	void SetElectron(Bool_t e=kTRUE) { e?SETBIT(fSteer, kElectron):CLRBIT(fSteer, kElectron);}
	70	void SetPion(Bool_t e=kTRUE) { e?SETBIT(fSteer, kPion):CLRBIT(fSteer, kPion);}
	71	void SetProton(Bool_t e=kTRUE) { e?SETBIT(fSteer, kProton):CLRBIT(fSteer, kProton);}
	72	void SetV0(Bool_t v=kTRUE) { v?SETBIT(fSteer, kV0):CLRBIT(fSteer, kV0);}
eb05d549	73	void SetOuterParam(const AliExternalTrackParam *op);
	74	void SetITSoutParam(const AliExternalTrackParam *op);
	75	void SetTPCoutParam(const AliExternalTrackParam *op);
	76	void SetTrackPointArray(const AliTrackPointArray *tps);
1ee39b3a	77
1ee39b3a	78	protected:
5047978d	79	UChar_t fSteer; // bit map
eb05d549	80	Int_t fId; // ESD track id
	81	ULong_t fStatus; // ESD track status
	82	Int_t fKinkIndex; // ESD kink index
	83	UShort_t fTPCncls; // Number of Clusters inside TPC
2b33fd9c	84	Float_t fTPCdedx; // dEdx in TPC
f036f7ec	85	Float_t fTOFbeta; // time of flight in TOF
eb05d549	86	Short_t fTOFbc; // TOF bunch crossing index
1ee39b3a	87	Double32_t fTRDr[AliPID::kSPECIES]; // TRD radial position
eb05d549	88	UChar_t fTRDpidQuality; // TRD PID quality
	89	Int_t fTRDnSlices; // number of slices used for PID
	90	Float_t fPt; // p_t at TRD entrance
	91	Float_t fPhi; // phi at TRD entrance
	92	Float_t fEta; // eta at TRD entrance
	93	Double32_t *fTRDslices; //[fTRDnSlices]
	94	AliExternalTrackParam *fOP; // outer track param
	95	AliExternalTrackParam *fTPCout; // outer TPC param
	96	AliExternalTrackParam *fITSout; // outer ITS param
	97	AliTrackPointArray *fTPArray; // track point array to be used for alignment
	98	Int_t fTRDv0pid[AliPID::kSPECIES]; // PID from v0s
1ee39b3a	99
2b33fd9c	100	ClassDef(AliESDinfo, 9) // ESD info related to TRD
1ee39b3a	101	};
	102
	103	class AliMCinfo{
	104	friend class AliTRDtrackInfo;
	105	public:
	106	//typedef AliTrackReference (const* constAliTrackReference);
	107	AliMCinfo();
	108	AliMCinfo(const AliMCinfo &mc);
	109	virtual ~AliMCinfo();
	110	AliMCinfo& operator=(const AliMCinfo &mc);
95d47440	111	Float_t GetEta() const { return fEta;}
	112	Int_t GetLabel() const { return fLabel;}
	113	Int_t GetTRDlabel() const { return fTRDlabel;}
	114	Int_t GetNTrackRefs() const { return fNTrackRefs;}
	115	Int_t GetPDG() const { return fPDG;}
b9ddd472	116	Int_t GetPID() const ;
95d47440	117	Float_t GetPhi() const { return fPhi;}
95d47440	118	Float_t GetPt() const { return fPt;}
0f2c4c4f	119	Bool_t GetDirections(Float_t &x0, Float_t &y0, Float_t &z0, Float_t &dydx, Float_t &dzdx, Float_t &pt, Float_t &p, Float_t &eta, Float_t &phi, UChar_t &s) const;
95d47440	120	AliTrackReference const* GetTrackRef(Int_t ref=0) const { return fTrackRefs[ref];}
	121	static Double_t GetKalmanStep() { return fgKalmanStep;}
	122	static Bool_t IsKalmanUpdate() { return fgKalmanUpdate;}
3ceb45ae	123	Bool_t PropagateKalman(
	124	TVectorD x, TVectorD y, TVectorD *z,
	125	TVectorD dx, TVectorD dy, TVectorD *dz,
	126	TVectorD pt, TVectorD dpt, TVectorD budget, TVectorD c, Double_t mass=-1) const;
95d47440	127	static void SetKalmanStep(Double_t s) { fgKalmanStep = s;}
95d47440	128	static void SetKalmanUpdate(Bool_t s=kTRUE) { fgKalmanUpdate = s;}
1ee39b3a	129	protected:
eb05d549	130	Int_t fLabel; // ESD label
eb05d549	131	Int_t fTRDlabel; // TRD label
5066aa9a	132	Int_t fPDG; // particle code
5066aa9a	133	Int_t fNTrackRefs; // number of track refs
95d47440	134	Float_t fEta; // particle eta (vertex)
	135	Float_t fPhi; // particle phi (vertex)
	136	Float_t fPt; // particle pt (vertex)
5066aa9a	137	static Double_t fgKalmanStep; // Kalman step propagation
3ceb45ae	138	static Bool_t fgKalmanUpdate; // Kalman update with TRD tracklets
1ee39b3a	139	AliTrackReference *fTrackRefs[kNTrackRefs]; // track refs array
5066aa9a	140
95d47440	141	ClassDef(AliMCinfo, 4) // MC info related to TRD
1ee39b3a	142	};
	143
	144	AliTRDtrackInfo();
	145	AliTRDtrackInfo(const AliTRDtrackInfo &trdInfo);
	146	~AliTRDtrackInfo();
4226db3e	147
1ee39b3a	148	// void Clear(const Option_t *){}
1ee39b3a	149	void Delete(const Option_t *);
1ee39b3a	150	AliTRDtrackInfo& operator=(const AliTRDtrackInfo &trdInfo);
1ee39b3a	151	void AddTrackRef(const AliTrackReference *trackRef);
3ceb45ae	152	Int_t GetTrackId() const { return fESD.fId;}
	153	const AliESDinfo* GetESDinfo() const { return &fESD; }
	154	const AliMCinfo* GetMCinfo() const { return fMC; }
1ee39b3a	155	Int_t GetNumberOfClusters() const;
3ceb45ae	156	Int_t GetNumberOfClustersRefit() const { return fNClusters;}
1ee39b3a	157	Int_t GetNTracklets() const;
3ceb45ae	158	Int_t GetNTrackRefs() const { return fMC ? fMC->fNTrackRefs:0;}
	159	Int_t GetLabel() const { return fMC ? fMC->fLabel:0; }
	160	Int_t GetKinkIndex() const { return fESD.fKinkIndex;}
566c3d46	161	Short_t GetTOFbc() const { return fESD.fTOFbc;}
3ceb45ae	162	UShort_t GetTPCncls() const { return fESD.fTPCncls;}
	163	Int_t GetPDG() const { return fMC ? fMC->fPDG : 0; }
	164	Int_t GetPID() const { return fMC ? fMC->GetPID() : -1; }
	165	ULong_t GetStatus() const { return fESD.fStatus;}
	166	AliTRDtrackV1* GetTrack() const { return fTRDtrack; }
1ee39b3a	167	AliTrackReference* GetTrackRef(Int_t entry) const;
61f6b45e	168	AliTrackReference* GetTrackRef(const AliTRDseedV1* const tracklet) const;
1ee39b3a	169
3ceb45ae	170	Bool_t IsCurved() const { return TestBit(kCurv);}
	171	Bool_t IsPrimary() const { return TestBit(kPrim);}
	172	Bool_t HasESDtrack() const { return ((fTRDtrack != 0x0) \|\|(fESD.fOP != 0));}
	173	Bool_t HasMCinfo() const { return (Bool_t)fMC; }
1ee39b3a	174
5047978d	175	void SetElectron(Bool_t c = kTRUE) { fESD.SetElectron(c);}
	176	void SetPion(Bool_t c = kTRUE) { fESD.SetPion(c);}
	177	void SetProton(Bool_t c = kTRUE) { fESD.SetProton(c);}
3ceb45ae	178	void SetCurved(Bool_t curv = kTRUE) { SetBit(kCurv, curv);}
3ceb45ae	179	void SetLabel(Int_t lab) { if(fMC) fMC->fLabel = lab; }
eb05d549	180	void SetTRDlabel(Int_t lab) { if(fMC) fMC->fTRDlabel = lab; }
3ceb45ae	181	void SetNumberOfClustersRefit(Int_t n){fNClusters = n;}
1ee39b3a	182	inline void SetMC();
95d47440	183	void SetMCeta(Float_t eta) { if(fMC) fMC->fEta = eta; }
	184	void SetMCphi(Float_t phi) { if(fMC) fMC->fPhi = phi; }
	185	void SetMCpt(Float_t pt) { if(fMC) fMC->fPt = pt; }
3ceb45ae	186	void SetPDG(Int_t pdg) { if(fMC) fMC->fPDG = pdg; }
3ceb45ae	187	void SetPrimary(Bool_t prim = kTRUE) {SetBit(kPrim, prim);}
eb05d549	188	void SetOuterParam(const AliExternalTrackParam *op) {fESD.SetOuterParam(op);}
	189	void SetITSoutParam(const AliExternalTrackParam *op) {fESD.SetITSoutParam(op);}
	190	void SetTPCoutParam(const AliExternalTrackParam *op) {fESD.SetTPCoutParam(op);}
3ceb45ae	191	void SetStatus(ULong_t stat) { fESD.fStatus = stat;}
3ceb45ae	192	void SetKinkIndex(Int_t kinkIndex) { fESD.fKinkIndex = kinkIndex;}
566c3d46	193	void SetTOFbc(Int_t bc) { fESD.fTOFbc = bc;}
f036f7ec	194	void SetTOFbeta(Float_t b) { fESD.fTOFbeta = b;}
3ceb45ae	195	void SetTPCncls(UShort_t TPCncls) { fESD.fTPCncls = TPCncls;}
2b33fd9c	196	void SetTPCdedx(Float_t dedx) { fESD.fTPCdedx = dedx;}
3ceb45ae	197	void SetTrackId(Int_t id) { fESD.fId = id;}
1ee39b3a	198	void SetTrack(const AliTRDtrackV1 *track);
eb05d549	199	void SetTrackPointArray(const AliTrackPointArray *tps) {fESD.SetTrackPointArray(tps);}
3ceb45ae	200	void SetESDpidQuality(UChar_t q) { fESD.fTRDpidQuality = q;}
1ee39b3a	201	void SetSlices(Int_t n, Double32_t *s);
1ee39b3a	202	inline void SetESDpid(Double_t *);
eb05d549	203	void SetESDeta(Float_t eta) { fESD.fEta = eta;}
	204	void SetESDphi(Float_t phi) { fESD.fPhi = phi;}
	205	void SetESDpt(Float_t pt) { fESD.fPt = pt;}
b554ac34	206	inline void SetV0pid(Int_t *);
5047978d	207	void SetV0(Bool_t v0=kTRUE) { fESD.SetV0(v0);}
1ee39b3a	208
	209	private:
	210	enum{
	211	kCurv = 14,
	212	kPrim = 15
	213	};
	214	// this 2 data members have to go to ESD header.
	215	Int_t fNClusters; // Numer of clusters from refit
	216	AliTRDtrackV1 *fTRDtrack; // tracklets data array
	217	AliMCinfo *fMC; // MC extract for TRD
	218	AliESDinfo fESD; // ESD extract for TRD
	219
b554ac34	220	ClassDef(AliTRDtrackInfo, 4) // TRD track info
1ee39b3a	221	};
	222
	223
	224	//________________________________________________________
	225	inline void AliTRDtrackInfo::SetMC()
	226	{
	227	if(!fMC) fMC = new AliMCinfo();
	228	}
	229
	230	//________________________________________________________
	231	inline void AliTRDtrackInfo::SetESDpid(Double_t * const r)
	232	{
	233	for(Int_t is = AliPID::kSPECIES; is--;) fESD.fTRDr[is] = r[is];
	234	}
	235
b554ac34	236	//________________________________________________________
	237	inline void AliTRDtrackInfo::SetV0pid(Int_t * const r)
	238	{
	239	for(Int_t is = AliPID::kSPECIES; is--;) fESD.fTRDv0pid[is] = r[is];
	240	}
	241
1ee39b3a	242	#endif