[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(-99),
  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,
			 Bool_t usedForPrimVtxFit,
			 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);
  SetUsedForPrimVtxFit(usedForPrimVtxFit);
  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,
			 Bool_t usedForPrimVtxFit,
			 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);
  SetUsedForPrimVtxFit(usedForPrimVtxFit);
  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);
  SetUsedForPrimVtxFit(trk.GetUsedForPrimVtxFit());
  if(trk.fCovMatrix) fCovMatrix=new AliAODRedCov<6>(*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 AliAODRedCov<6>(*trk.fCovMatrix);
    else fCovMatrix=NULL;
    fProdVertex = trk.fProdVertex;

    fCharge = trk.fCharge;
    fITSClusterMap = trk.fITSClusterMap;
    SetUsedForPrimVtxFit(trk.GetUsedForPrimVtxFit());
    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 pt2 = p[0]*p[0] + p[1]*p[1];
      Double_t P = TMath::Sqrt(pt2 + p[2]*p[2]);
      
      fMomentum[0] = TMath::Sqrt(pt2); // pt
      fMomentum[1] = (pt2 != 0.) ? TMath::ATan2(p[1], p[0]) : -999; // phi
      fMomentum[2] = (P != 0.) ? TMath::ACos(p[2]/P) : -999.; // theta
    } else {
      fMomentum[0] = p[0];  // 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());
}
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),
14b34be5	35	fCharge(-99),
df9db588	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,
dc825b15	58	Bool_t usedForPrimVtxFit,
df9db588	59	AODTrk_t ttype) :
	60	AliVirtualParticle(),
	61	fChi2(-999.),
	62	fID(id),
	63	fLabel(label),
	64	fCovMatrix(NULL),
	65	fProdVertex(prodVertex),
	66	fCharge(charge),
	67	fITSClusterMap(itsClusMap),
	68	fType(ttype)
	69	{
	70	// constructor
	71
	72	SetP(p, cartesian);
	73	SetPosition(x, isDCA);
dc825b15	74	SetUsedForPrimVtxFit(usedForPrimVtxFit);
df9db588	75	if(covMatrix) SetCovMatrix(covMatrix);
	76	SetPID(pid);
	77
	78	}
	79
	80	//______________________________________________________________________________
	81	AliAODTrack::AliAODTrack(Int_t id,
	82	Int_t label,
	83	Float_t p[3],
	84	Bool_t cartesian,
	85	Float_t x[3],
	86	Bool_t isDCA,
	87	Float_t covMatrix[21],
	88	Short_t charge,
	89	UChar_t itsClusMap,
	90	Float_t pid[10],
	91	AliAODVertex *prodVertex,
dc825b15	92	Bool_t usedForPrimVtxFit,
df9db588	93	AODTrk_t ttype) :
	94	AliVirtualParticle(),
	95	fChi2(-999.),
	96	fID(id),
	97	fLabel(label),
	98	fCovMatrix(NULL),
	99	fProdVertex(prodVertex),
	100	fCharge(charge),
	101	fITSClusterMap(itsClusMap),
	102	fType(ttype)
	103	{
	104	// constructor
	105
	106	SetP(p, cartesian);
	107	SetPosition(x, isDCA);
dc825b15	108	SetUsedForPrimVtxFit(usedForPrimVtxFit);
df9db588	109	if(covMatrix) SetCovMatrix(covMatrix);
df9db588	110	SetPID(pid);
df9db588	111	}
df9db588	112
df9db588	113	//______________________________________________________________________________
	114	AliAODTrack::~AliAODTrack()
	115	{
	116	// destructor
	117	delete fCovMatrix;
	118	}
	119
	120
	121	//______________________________________________________________________________
	122	AliAODTrack::AliAODTrack(const AliAODTrack& trk) :
	123	AliVirtualParticle(trk),
	124	fChi2(trk.fChi2),
	125	fID(trk.fID),
	126	fLabel(trk.fLabel),
	127	fCovMatrix(NULL),
	128	fProdVertex(trk.fProdVertex),
	129	fCharge(trk.fCharge),
	130	fITSClusterMap(trk.fITSClusterMap),
	131	fType(trk.fType)
	132	{
	133	// Copy constructor
	134
	135	trk.GetP(fMomentum);
	136	trk.GetPosition(fPosition);
dc825b15	137	SetUsedForPrimVtxFit(trk.GetUsedForPrimVtxFit());
5d62ce04	138	if(trk.fCovMatrix) fCovMatrix=new AliAODRedCov<6>(*trk.fCovMatrix);
df9db588	139	SetPID(trk.fPID);
	140
	141	}
	142
	143	//______________________________________________________________________________
	144	AliAODTrack& AliAODTrack::operator=(const AliAODTrack& trk)
	145	{
	146	// Assignment operator
	147	if(this!=&trk) {
	148
	149	AliVirtualParticle::operator=(trk);
	150
	151	trk.GetP(fMomentum);
	152	trk.GetPosition(fPosition);
	153	trk.GetPID(fPID);
	154
	155	fChi2 = trk.fChi2;
	156
	157	fID = trk.fID;
	158	fLabel = trk.fLabel;
	159
	160	delete fCovMatrix;
5d62ce04	161	if(trk.fCovMatrix) fCovMatrix=new AliAODRedCov<6>(*trk.fCovMatrix);
df9db588	162	else fCovMatrix=NULL;
	163	fProdVertex = trk.fProdVertex;
	164
	165	fCharge = trk.fCharge;
	166	fITSClusterMap = trk.fITSClusterMap;
dc825b15	167	SetUsedForPrimVtxFit(trk.GetUsedForPrimVtxFit());
df9db588	168	fType = trk.fType;
	169	}
	170
	171	return *this;
	172	}
	173
	174	//______________________________________________________________________________
	175	template <class T> void AliAODTrack::SetP(const T *p, const Bool_t cartesian)
	176	{
	177	// set the momentum
	178
	179	if (p) {
	180	if (cartesian) {
16b65f2a	181	Double_t pt2 = p[0]p[0] + p[1]p[1];
16b65f2a	182	Double_t P = TMath::Sqrt(pt2 + p[2]*p[2]);
df9db588	183
16b65f2a	184	fMomentum[0] = TMath::Sqrt(pt2); // pt
	185	fMomentum[1] = (pt2 != 0.) ? TMath::ATan2(p[1], p[0]) : -999; // phi
	186	fMomentum[2] = (P != 0.) ? TMath::ACos(p[2]/P) : -999.; // theta
df9db588	187	} else {
16b65f2a	188	fMomentum[0] = p[0]; // pt
df9db588	189	fMomentum[1] = p[1]; // phi
	190	fMomentum[2] = p[2]; // theta
	191	}
	192	} else {
	193	fMomentum[0] = -999.;
	194	fMomentum[1] = -999.;
	195	fMomentum[2] = -999.;
	196	}
	197	}
	198
	199	//______________________________________________________________________________
	200	template <class T> void AliAODTrack::SetPosition(const T *x, const Bool_t dca)
	201	{
	202	// set the position
	203
	204	if (x) {
	205	if (!dca) {
	206	ResetBit(kIsDCA);
	207
	208	fPosition[0] = x[0];
	209	fPosition[1] = x[1];
	210	fPosition[2] = x[2];
	211	} else {
	212	SetBit(kIsDCA);
	213	// don't know any better yet
	214	fPosition[0] = -999.;
	215	fPosition[1] = -999.;
	216	fPosition[2] = -999.;
	217	}
	218	} else {
	219	ResetBit(kIsDCA);
	220
	221	fPosition[0] = -999.;
	222	fPosition[1] = -999.;
	223	fPosition[2] = -999.;
	224	}
	225	}
	226
	227	//______________________________________________________________________________
	228	void AliAODTrack::SetDCA(Double_t d, Double_t z)
	229	{
	230	// set the dca
	231	fPosition[0] = d;
	232	fPosition[1] = z;
	233	fPosition[2] = 0.;
	234	SetBit(kIsDCA);
	235	}
	236
	237	//______________________________________________________________________________
	238	void AliAODTrack::Print(Option_t* /* option */) const
	239	{
	240	// prints information about AliAODTrack
	241
	242	printf("Object name: %s Track type: %s\n", GetName(), GetTitle());
	243	printf(" px = %f\n", Px());
	244	printf(" py = %f\n", Py());
	245	printf(" pz = %f\n", Pz());
	246	printf(" pt = %f\n", Pt());
	247	printf(" 1/pt = %f\n", OneOverPt());
	248	printf(" theta = %f\n", Theta());
	249	printf(" phi = %f\n", Phi());
	250	printf(" chi2 = %f\n", Chi2());
	251	printf(" charge = %d\n", Charge());
	252	printf(" PID object: %p\n", PID());
253	}
254