[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 implementation of AliVTrack
//     Author: Markus Oldenburg, CERN
//     Markus.Oldenburg@cern.ch
//-------------------------------------------------------------------------

#include "AliLog.h"
#include "AliExternalTrackParam.h"
#include "AliVVertex.h"
#include "AliAODTrack.h"

ClassImp(AliAODTrack)

//______________________________________________________________________________
AliAODTrack::AliAODTrack() : 
  AliVTrack(),
  fRAtAbsorberEnd(0.),
  fChi2perNDF(-999.),
  fChi2MatchTrigger(0.),
  fFlags(0),
  fLabel(-999),
  fITSMuonClusterMap(0),
  fFilterMap(0),
  fTPCClusterMap(),
  fTPCSharedMap(),
  fID(-999),
  fCharge(-99),
  fType(kUndef),
  fCovMatrix(NULL),
  fDetPid(NULL),
  fProdVertex(NULL)
{
  // default constructor

  SetP();
  SetPosition((Float_t*)NULL);
  SetXYAtDCA(-999., -999.);
  SetPxPyPzAtDCA(-999., -999., -999.);
  SetPID((Float_t*)NULL);
}

//______________________________________________________________________________
AliAODTrack::AliAODTrack(Short_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 usedForVtxFit,
			 Bool_t usedForPrimVtxFit,
			 AODTrk_t ttype,
			 UInt_t selectInfo,
			 Float_t chi2perNDF) :
  AliVTrack(),
  fRAtAbsorberEnd(0.),
  fChi2perNDF(chi2perNDF),
  fChi2MatchTrigger(0.),
  fFlags(0),
  fLabel(label),
  fITSMuonClusterMap(0),
  fFilterMap(selectInfo),
  fTPCClusterMap(),
  fTPCSharedMap(),
  fID(id),
  fCharge(charge),
  fType(ttype),
  fCovMatrix(NULL),
  fDetPid(NULL),
  fProdVertex(prodVertex)
{
  // constructor
 
  SetP(p, cartesian);
  SetPosition(x, isDCA);
  SetXYAtDCA(-999., -999.);
  SetPxPyPzAtDCA(-999., -999., -999.);
  SetUsedForVtxFit(usedForVtxFit);
  SetUsedForPrimVtxFit(usedForPrimVtxFit);
  if(covMatrix) SetCovMatrix(covMatrix);
  SetPID(pid);
  SetITSClusterMap(itsClusMap);
}

//______________________________________________________________________________
AliAODTrack::AliAODTrack(Short_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 usedForVtxFit,
			 Bool_t usedForPrimVtxFit,
			 AODTrk_t ttype,
			 UInt_t selectInfo,
			 Float_t chi2perNDF) :
  AliVTrack(),
  fRAtAbsorberEnd(0.),
  fChi2perNDF(chi2perNDF),
  fChi2MatchTrigger(0.),
  fFlags(0),
  fLabel(label),
  fITSMuonClusterMap(0),
  fFilterMap(selectInfo),
  fTPCClusterMap(),
  fTPCSharedMap(),
  fID(id),
  fCharge(charge),
  fType(ttype),
  fCovMatrix(NULL),
  fDetPid(NULL),
  fProdVertex(prodVertex)
{
  // constructor
 
  SetP(p, cartesian);
  SetPosition(x, isDCA);
  SetXYAtDCA(-999., -999.);
  SetPxPyPzAtDCA(-999., -999., -999.);
  SetUsedForVtxFit(usedForVtxFit);
  SetUsedForPrimVtxFit(usedForPrimVtxFit);
  if(covMatrix) SetCovMatrix(covMatrix);
  SetPID(pid);
  SetITSClusterMap(itsClusMap);
}

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


//______________________________________________________________________________
AliAODTrack::AliAODTrack(const AliAODTrack& trk) :
  AliVTrack(trk),
  fRAtAbsorberEnd(trk.fRAtAbsorberEnd),
  fChi2perNDF(trk.fChi2perNDF),
  fChi2MatchTrigger(trk.fChi2MatchTrigger),
  fFlags(trk.fFlags),
  fLabel(trk.fLabel),
  fITSMuonClusterMap(trk.fITSMuonClusterMap),
  fFilterMap(trk.fFilterMap),
  fTPCClusterMap(trk.fTPCClusterMap),
  fTPCSharedMap(trk.fTPCSharedMap),
  fID(trk.fID),
  fCharge(trk.fCharge),
  fType(trk.fType),
  fCovMatrix(NULL),
  fDetPid(NULL),
  fProdVertex(trk.fProdVertex)
{
  // Copy constructor

  trk.GetP(fMomentum);
  trk.GetPosition(fPosition);
  SetXYAtDCA(trk.XAtDCA(), trk.YAtDCA());
  SetPxPyPzAtDCA(trk.PxAtDCA(), trk.PyAtDCA(), trk.PzAtDCA());
  SetUsedForVtxFit(trk.GetUsedForVtxFit());
  SetUsedForPrimVtxFit(trk.GetUsedForPrimVtxFit());
  if(trk.fCovMatrix) fCovMatrix=new AliAODRedCov<6>(*trk.fCovMatrix);
  if(trk.fDetPid) fDetPid=new AliAODPid(*trk.fDetPid);
  SetPID(trk.fPID);
}

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

    AliVTrack::operator=(trk);

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

    SetXYAtDCA(trk.XAtDCA(), trk.YAtDCA());
    SetPxPyPzAtDCA(trk.PxAtDCA(), trk.PyAtDCA(), trk.PzAtDCA());
    
    fRAtAbsorberEnd = trk.fRAtAbsorberEnd;
    
    fChi2perNDF = trk.fChi2perNDF;
    fChi2MatchTrigger = trk.fChi2MatchTrigger;

    fFlags = trk.fFlags;
    fLabel = trk.fLabel;    
    
    fITSMuonClusterMap = trk.fITSMuonClusterMap;
    fFilterMap = trk.fFilterMap;

    fID = trk.fID;

    fCharge = trk.fCharge;
    fType = trk.fType;

    delete fCovMatrix;
    if(trk.fCovMatrix) fCovMatrix=new AliAODRedCov<6>(*trk.fCovMatrix);
    else fCovMatrix=NULL;
    fProdVertex = trk.fProdVertex;

    SetUsedForVtxFit(trk.GetUsedForVtxFit());
    SetUsedForPrimVtxFit(trk.GetUsedForPrimVtxFit());

    delete fDetPid;
    if(trk.fDetPid) fDetPid=new AliAODPid(*trk.fDetPid);
    else fDetPid=NULL;
  }

  return *this;
}

