[u/mrichter/AliRoot.git] / STEER / AliAODTrack.cxx

/**************************************************************************
 * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */

//-------------------------------------------------------------------------
//     AOD track base class
//     Author: Markus Oldenburg, CERN
//-------------------------------------------------------------------------

#include "AliAODTrack.h"

ClassImp(AliAODTrack)

//______________________________________________________________________________
AliAODTrack::AliAODTrack() : 
  AliVirtualParticle(),
  fChi2(-999.),
  fID(-999),
  fLabel(-999),
  fCovMatrix(NULL),
  fProdVertex(0x0),
  fCharge(-999),
  fITSClusterMap(0),
  fType(kUndef)
{
  // default constructor

  SetP();
  SetPosition((Float_t*)NULL);
  SetPID((Float_t*)NULL);
}

//______________________________________________________________________________
AliAODTrack::AliAODTrack(Int_t id,
			 Int_t label, 
			 Double_t p[3],
			 Bool_t cartesian,
			 Double_t x[3],
			 Bool_t isDCA,
			 Double_t covMatrix[21],
			 Short_t charge,
			 UChar_t itsClusMap,
			 Double_t pid[10],
			 AliAODVertex *prodVertex,
			 AODTrk_t ttype) :
  AliVirtualParticle(),
  fChi2(-999.),
  fID(id),
  fLabel(label),
  fCovMatrix(NULL),
  fProdVertex(prodVertex),
  fCharge(charge),
  fITSClusterMap(itsClusMap),
  fType(ttype)
{
  // constructor
 
  SetP(p, cartesian);
  SetPosition(x, isDCA);
  if(covMatrix) SetCovMatrix(covMatrix);
  SetPID(pid);

}

//______________________________________________________________________________
AliAODTrack::AliAODTrack(Int_t id,
			 Int_t label, 
			 Float_t p[3],
			 Bool_t cartesian,
			 Float_t x[3],
			 Bool_t isDCA,
			 Float_t covMatrix[21],
			 Short_t charge,
			 UChar_t itsClusMap,
			 Float_t pid[10],
			 AliAODVertex *prodVertex,
			 AODTrk_t ttype) :
  AliVirtualParticle(),
  fChi2(-999.),
  fID(id),
  fLabel(label),
  fCovMatrix(NULL),
  fProdVertex(prodVertex),
  fCharge(charge),
  fITSClusterMap(itsClusMap),
  fType(ttype)
{
  // constructor
 
  SetP(p, cartesian);
  SetPosition(x, isDCA);
  if(covMatrix) SetCovMatrix(covMatrix);
  SetPID(pid);

}


//______________________________________________________________________________
AliAODTrack::~AliAODTrack() 
{
  // destructor
  delete fCovMatrix;
}


//______________________________________________________________________________
AliAODTrack::AliAODTrack(const AliAODTrack& trk) :
  AliVirtualParticle(trk),
  fChi2(trk.fChi2),
  fID(trk.fID),
  fLabel(trk.fLabel),
  fCovMatrix(NULL),
  fProdVertex(trk.fProdVertex),
  fCharge(trk.fCharge),
  fITSClusterMap(trk.fITSClusterMap),
  fType(trk.fType)
{
  // Copy constructor

  trk.GetP(fMomentum);
  trk.GetPosition(fPosition);
  if(trk.fCovMatrix) fCovMatrix=new AliAODTrkCov(*trk.fCovMatrix);
  SetPID(trk.fPID);

}

//______________________________________________________________________________
AliAODTrack& AliAODTrack::operator=(const AliAODTrack& trk)
{
  // Assignment operator
  if(this!=&trk) {

    AliVirtualParticle::operator=(trk);

    trk.GetP(fMomentum);
    trk.GetPosition(fPosition);
    trk.GetPID(fPID);

    fChi2 = trk.fChi2;

    fID = trk.fID;
    fLabel = trk.fLabel;    
    
    delete fCovMatrix;
    if(trk.fCovMatrix) fCovMatrix=new AliAODTrkCov(*trk.fCovMatrix);
    else fCovMatrix=NULL;
    fProdVertex = trk.fProdVertex;

    fCharge = trk.fCharge;
    fITSClusterMap = trk.fITSClusterMap;
    fType = trk.fType;
  }

  return *this;
}