//______________________________________________________________________________
Double_t AliAODTrack::M(AODTrkPID_t pid) const
{
  // Returns the mass.
  // Masses for nuclei don't exist in the PDG tables, therefore they were put by hand.

  switch (pid) {

  case kElectron :
    return 0.000510999; //TDatabasePDG::Instance()->GetParticle(11/*::kElectron*/)->Mass();
    break;

  case kMuon :
    return 0.1056584; //TDatabasePDG::Instance()->GetParticle(13/*::kMuonMinus*/)->Mass();
    break;

  case kPion :
    return 0.13957; //TDatabasePDG::Instance()->GetParticle(211/*::kPiPlus*/)->Mass();
    break;

  case kKaon :
    return 0.4937; //TDatabasePDG::Instance()->GetParticle(321/*::kKPlus*/)->Mass();
    break;

  case kProton :
    return 0.9382720; //TDatabasePDG::Instance()->GetParticle(2212/*::kProton*/)->Mass();
    break;

  case kDeuteron :
    return 1.8756; //TDatabasePDG::Instance()->GetParticle(1000010020)->Mass();
    break;

  case kTriton :
    return 2.8089; //TDatabasePDG::Instance()->GetParticle(1000010030)->Mass();
    break;

  case kHelium3 :
    return 2.8084; //TDatabasePDG::Instance()->GetParticle(1000020030)->Mass();
    break;

  case kAlpha :
    return 3.7274; //TDatabasePDG::Instance()->GetParticle(1000020040)->Mass();
    break;

  case kUnknown :
    return -999.;
    break;

  default :
    return -999.;
  }
}

//______________________________________________________________________________
Double_t AliAODTrack::E(AODTrkPID_t pid) const
{
  // Returns the energy of the particle of a given pid.
  
  if (pid != kUnknown) { // particle was identified
    Double_t m = M(pid);
    return TMath::Sqrt(P()*P() + m*m);
  } else { // pid unknown
    return -999.;
  }
}

//______________________________________________________________________________
Double_t AliAODTrack::Y(AODTrkPID_t pid) const
{
  // Returns the rapidity of a particle of a given pid.
  
  if (pid != kUnknown) { // particle was identified
    Double_t e = E(pid);
    Double_t pz = Pz();
    if (e>=0 && e!=pz) { // energy was positive (e.g. not -999.) and not equal to pz
      return 0.5*TMath::Log((e+pz)/(e-pz));
    } else { // energy not known or equal to pz
      return -999.;
    }
  } else { // pid unknown
    return -999.;
  }
}

//______________________________________________________________________________
Double_t AliAODTrack::Y(Double_t m) const
{
  // Returns the rapidity of a particle of a given mass.
  
  if (m >= 0.) { // mass makes sense
    Double_t e = E(m);
    Double_t pz = Pz();
    if (e>=0 && e!=pz) { // energy was positive (e.g. not -999.) and not equal to pz
      return 0.5*TMath::Log((e+pz)/(e-pz));
    } else { // energy not known or equal to pz
      return -999.;
    }
  } else { // pid unknown
    return -999.;
  }
}

//______________________________________________________________________________
AliAODTrack::AODTrkPID_t AliAODTrack::GetMostProbablePID() const 
{
  // Returns the most probable PID array element.
  
  Int_t nPID = 10;
  AODTrkPID_t loc = kUnknown;
  Double_t max = 0.;
  Bool_t allTheSame = kTRUE;
  
  for (Int_t iPID = 0; iPID < nPID; iPID++) {
    if (fPID[iPID] >= max) {
      if (fPID[iPID] > max) {
	allTheSame = kFALSE;
	max = fPID[iPID];
	loc = (AODTrkPID_t)iPID;
      } else {
	allTheSame = kTRUE;
      }
    }
  }
  return allTheSame ? kUnknown : loc;
}

//______________________________________________________________________________
void AliAODTrack::ConvertAliPIDtoAODPID()
{
  // Converts AliPID array.
  // The numbering scheme is the same for electrons, muons, pions, kaons, and protons.
  // Everything else has to be set to zero.

  fPID[kDeuteron] = 0.;
  fPID[kTriton]   = 0.;
  fPID[kHelium3]  = 0.;
  fPID[kAlpha]    = 0.;
  fPID[kUnknown]  = 0.;
  
  return;
}


//______________________________________________________________________________
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 pp  = TMath::Sqrt(pt2 + p[2]*p[2]);
      
      fMomentum[0] = TMath::Sqrt(pt2); // pt
      fMomentum[1] = (pt2 != 0.) ? TMath::Pi()+TMath::ATan2(-p[1], -p[0]) : -999; // phi
      fMomentum[2] = (pp != 0.) ? TMath::ACos(p[2] / pp) : -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/NDF = %f\n", Chi2perNDF());
  printf("    charge = %d\n", Charge());
}

//______________________________________________________________________________
void AliAODTrack::SetMatchTrigger(Int_t matchTrig)
{
  // Set the MUON trigger information
  switch(matchTrig){
    case 0: // 0 track does not match trigger
      fITSMuonClusterMap=fITSMuonClusterMap&0x3fffffff;
      break;
    case 1: // 1 track match but does not pass pt cut
      fITSMuonClusterMap=(fITSMuonClusterMap&0x3fffffff)|0x40000000;
      break;
    case 2: // 2 track match Low pt cut
      fITSMuonClusterMap=(fITSMuonClusterMap&0x3fffffff)|0x80000000;
      break;
    case 3: // 3 track match High pt cut
      fITSMuonClusterMap=fITSMuonClusterMap|0xc0000000;
      break;
    default:
      fITSMuonClusterMap=fITSMuonClusterMap&0x3fffffff;
      AliWarning(Form("unknown case for matchTrig: %d\n",matchTrig));
  }
}

//______________________________________________________________________________
Bool_t AliAODTrack::HitsMuonChamber(Int_t MuonChamber, Int_t cathode) const
{
  // return kTRUE if the track fires the given tracking or trigger chamber.
  // If the chamber is a trigger one:
  // - if cathode = 0 or 1, the track matches the corresponding cathode
  // - if cathode = -1, the track matches both cathodes
  
  if (MuonChamber < 0) return kFALSE;
  
  if (MuonChamber < 10) return TESTBIT(GetMUONClusterMap(), MuonChamber);
  
  if (MuonChamber < 14) {
    
    if (cathode < 0) return TESTBIT(GetHitsPatternInTrigCh(), 13-MuonChamber) &&
                            TESTBIT(GetHitsPatternInTrigCh(), 13-MuonChamber+4);
    
    if (cathode < 2) return TESTBIT(GetHitsPatternInTrigCh(), 13-MuonChamber+(1-cathode)*4);
    
  }
  
  return kFALSE;
}

//______________________________________________________________________________
Bool_t AliAODTrack::MatchTriggerDigits() const
{
  // return kTRUE if the track matches a digit on both planes of at least 2 trigger chambers
  
  Int_t nMatchedChambers = 0;
  for (Int_t ich=10; ich<14; ich++) if (HitsMuonChamber(ich)) nMatchedChambers++;
  
  return (nMatchedChambers >= 2);
}

//______________________________________________________________________________
Bool_t AliAODTrack::PropagateToDCA(const AliVVertex *vtx, 
    Double_t b, Double_t maxd, Double_t dz[2], Double_t covar[3])
{
  // compute impact parameters to the vertex vtx and their covariance matrix
  // b is the Bz, needed to propagate correctly the track to vertex 
  // only the track parameters are update after the propagation (pos and mom),
  // not the covariance matrix. This is OK for propagation over short distance
  // inside the beam pipe.
  // return kFALSE is something went wrong

  // convert to AliExternalTrackParam
  AliExternalTrackParam etp(this);  

  Float_t xstart = etp.GetX();
  if(xstart>3.) {
    AliError("This method can be used only for propagation inside the beam pipe");
    return kFALSE; 
  }

  if(!etp.PropagateToDCA(vtx,b,maxd,dz,covar)) return kFALSE;

  // update track position and momentum
  Double_t mom[3];
  etp.GetPxPyPz(mom);
  SetP(mom,kTRUE);
  etp.GetXYZ(mom);
  SetPosition(mom,kFALSE);


  return kTRUE;
}