//______________________________________________________________________________
template <class T> void AliAODTrack::SetP(const T *p, const Bool_t cartesian) 
{
  // set the momentum

  if (p) {
    if (cartesian) {
      Double_t pt = TMath::Sqrt(p[0]*p[0] + p[1]*p[1]);
      Double_t P = TMath::Sqrt(pt*pt + p[2]*p[2]);
      
      fMomentum[0] = 1./pt;
      fMomentum[1] = TMath::ACos(p[2]/P);
      fMomentum[2] = TMath::ATan2(p[1], p[0]);
    } else {
      fMomentum[0] = p[0];  // 1/pt
      fMomentum[1] = p[1];  // phi
      fMomentum[2] = p[2];  // theta
    }
  } else {
    fMomentum[0] = -999.;
    fMomentum[1] = -999.;
    fMomentum[2] = -999.;
  }
}

//______________________________________________________________________________
template <class T> void AliAODTrack::SetPosition(const T *x, const Bool_t dca) 
{
  // set the position

  if (x) {
    if (!dca) {
      ResetBit(kIsDCA);

      fPosition[0] = x[0];
      fPosition[1] = x[1];
      fPosition[2] = x[2];
    } else {
      SetBit(kIsDCA);
      // don't know any better yet
      fPosition[0] = -999.;
      fPosition[1] = -999.;
      fPosition[2] = -999.;
    }
  } else {
    ResetBit(kIsDCA);

    fPosition[0] = -999.;
    fPosition[1] = -999.;
    fPosition[2] = -999.;
  }
}

//______________________________________________________________________________
void AliAODTrack::SetDCA(Double_t d, Double_t z) 
{
  // set the dca
  fPosition[0] = d;
  fPosition[1] = z;
  fPosition[2] = 0.;
  SetBit(kIsDCA);
}

//______________________________________________________________________________
void AliAODTrack::Print(Option_t* /* option */) const
{
  // prints information about AliAODTrack

  printf("Object name: %s   Track type: %s\n", GetName(), GetTitle()); 
  printf("        px = %f\n", Px());
  printf("        py = %f\n", Py());
  printf("        pz = %f\n", Pz());
  printf("        pt = %f\n", Pt());
  printf("      1/pt = %f\n", OneOverPt());
  printf("     theta = %f\n", Theta());
  printf("       phi = %f\n", Phi());
  printf("      chi2 = %f\n", Chi2());
  printf("    charge = %d\n", Charge());
  printf(" PID object: %p\n", PID());
}

//-------------------------------------------------------------------------
//     AOD track cov matrix base class
//-------------------------------------------------------------------------

ClassImp(AliAODTrack::AliAODTrkCov)