//______________________________________________________________________________
Bool_t AliAODTrack::GetPxPyPz(Double_t p[3]) const 
{
    //---------------------------------------------------------------------
    // This function returns the global track momentum components
    //---------------------------------------------------------------------
  p[0]=Px(); p[1]=Py(); p[2]=Pz();
  return kTRUE;
}
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	//-------------------------------------------------------------------------
4f6e22bd	19	// AOD track implementation of AliVTrack
df9db588	20	// Author: Markus Oldenburg, CERN
0c5f89fb	21	// Markus.Oldenburg@cern.ch
df9db588	22	//-------------------------------------------------------------------------
df9db588	23
8ac4fa64	24	#include "AliLog.h"
6dc40b1c	25	#include "AliExternalTrackParam.h"
6dc40b1c	26	#include "AliVVertex.h"
df9db588	27	#include "AliAODTrack.h"
	28
	29	ClassImp(AliAODTrack)
	30
	31	//______________________________________________________________________________
	32	AliAODTrack::AliAODTrack() :
4f6e22bd	33	AliVTrack(),
f43586f0	34	fRAtAbsorberEnd(0.),
1912763f	35	fChi2perNDF(-999.),
9333290e	36	fChi2MatchTrigger(0.),
6efb741f	37	fFlags(0),
df9db588	38	fLabel(-999),
1912763f	39	fITSMuonClusterMap(0),
9333290e	40	fFilterMap(0),
d999f2e6	41	fTPCClusterMap(),
d999f2e6	42	fTPCSharedMap(),
02153d58	43	fID(-999),
9333290e	44	fCharge(-99),
e1c744ca	45	fType(kUndef),
9333290e	46	fCovMatrix(NULL),
7be1db84	47	fDetPid(NULL),
7be1db84	48	fProdVertex(NULL)
df9db588	49	{
	50	// default constructor
	51
	52	SetP();
	53	SetPosition((Float_t*)NULL);
6c954176	54	SetXYAtDCA(-999., -999.);
6c954176	55	SetPxPyPzAtDCA(-999., -999., -999.);
df9db588	56	SetPID((Float_t*)NULL);
	57	}
	58
	59	//______________________________________________________________________________
02153d58	60	AliAODTrack::AliAODTrack(Short_t id,
df9db588	61	Int_t label,
	62	Double_t p[3],
	63	Bool_t cartesian,
	64	Double_t x[3],
	65	Bool_t isDCA,
	66	Double_t covMatrix[21],
	67	Short_t charge,
	68	UChar_t itsClusMap,
	69	Double_t pid[10],
	70	AliAODVertex *prodVertex,
1912763f	71	Bool_t usedForVtxFit,
dc825b15	72	Bool_t usedForPrimVtxFit,
ec40c484	73	AODTrk_t ttype,
862ce351	74	UInt_t selectInfo,
862ce351	75	Float_t chi2perNDF) :
4f6e22bd	76	AliVTrack(),
f43586f0	77	fRAtAbsorberEnd(0.),
862ce351	78	fChi2perNDF(chi2perNDF),
9333290e	79	fChi2MatchTrigger(0.),
6efb741f	80	fFlags(0),
df9db588	81	fLabel(label),
6c954176	82	fITSMuonClusterMap(0),
9333290e	83	fFilterMap(selectInfo),
d999f2e6	84	fTPCClusterMap(),
d999f2e6	85	fTPCSharedMap(),
02153d58	86	fID(id),
9333290e	87	fCharge(charge),
e1c744ca	88	fType(ttype),
9333290e	89	fCovMatrix(NULL),
7be1db84	90	fDetPid(NULL),
9333290e	91	fProdVertex(prodVertex)
df9db588	92	{
	93	// constructor
	94
	95	SetP(p, cartesian);
	96	SetPosition(x, isDCA);
6c954176	97	SetXYAtDCA(-999., -999.);
6c954176	98	SetPxPyPzAtDCA(-999., -999., -999.);
1912763f	99	SetUsedForVtxFit(usedForVtxFit);
dc825b15	100	SetUsedForPrimVtxFit(usedForPrimVtxFit);
df9db588	101	if(covMatrix) SetCovMatrix(covMatrix);
df9db588	102	SetPID(pid);
6c954176	103	SetITSClusterMap(itsClusMap);
df9db588	104	}
	105
	106	//______________________________________________________________________________
02153d58	107	AliAODTrack::AliAODTrack(Short_t id,
df9db588	108	Int_t label,
	109	Float_t p[3],
	110	Bool_t cartesian,
	111	Float_t x[3],
	112	Bool_t isDCA,
	113	Float_t covMatrix[21],
	114	Short_t charge,
	115	UChar_t itsClusMap,
	116	Float_t pid[10],
	117	AliAODVertex *prodVertex,
1912763f	118	Bool_t usedForVtxFit,
dc825b15	119	Bool_t usedForPrimVtxFit,
ec40c484	120	AODTrk_t ttype,
862ce351	121	UInt_t selectInfo,
862ce351	122	Float_t chi2perNDF) :
4f6e22bd	123	AliVTrack(),
f43586f0	124	fRAtAbsorberEnd(0.),
862ce351	125	fChi2perNDF(chi2perNDF),
9333290e	126	fChi2MatchTrigger(0.),
6efb741f	127	fFlags(0),
df9db588	128	fLabel(label),
6c954176	129	fITSMuonClusterMap(0),
9333290e	130	fFilterMap(selectInfo),
d999f2e6	131	fTPCClusterMap(),
d999f2e6	132	fTPCSharedMap(),
02153d58	133	fID(id),
9333290e	134	fCharge(charge),
e1c744ca	135	fType(ttype),
9333290e	136	fCovMatrix(NULL),
7be1db84	137	fDetPid(NULL),
9333290e	138	fProdVertex(prodVertex)
df9db588	139	{
	140	// constructor
	141
	142	SetP(p, cartesian);
	143	SetPosition(x, isDCA);
6c954176	144	SetXYAtDCA(-999., -999.);
6c954176	145	SetPxPyPzAtDCA(-999., -999., -999.);
1912763f	146	SetUsedForVtxFit(usedForVtxFit);
dc825b15	147	SetUsedForPrimVtxFit(usedForPrimVtxFit);
df9db588	148	if(covMatrix) SetCovMatrix(covMatrix);
df9db588	149	SetPID(pid);
6c954176	150	SetITSClusterMap(itsClusMap);
df9db588	151	}
df9db588	152
df9db588	153	//______________________________________________________________________________
	154	AliAODTrack::~AliAODTrack()
	155	{
	156	// destructor
	157	delete fCovMatrix;
7450f8ab	158	delete fDetPid;
df9db588	159	}
	160
	161
	162	//______________________________________________________________________________
	163	AliAODTrack::AliAODTrack(const AliAODTrack& trk) :
4f6e22bd	164	AliVTrack(trk),
f43586f0	165	fRAtAbsorberEnd(trk.fRAtAbsorberEnd),
1912763f	166	fChi2perNDF(trk.fChi2perNDF),
9333290e	167	fChi2MatchTrigger(trk.fChi2MatchTrigger),
6efb741f	168	fFlags(trk.fFlags),
df9db588	169	fLabel(trk.fLabel),
1912763f	170	fITSMuonClusterMap(trk.fITSMuonClusterMap),
9333290e	171	fFilterMap(trk.fFilterMap),
d999f2e6	172	fTPCClusterMap(trk.fTPCClusterMap),
d999f2e6	173	fTPCSharedMap(trk.fTPCSharedMap),
02153d58	174	fID(trk.fID),
9333290e	175	fCharge(trk.fCharge),
e1c744ca	176	fType(trk.fType),
9333290e	177	fCovMatrix(NULL),
7be1db84	178	fDetPid(NULL),
9333290e	179	fProdVertex(trk.fProdVertex)
df9db588	180	{
	181	// Copy constructor
	182
	183	trk.GetP(fMomentum);
	184	trk.GetPosition(fPosition);
6c954176	185	SetXYAtDCA(trk.XAtDCA(), trk.YAtDCA());
6c954176	186	SetPxPyPzAtDCA(trk.PxAtDCA(), trk.PyAtDCA(), trk.PzAtDCA());
1912763f	187	SetUsedForVtxFit(trk.GetUsedForVtxFit());
dc825b15	188	SetUsedForPrimVtxFit(trk.GetUsedForPrimVtxFit());
5d62ce04	189	if(trk.fCovMatrix) fCovMatrix=new AliAODRedCov<6>(*trk.fCovMatrix);
7be1db84	190	if(trk.fDetPid) fDetPid=new AliAODPid(*trk.fDetPid);
df9db588	191	SetPID(trk.fPID);
df9db588	192	}
	193
	194	//______________________________________________________________________________
	195	AliAODTrack& AliAODTrack::operator=(const AliAODTrack& trk)
	196	{
	197	// Assignment operator
	198	if(this!=&trk) {
	199
4f6e22bd	200	AliVTrack::operator=(trk);
df9db588	201
	202	trk.GetP(fMomentum);
	203	trk.GetPosition(fPosition);
	204	trk.GetPID(fPID);
	205
6c954176	206	SetXYAtDCA(trk.XAtDCA(), trk.YAtDCA());
	207	SetPxPyPzAtDCA(trk.PxAtDCA(), trk.PyAtDCA(), trk.PzAtDCA());
	208
f43586f0	209	fRAtAbsorberEnd = trk.fRAtAbsorberEnd;
f43586f0	210
1912763f	211	fChi2perNDF = trk.fChi2perNDF;
9333290e	212	fChi2MatchTrigger = trk.fChi2MatchTrigger;
df9db588	213
6efb741f	214	fFlags = trk.fFlags;
df9db588	215	fLabel = trk.fLabel;
df9db588	216
9333290e	217	fITSMuonClusterMap = trk.fITSMuonClusterMap;
	218	fFilterMap = trk.fFilterMap;
	219
6efb741f	220	fID = trk.fID;
6efb741f	221
9333290e	222	fCharge = trk.fCharge;
	223	fType = trk.fType;
	224
df9db588	225	delete fCovMatrix;
5d62ce04	226	if(trk.fCovMatrix) fCovMatrix=new AliAODRedCov<6>(*trk.fCovMatrix);
df9db588	227	else fCovMatrix=NULL;
	228	fProdVertex = trk.fProdVertex;
	229
1912763f	230	SetUsedForVtxFit(trk.GetUsedForVtxFit());
dc825b15	231	SetUsedForPrimVtxFit(trk.GetUsedForPrimVtxFit());
7be1db84	232
	233	delete fDetPid;
	234	if(trk.fDetPid) fDetPid=new AliAODPid(*trk.fDetPid);
	235	else fDetPid=NULL;
df9db588	236	}
	237
	238	return *this;
	239	}
	240