//______________________________________________________________________________
template <class T> void AliAODTrack::AliAODTrkCov::GetCovMatrix(T *cmat) const
{
  //
  // Returns the external cov matrix
  //
  cmat[ 0] = fDiag[ 0]*fDiag[ 0];
  cmat[ 2] = fDiag[ 1]*fDiag[ 1];
  cmat[ 5] = fDiag[ 2]*fDiag[ 2];
  cmat[ 9] = fDiag[ 3]*fDiag[ 3];
  cmat[14] = fDiag[ 4]*fDiag[ 4];
  cmat[20] = fDiag[ 5]*fDiag[ 5];
  //
  cmat[ 1] = fODia[ 0]*fDiag[ 0]*fDiag[ 1];
  cmat[ 3] = fODia[ 1]*fDiag[ 0]*fDiag[ 2];
  cmat[ 4] = fODia[ 2]*fDiag[ 1]*fDiag[ 2];
  cmat[ 6] = fODia[ 3]*fDiag[ 0]*fDiag[ 3];
  cmat[ 7] = fODia[ 4]*fDiag[ 1]*fDiag[ 3];
  cmat[ 8] = fODia[ 5]*fDiag[ 2]*fDiag[ 3];
  cmat[10] = fODia[ 6]*fDiag[ 0]*fDiag[ 4];
  cmat[11] = fODia[ 7]*fDiag[ 1]*fDiag[ 4];
  cmat[12] = fODia[ 8]*fDiag[ 2]*fDiag[ 4];
  cmat[13] = fODia[ 9]*fDiag[ 3]*fDiag[ 4];
  cmat[15] = fODia[10]*fDiag[ 0]*fDiag[ 5];
  cmat[16] = fODia[11]*fDiag[ 1]*fDiag[ 5];
  cmat[17] = fODia[12]*fDiag[ 2]*fDiag[ 5];
  cmat[18] = fODia[13]*fDiag[ 3]*fDiag[ 5];
  cmat[19] = fODia[14]*fDiag[ 4]*fDiag[ 5];
}


//______________________________________________________________________________
template <class T> void AliAODTrack::AliAODTrkCov::SetCovMatrix(T *cmat)
{
  //
  // Sets the external cov matrix
  //
  if(cmat) {
    fDiag[ 0] = TMath::Sqrt(cmat[ 0]);
    fDiag[ 1] = TMath::Sqrt(cmat[ 2]);
    fDiag[ 2] = TMath::Sqrt(cmat[ 5]);
    fDiag[ 3] = TMath::Sqrt(cmat[ 9]);
    fDiag[ 4] = TMath::Sqrt(cmat[14]);
    fDiag[ 5] = TMath::Sqrt(cmat[20]);
    //
    fODia[ 0] = cmat[ 1]/(fDiag[ 0]*fDiag[ 1]);
    fODia[ 1] = cmat[ 3]/(fDiag[ 0]*fDiag[ 2]);
    fODia[ 2] = cmat[ 4]/(fDiag[ 1]*fDiag[ 2]);
    fODia[ 3] = cmat[ 6]/(fDiag[ 0]*fDiag[ 3]);
    fODia[ 4] = cmat[ 7]/(fDiag[ 1]*fDiag[ 3]);
    fODia[ 5] = cmat[ 8]/(fDiag[ 2]*fDiag[ 3]);
    fODia[ 6] = cmat[10]/(fDiag[ 0]*fDiag[ 4]);
    fODia[ 7] = cmat[11]/(fDiag[ 1]*fDiag[ 4]);
    fODia[ 8] = cmat[12]/(fDiag[ 2]*fDiag[ 4]);
    fODia[ 9] = cmat[13]/(fDiag[ 3]*fDiag[ 4]);
    fODia[10] = cmat[15]/(fDiag[ 0]*fDiag[ 5]);
    fODia[11] = cmat[16]/(fDiag[ 1]*fDiag[ 5]);
    fODia[12] = cmat[17]/(fDiag[ 2]*fDiag[ 5]);
    fODia[13] = cmat[18]/(fDiag[ 3]*fDiag[ 5]);
    fODia[14] = cmat[19]/(fDiag[ 4]*fDiag[ 5]);
  } else {
    for(Int_t i=0; i< 6; ++i) fDiag[i]=-999.;
    for(Int_t i=0; i<15; ++i) fODia[i]=0.;
  }
}
Commit	Line	Data
df9db588	1	/**************************************************************************
	2	* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/* $Id$ */
	17
	18	//-------------------------------------------------------------------------
	19	// AOD track base class
	20	// Author: Markus Oldenburg, CERN
	21	//-------------------------------------------------------------------------
	22
	23	#include "AliAODTrack.h"
	24
	25	ClassImp(AliAODTrack)
	26
	27	//______________________________________________________________________________
	28	AliAODTrack::AliAODTrack() :
	29	AliVirtualParticle(),
	30	fChi2(-999.),
	31	fID(-999),
	32	fLabel(-999),
	33	fCovMatrix(NULL),
	34	fProdVertex(0x0),
	35	fCharge(-999),
	36	fITSClusterMap(0),
	37	fType(kUndef)
	38	{
	39	// default constructor
	40
	41	SetP();
	42	SetPosition((Float_t*)NULL);
	43	SetPID((Float_t*)NULL);
	44	}
	45
	46	//______________________________________________________________________________
	47	AliAODTrack::AliAODTrack(Int_t id,
	48	Int_t label,
	49	Double_t p[3],
	50	Bool_t cartesian,
	51	Double_t x[3],
	52	Bool_t isDCA,
	53	Double_t covMatrix[21],
	54	Short_t charge,
	55	UChar_t itsClusMap,
	56	Double_t pid[10],
	57	AliAODVertex *prodVertex,
	58	AODTrk_t ttype) :
	59	AliVirtualParticle(),
	60	fChi2(-999.),
	61	fID(id),
	62	fLabel(label),
	63	fCovMatrix(NULL),
	64	fProdVertex(prodVertex),