4697e4fb	241	//______________________________________________________________________________
	242	Double_t AliAODTrack::M(AODTrkPID_t pid) const
	243	{
	244	// Returns the mass.
9861edc0	245	// Masses for nuclei don't exist in the PDG tables, therefore they were put by hand.
4697e4fb	246
	247	switch (pid) {
	248
	249	case kElectron :
9861edc0	250	return 0.000510999; //TDatabasePDG::Instance()->GetParticle(11/::kElectron/)->Mass();
4697e4fb	251	break;
	252
	253	case kMuon :
9861edc0	254	return 0.1056584; //TDatabasePDG::Instance()->GetParticle(13/::kMuonMinus/)->Mass();
4697e4fb	255	break;
	256
	257	case kPion :
9861edc0	258	return 0.13957; //TDatabasePDG::Instance()->GetParticle(211/::kPiPlus/)->Mass();
4697e4fb	259	break;
	260
	261	case kKaon :
9861edc0	262	return 0.4937; //TDatabasePDG::Instance()->GetParticle(321/::kKPlus/)->Mass();
4697e4fb	263	break;
	264
	265	case kProton :
9861edc0	266	return 0.9382720; //TDatabasePDG::Instance()->GetParticle(2212/::kProton/)->Mass();
4697e4fb	267	break;
	268
	269	case kDeuteron :
9861edc0	270	return 1.8756; //TDatabasePDG::Instance()->GetParticle(1000010020)->Mass();
4697e4fb	271	break;
	272
	273	case kTriton :
9861edc0	274	return 2.8089; //TDatabasePDG::Instance()->GetParticle(1000010030)->Mass();
4697e4fb	275	break;
	276
	277	case kHelium3 :
9861edc0	278	return 2.8084; //TDatabasePDG::Instance()->GetParticle(1000020030)->Mass();
4697e4fb	279	break;
	280
	281	case kAlpha :
9861edc0	282	return 3.7274; //TDatabasePDG::Instance()->GetParticle(1000020040)->Mass();
4697e4fb	283	break;
	284
	285	case kUnknown :
	286	return -999.;
	287	break;
	288
	289	default :
	290	return -999.;
	291	}
	292	}
	293
	294	//______________________________________________________________________________
	295	Double_t AliAODTrack::E(AODTrkPID_t pid) const
	296	{
	297	// Returns the energy of the particle of a given pid.
	298
	299	if (pid != kUnknown) { // particle was identified
	300	Double_t m = M(pid);
	301	return TMath::Sqrt(P()P() + mm);
	302	} else { // pid unknown
	303	return -999.;
	304	}
	305	}
	306
	307	//______________________________________________________________________________
	308	Double_t AliAODTrack::Y(AODTrkPID_t pid) const
	309	{
9861edc0	310	// Returns the rapidity of a particle of a given pid.
4697e4fb	311
	312	if (pid != kUnknown) { // particle was identified
	313	Double_t e = E(pid);
	314	Double_t pz = Pz();
	315	if (e>=0 && e!=pz) { // energy was positive (e.g. not -999.) and not equal to pz
	316	return 0.5*TMath::Log((e+pz)/(e-pz));
	317	} else { // energy not known or equal to pz
	318	return -999.;
	319	}
	320	} else { // pid unknown
	321	return -999.;
	322	}
	323	}
	324
	325	//______________________________________________________________________________
	326	Double_t AliAODTrack::Y(Double_t m) const
	327	{
9861edc0	328	// Returns the rapidity of a particle of a given mass.
4697e4fb	329
	330	if (m >= 0.) { // mass makes sense
	331	Double_t e = E(m);
	332	Double_t pz = Pz();
	333	if (e>=0 && e!=pz) { // energy was positive (e.g. not -999.) and not equal to pz
	334	return 0.5*TMath::Log((e+pz)/(e-pz));
	335	} else { // energy not known or equal to pz
	336	return -999.;
	337	}
	338	} else { // pid unknown
	339	return -999.;
	340	}
	341	}
	342
	343	//______________________________________________________________________________
	344	AliAODTrack::AODTrkPID_t AliAODTrack::GetMostProbablePID() const
	345	{
	346	// Returns the most probable PID array element.
	347
	348	Int_t nPID = 10;
7ba6f91a	349	AODTrkPID_t loc = kUnknown;
	350	Double_t max = 0.;
	351	Bool_t allTheSame = kTRUE;
	352
	353	for (Int_t iPID = 0; iPID < nPID; iPID++) {
	354	if (fPID[iPID] >= max) {
	355	if (fPID[iPID] > max) {
	356	allTheSame = kFALSE;
	357	max = fPID[iPID];
	358	loc = (AODTrkPID_t)iPID;
	359	} else {
	360	allTheSame = kTRUE;
4697e4fb	361	}
4697e4fb	362	}
4697e4fb	363	}
7ba6f91a	364	return allTheSame ? kUnknown : loc;
4697e4fb	365	}
	366
	367	//______________________________________________________________________________
	368	void AliAODTrack::ConvertAliPIDtoAODPID()
	369	{
	370	// Converts AliPID array.
	371	// The numbering scheme is the same for electrons, muons, pions, kaons, and protons.
	372	// Everything else has to be set to zero.
	373
	374	fPID[kDeuteron] = 0.;
8a1418dc	375	fPID[kTriton] = 0.;
	376	fPID[kHelium3] = 0.;
	377	fPID[kAlpha] = 0.;
	378	fPID[kUnknown] = 0.;
4697e4fb	379
	380	return;
	381	}
	382
	383