65	fCharge(charge),
66	fITSClusterMap(itsClusMap),
67	fType(ttype)
68	{
69	// constructor
70
71	SetP(p, cartesian);
72	SetPosition(x, isDCA);
73	if(covMatrix) SetCovMatrix(covMatrix);
74	SetPID(pid);
75
76	}
77
78	//______________________________________________________________________________
79	AliAODTrack::AliAODTrack(Int_t id,
80	Int_t label,
81	Float_t p[3],
82	Bool_t cartesian,
83	Float_t x[3],
84	Bool_t isDCA,
85	Float_t covMatrix[21],
86	Short_t charge,
87	UChar_t itsClusMap,
88	Float_t pid[10],
89	AliAODVertex *prodVertex,
90	AODTrk_t ttype) :
91	AliVirtualParticle(),
92	fChi2(-999.),
93	fID(id),
94	fLabel(label),
95	fCovMatrix(NULL),
96	fProdVertex(prodVertex),
97	fCharge(charge),
98	fITSClusterMap(itsClusMap),
99	fType(ttype)
100	{
101	// constructor
102
103	SetP(p, cartesian);
104	SetPosition(x, isDCA);
105	if(covMatrix) SetCovMatrix(covMatrix);
106	SetPID(pid);
107
108	}
109
110
111	//______________________________________________________________________________
112	AliAODTrack::~AliAODTrack()
113	{
114	// destructor
115	delete fCovMatrix;
116	}
117
118
119	//______________________________________________________________________________
120	AliAODTrack::AliAODTrack(const AliAODTrack& trk) :
121	AliVirtualParticle(trk),
122	fChi2(trk.fChi2),
123	fID(trk.fID),
124	fLabel(trk.fLabel),
125	fCovMatrix(NULL),
126	fProdVertex(trk.fProdVertex),
127	fCharge(trk.fCharge),
128	fITSClusterMap(trk.fITSClusterMap),
129	fType(trk.fType)
130	{
131	// Copy constructor
132
133	trk.GetP(fMomentum);
134	trk.GetPosition(fPosition);
135	if(trk.fCovMatrix) fCovMatrix=new AliAODTrkCov(*trk.fCovMatrix);
136	SetPID(trk.fPID);
137
138	}
139
140	//______________________________________________________________________________
141	AliAODTrack& AliAODTrack::operator=(const AliAODTrack& trk)
142	{
143	// Assignment operator
144	if(this!=&trk) {
145
146	AliVirtualParticle::operator=(trk);
147
148	trk.GetP(fMomentum);
149	trk.GetPosition(fPosition);
150	trk.GetPID(fPID);
151
152	fChi2 = trk.fChi2;
153
154	fID = trk.fID;
155	fLabel = trk.fLabel;
156
157	delete fCovMatrix;
158	if(trk.fCovMatrix) fCovMatrix=new AliAODTrkCov(*trk.fCovMatrix);
159	else fCovMatrix=NULL;
160	fProdVertex = trk.fProdVertex;
161
162	fCharge = trk.fCharge;
163	fITSClusterMap = trk.fITSClusterMap;
164	fType = trk.fType;
165	}
166
167	return *this;
168	}
169
170	//______________________________________________________________________________
171	template <class T> void AliAODTrack::SetP(const T *p, const Bool_t cartesian)
172	{
173	// set the momentum
174
175	if (p) {
176	if (cartesian) {
177	Double_t pt = TMath::Sqrt(p[0]p[0] + p[1]p[1]);
178	Double_t P = TMath::Sqrt(ptpt + p[2]p[2]);
179
180	fMomentum[0] = 1./pt;
181	fMomentum[1] = TMath::ACos(p[2]/P);
182	fMomentum[2] = TMath::ATan2(p[1], p[0]);
183	} else {
184	fMomentum[0] = p[0]; // 1/pt
185	fMomentum[1] = p[1]; // phi
186	fMomentum[2] = p[2]; // theta
187	}
188	} else {
189	fMomentum[0] = -999.;
190	fMomentum[1] = -999.;
191	fMomentum[2] = -999.;
192	}
193	}
194
195	//______________________________________________________________________________
196	template <class T> void AliAODTrack::SetPosition(const T *x, const Bool_t dca)
197	{
198	// set the position
199
200	if (x) {
201	if (!dca) {
202	ResetBit(kIsDCA);
203
204	fPosition[0] = x[0];
205	fPosition[1] = x[1];
206	fPosition[2] = x[2];
207	} else {
208	SetBit(kIsDCA);
209	// don't know any better yet
210	fPosition[0] = -999.;
211	fPosition[1] = -999.;
212	fPosition[2] = -999.;
213	}
214	} else {
215	ResetBit(kIsDCA);
216
217	fPosition[0] = -999.;
218	fPosition[1] = -999.;
219	fPosition[2] = -999.;
220	}
221	}
222
223	//______________________________________________________________________________
224	void AliAODTrack::SetDCA(Double_t d, Double_t z)
225	{
226	// set the dca
227	fPosition[0] = d;
228	fPosition[1] = z;
229	fPosition[2] = 0.;
230	SetBit(kIsDCA);
231	}
232
233	//______________________________________________________________________________
234	void AliAODTrack::Print(Option_t* /* option */) const
235	{
236	// prints information about AliAODTrack
237
238	printf("Object name: %s Track type: %s\n", GetName(), GetTitle());
239	printf(" px = %f\n", Px());
240	printf(" py = %f\n", Py());
241	printf(" pz = %f\n", Pz());
242	printf(" pt = %f\n", Pt());
243	printf(" 1/pt = %f\n", OneOverPt());
244	printf(" theta = %f\n", Theta());
245	printf(" phi = %f\n", Phi());
246	printf(" chi2 = %f\n", Chi2());
247	printf(" charge = %d\n", Charge());
248	printf(" PID object: %p\n", PID());
249	}
250
251	//-------------------------------------------------------------------------
252	// AOD track cov matrix base class
253	//-------------------------------------------------------------------------
254
255	ClassImp(AliAODTrack::AliAODTrkCov)
256
257	//______________________________________________________________________________
258	template <class T> void AliAODTrack::AliAODTrkCov::GetCovMatrix(T *cmat) const
259	{
260	//
261	// Returns the external cov matrix
262	//
263	cmat[ 0] = fDiag[ 0]*fDiag[ 0];
264	cmat[ 2] = fDiag[ 1]*fDiag[ 1];
265	cmat[ 5] = fDiag[ 2]*fDiag[ 2];
266	cmat[ 9] = fDiag[ 3]*fDiag[ 3];
267	cmat[14] = fDiag[ 4]*fDiag[ 4];
268	cmat[20] = fDiag[ 5]*fDiag[ 5];
269	//
270	cmat[ 1] = fODia[ 0]fDiag[ 0]fDiag[ 1];
271	cmat[ 3] = fODia[ 1]fDiag[ 0]fDiag[ 2];
272	cmat[ 4] = fODia[ 2]fDiag[ 1]fDiag[ 2];
273	cmat[ 6] = fODia[ 3]fDiag[ 0]fDiag[ 3];
274	cmat[ 7] = fODia[ 4]fDiag[ 1]fDiag[ 3];
275	cmat[ 8] = fODia[ 5]fDiag[ 2]fDiag[ 3];
276	cmat[10] = fODia[ 6]fDiag[ 0]fDiag[ 4];
277	cmat[11] = fODia[ 7]fDiag[ 1]fDiag[ 4];
278	cmat[12] = fODia[ 8]fDiag[ 2]fDiag[ 4];
279	cmat[13] = fODia[ 9]fDiag[ 3]fDiag[ 4];
280	cmat[15] = fODia[10]fDiag[ 0]fDiag[ 5];
281	cmat[16] = fODia[11]fDiag[ 1]fDiag[ 5];
282	cmat[17] = fODia[12]fDiag[ 2]fDiag[ 5];
283	cmat[18] = fODia[13]fDiag[ 3]fDiag[ 5];
284	cmat[19] = fODia[14]fDiag[ 4]fDiag[ 5];
285	}
286
287
288	//______________________________________________________________________________
289	template <class T> void AliAODTrack::AliAODTrkCov::SetCovMatrix(T *cmat)
290	{
291	//
292	// Sets the external cov matrix
293	//
294	if(cmat) {
295	fDiag[ 0] = TMath::Sqrt(cmat[ 0]);
296	fDiag[ 1] = TMath::Sqrt(cmat[ 2]);
297	fDiag[ 2] = TMath::Sqrt(cmat[ 5]);
298	fDiag[ 3] = TMath::Sqrt(cmat[ 9]);
299	fDiag[ 4] = TMath::Sqrt(cmat[14]);
300	fDiag[ 5] = TMath::Sqrt(cmat[20]);
301	//
302	fODia[ 0] = cmat[ 1]/(fDiag[ 0]*fDiag[ 1]);
303	fODia[ 1] = cmat[ 3]/(fDiag[ 0]*fDiag[ 2]);
304	fODia[ 2] = cmat[ 4]/(fDiag[ 1]*fDiag[ 2]);
305	fODia[ 3] = cmat[ 6]/(fDiag[ 0]*fDiag[ 3]);
306	fODia[ 4] = cmat[ 7]/(fDiag[ 1]*fDiag[ 3]);
307	fODia[ 5] = cmat[ 8]/(fDiag[ 2]*fDiag[ 3]);
308	fODia[ 6] = cmat[10]/(fDiag[ 0]*fDiag[ 4]);
309	fODia[ 7] = cmat[11]/(fDiag[ 1]*fDiag[ 4]);
310	fODia[ 8] = cmat[12]/(fDiag[ 2]*fDiag[ 4]);
311	fODia[ 9] = cmat[13]/(fDiag[ 3]*fDiag[ 4]);
312	fODia[10] = cmat[15]/(fDiag[ 0]*fDiag[ 5]);
313	fODia[11] = cmat[16]/(fDiag[ 1]*fDiag[ 5]);
314	fODia[12] = cmat[17]/(fDiag[ 2]*fDiag[ 5]);
315	fODia[13] = cmat[18]/(fDiag[ 3]*fDiag[ 5]);
316	fODia[14] = cmat[19]/(fDiag[ 4]*fDiag[ 5]);
317	} else {
318	for(Int_t i=0; i< 6; ++i) fDiag[i]=-999.;
319	for(Int_t i=0; i<15; ++i) fODia[i]=0.;
320	}
321	}