df9db588	384	//______________________________________________________________________________
	385	template <class T> void AliAODTrack::SetP(const T *p, const Bool_t cartesian)
	386	{
8a1418dc	387	// Set the momentum
df9db588	388
	389	if (p) {
	390	if (cartesian) {
16b65f2a	391	Double_t pt2 = p[0]p[0] + p[1]p[1];
0c5f89fb	392	Double_t pp = TMath::Sqrt(pt2 + p[2]*p[2]);
df9db588	393
16b65f2a	394	fMomentum[0] = TMath::Sqrt(pt2); // pt
b1a9edc8	395	fMomentum[1] = (pt2 != 0.) ? TMath::Pi()+TMath::ATan2(-p[1], -p[0]) : -999; // phi
0c5f89fb	396	fMomentum[2] = (pp != 0.) ? TMath::ACos(p[2] / pp) : -999.; // theta
df9db588	397	} else {
16b65f2a	398	fMomentum[0] = p[0]; // pt
df9db588	399	fMomentum[1] = p[1]; // phi
	400	fMomentum[2] = p[2]; // theta
	401	}
	402	} else {
	403	fMomentum[0] = -999.;
	404	fMomentum[1] = -999.;
	405	fMomentum[2] = -999.;
	406	}
	407	}
	408
	409	//______________________________________________________________________________
	410	template <class T> void AliAODTrack::SetPosition(const T *x, const Bool_t dca)
	411	{
	412	// set the position
	413
	414	if (x) {
	415	if (!dca) {
	416	ResetBit(kIsDCA);
	417
	418	fPosition[0] = x[0];
	419	fPosition[1] = x[1];
	420	fPosition[2] = x[2];
	421	} else {
	422	SetBit(kIsDCA);
	423	// don't know any better yet
	424	fPosition[0] = -999.;
	425	fPosition[1] = -999.;
	426	fPosition[2] = -999.;
	427	}
	428	} else {
	429	ResetBit(kIsDCA);
	430
	431	fPosition[0] = -999.;
	432	fPosition[1] = -999.;
	433	fPosition[2] = -999.;
	434	}
	435	}
	436
	437	//______________________________________________________________________________
	438	void AliAODTrack::SetDCA(Double_t d, Double_t z)
	439	{
	440	// set the dca
	441	fPosition[0] = d;
	442	fPosition[1] = z;
	443	fPosition[2] = 0.;
	444	SetBit(kIsDCA);
	445	}
	446
	447	//______________________________________________________________________________
	448	void AliAODTrack::Print(Option_t* /* option */) const
	449	{
	450	// prints information about AliAODTrack
	451
	452	printf("Object name: %s Track type: %s\n", GetName(), GetTitle());
	453	printf(" px = %f\n", Px());
	454	printf(" py = %f\n", Py());
	455	printf(" pz = %f\n", Pz());
	456	printf(" pt = %f\n", Pt());
	457	printf(" 1/pt = %f\n", OneOverPt());
	458	printf(" theta = %f\n", Theta());
	459	printf(" phi = %f\n", Phi());
1912763f	460	printf(" chi2/NDF = %f\n", Chi2perNDF());
df9db588	461	printf(" charge = %d\n", Charge());
df9db588	462	}
df9db588	463
2200238e	464	//______________________________________________________________________________
	465	void AliAODTrack::SetMatchTrigger(Int_t matchTrig)
	466	{
	467	// Set the MUON trigger information
8ac4fa64	468	switch(matchTrig){
e1c744ca	469	case 0: // 0 track does not match trigger
	470	fITSMuonClusterMap=fITSMuonClusterMap&0x3fffffff;
	471	break;
	472	case 1: // 1 track match but does not pass pt cut
	473	fITSMuonClusterMap=(fITSMuonClusterMap&0x3fffffff)\|0x40000000;
	474	break;
	475	case 2: // 2 track match Low pt cut
	476	fITSMuonClusterMap=(fITSMuonClusterMap&0x3fffffff)\|0x80000000;
	477	break;
	478	case 3: // 3 track match High pt cut
	479	fITSMuonClusterMap=fITSMuonClusterMap\|0xc0000000;
	480	break;
	481	default:
	482	fITSMuonClusterMap=fITSMuonClusterMap&0x3fffffff;
8ac4fa64	483	AliWarning(Form("unknown case for matchTrig: %d\n",matchTrig));
e1c744ca	484	}
	485	}
	486
2200238e	487	//______________________________________________________________________________
	488	Bool_t AliAODTrack::HitsMuonChamber(Int_t MuonChamber, Int_t cathode) const
	489	{
	490	// return kTRUE if the track fires the given tracking or trigger chamber.
	491	// If the chamber is a trigger one:
	492	// - if cathode = 0 or 1, the track matches the corresponding cathode
	493	// - if cathode = -1, the track matches both cathodes
	494
	495	if (MuonChamber < 0) return kFALSE;
	496
	497	if (MuonChamber < 10) return TESTBIT(GetMUONClusterMap(), MuonChamber);
	498
	499	if (MuonChamber < 14) {
	500
	501	if (cathode < 0) return TESTBIT(GetHitsPatternInTrigCh(), 13-MuonChamber) &&
	502	TESTBIT(GetHitsPatternInTrigCh(), 13-MuonChamber+4);
	503
	504	if (cathode < 2) return TESTBIT(GetHitsPatternInTrigCh(), 13-MuonChamber+(1-cathode)*4);
	505
e1c744ca	506	}
2200238e	507
2200238e	508	return kFALSE;
e1c744ca	509	}
e1c744ca	510
2200238e	511	//______________________________________________________________________________
	512	Bool_t AliAODTrack::MatchTriggerDigits() const
	513	{
	514	// return kTRUE if the track matches a digit on both planes of at least 2 trigger chambers
6c954176	515
2200238e	516	Int_t nMatchedChambers = 0;
	517	for (Int_t ich=10; ich<14; ich++) if (HitsMuonChamber(ich)) nMatchedChambers++;
	518
	519	return (nMatchedChambers >= 2);
e1c744ca	520	}
c683ddc2	521
6dc40b1c	522	//______________________________________________________________________________
	523	Bool_t AliAODTrack::PropagateToDCA(const AliVVertex *vtx,
	524	Double_t b, Double_t maxd, Double_t dz[2], Double_t covar[3])
	525	{
	526	// compute impact parameters to the vertex vtx and their covariance matrix
	527	// b is the Bz, needed to propagate correctly the track to vertex
	528	// only the track parameters are update after the propagation (pos and mom),
	529	// not the covariance matrix. This is OK for propagation over short distance
	530	// inside the beam pipe.
	531	// return kFALSE is something went wrong
	532
	533	// convert to AliExternalTrackParam
	534	AliExternalTrackParam etp(this);
	535
	536	Float_t xstart = etp.GetX();
	537	if(xstart>3.) {
	538	AliError("This method can be used only for propagation inside the beam pipe");
	539	return kFALSE;
	540	}
	541
	542	if(!etp.PropagateToDCA(vtx,b,maxd,dz,covar)) return kFALSE;
	543
	544	// update track position and momentum
	545	Double_t mom[3];
	546	etp.GetPxPyPz(mom);
	547	SetP(mom,kTRUE);
	548	etp.GetXYZ(mom);
	549	SetPosition(mom,kFALSE);
	550
	551
	552	return kTRUE;
	553	}
	554
c8fe2783	555	//______________________________________________________________________________
	556	Bool_t AliAODTrack::GetPxPyPz(Double_t p[3]) const
	557	{
	558	//---------------------------------------------------------------------
	559	// This function returns the global track momentum components
	560	//---------------------------------------------------------------------
	561	p[0]=Px(); p[1]=Py(); p[2]=Pz();
	562	return kTRUE;
	563	}