// This is the class to deal with during the phisics analysis of data
// Origin: Iouri Belikov, CERN
// e-mail: Jouri.Belikov@cern.ch
+//
+//
+//
+// What do you need to know before starting analysis
+// (by Marian Ivanov: marian.ivanov@cern.ch)
+//
+//
+// AliESDtrack:
+// 1. What is the AliESDtrack
+// 2. What informations do we store
+// 3. How to use the information for analysis
+//
+//
+// 1.AliESDtrack is the container of the information about the track/particle
+// reconstructed during Barrel Tracking.
+// The track information is propagated from one tracking detector to
+// other using the functionality of AliESDtrack - Current parameters.
+//
+// No global fit model is used.
+// Barrel tracking use Kalman filtering technique, it gives optimal local
+// track parameters at given point under certian assumptions.
+//
+// Kalman filter take into account additional effect which are
+// difficult to handle using global fit.
+// Effects:
+// a.) Multiple scattering
+// b.) Energy loss
+// c.) Non homogenous magnetic field
+//
+// In general case, following barrel detectors are contributing to
+// the Kalman track information:
+// a. TPC
+// b. ITS
+// c. TRD
+//
+// In general 3 reconstruction itteration are performed:
+// 1. Find tracks - sequence TPC->ITS
+// 2. PropagateBack - sequence ITS->TPC->TRD -> Outer PID detectors
+// 3. Refit invward - sequence TRD->TPC->ITS
+// The current tracks are updated after each detector (see bellow).
+// In specical cases a track sanpshots are stored.
+//
+//
+// For some type of analysis (+visualization) track local parameters at
+// different position are neccesary. A snapshots during the track
+// propagation are created.
+// (See AliExternalTrackParam class for desctiption of variables and
+// functionality)
+// Snapshots:
+// a. Current parameters - class itself (AliExternalTrackParam)
+// Contributors: general case TRD->TPC->ITS
+// Preferable usage: Decission - primary or secondary track
+// NOTICE - By default the track parameters are stored at the DCA point
+// to the primary vertex. optimal for primary tracks,
+// far from optimal for secondary tracks.
+// b. Constrained parameters - Kalman information updated with
+// the Primary vertex information
+// Contributors: general case TRD->TPC->ITS
+// Preferable usage: Use only for tracks selected as primary
+// NOTICE - not real constrain - taken as additional measurement
+// with corresponding error
+// Function:
+// const AliExternalTrackParam *GetConstrainedParam() const {return fCp;}
+// c. Inner parameters - Track parameters at inner wall of the TPC
+// Contributors: general case TRD->TPC
+// function:
+// const AliExternalTrackParam *GetInnerParam() const { return fIp;}
+//
+// d. TPCinnerparam - contributors - TPC only
+// Contributors: TPC
+// Preferable usage: Requested for HBT study
+// (smaller correlations as using also ITS information)
+// NOTICE - the track parameters are propagated to the DCA to
+// to primary vertex
+// Optimal for primary, far from optimal for secondary tracks
+// Function:
+// const AliExternalTrackParam *GetTPCInnerParam() const {return fTPCInner;}
+//
+// e. Outer parameters -
+// Contributors- general case - ITS-> TPC -> TRD
+// The last point - Outer parameters radius is determined
+// e.a) Local inclination angle bigger than threshold -
+// Low momenta tracks
+// e.a) Catastrofic energy losss in material
+// e.b) Not further improvement (no space points)
+// Usage:
+// a.) Tracking: Starting parameter for Refit inward
+// b.) Visualization
+// c.) QA
+// NOTICE: Should be not used for the physic analysis
+// Function:
+// const AliExternalTrackParam *GetOuterParam() const { return fOp;}
+//
//-----------------------------------------------------------------
#include <TMath.h>
#include <TParticle.h>
+#include <TDatabasePDG.h>
#include "AliESDVertex.h"
#include "AliESDtrack.h"
+#include "AliESDEvent.h"
#include "AliKalmanTrack.h"
+#include "AliVTrack.h"
#include "AliLog.h"
#include "AliTrackPointArray.h"
#include "TPolyMarker3D.h"
fIp(0),
fTPCInner(0),
fOp(0),
+ fHMPIDp(0),
fFriendTrack(new AliESDfriendTrack()),
fTPCClusterMap(159),//number of padrows
fTPCSharedMap(159),//number of padrows
fITSLabel(0),
fTPCLabel(0),
fTRDLabel(0),
- fTOFCalChannel(0),
+ fTOFCalChannel(-1),
fTOFindex(-1),
fHMPIDqn(0),
- fHMPIDcluIdx(0),
- fEMCALindex(kEMCALNoMatch),
+ fHMPIDcluIdx(-1),
+ fCaloIndex(kEMCALNoMatch),
fHMPIDtrkTheta(0),
fHMPIDtrkPhi(0),
fHMPIDsignal(0),
fTrackLength(0),
fdTPC(0),fzTPC(0),
fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
+ fCchi2TPC(0),
fD(0),fZ(0),
fCdd(0),fCdz(0),fCzz(0),
fCchi2(0),
fITSchi2(0),
fTPCchi2(0),
+ fTPCchi2Iter1(0),
fTRDchi2(0),
fTOFchi2(0),
fHMPIDchi2(0),
+ fGlobalChi2(0),
fITSsignal(0),
fTPCsignal(0),
fTPCsignalS(0),
fTRDsignal(0),
fTRDQuality(0),
fTRDBudget(0),
- fTOFsignal(0),
- fTOFsignalToT(0),
- fTOFsignalRaw(0),
- fTOFsignalDz(0),
+ fTOFsignal(99999),
+ fTOFsignalToT(99999),
+ fTOFsignalRaw(99999),
+ fTOFsignalDz(999),
+ fTOFsignalDx(999),
+ fTOFdeltaBC(999),
+ fTOFl0l1(999),
+ fCaloDx(0),
+ fCaloDz(0),
fHMPIDtrkX(0),
fHMPIDtrkY(0),
fHMPIDmipX(0),
fTPCncls(0),
fTPCnclsF(0),
fTPCsignalN(0),
+ fTPCnclsIter1(0),
+ fTPCnclsFIter1(0),
fITSncls(0),
fITSClusterMap(0),
fTRDncls(0),
fTRDncls0(0),
- fTRDpidQuality(0),
+ fTRDntracklets(0),
fTRDnSlices(0),
- fTRDslices(0x0)
-
+ fTRDslices(0x0),
+ fVertexID(-2),// -2 means an orphan track
+ fESDEvent(0)
{
//
// The default ESD constructor
for (i=0;i<kTRDnPlanes;i++) {
fTRDTimBin[i]=0;
}
+ for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
for (i=0;i<4;i++) {fTPCPoints[i]=0;}
- for (i=0;i<3;i++) {fTOFLabel[i]=0;}
+ for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
for (i=0;i<10;i++) {fTOFInfo[i]=0;}
for (i=0;i<12;i++) {fITSModule[i]=-1;}
}
fIp(0),
fTPCInner(0),
fOp(0),
+ fHMPIDp(0),
fFriendTrack(0),
fTPCClusterMap(track.fTPCClusterMap),
fTPCSharedMap(track.fTPCSharedMap),
fTOFindex(track.fTOFindex),
fHMPIDqn(track.fHMPIDqn),
fHMPIDcluIdx(track.fHMPIDcluIdx),
- fEMCALindex(track.fEMCALindex),
+ fCaloIndex(track.fCaloIndex),
fHMPIDtrkTheta(track.fHMPIDtrkTheta),
fHMPIDtrkPhi(track.fHMPIDtrkPhi),
fHMPIDsignal(track.fHMPIDsignal),
fTrackLength(track.fTrackLength),
fdTPC(track.fdTPC),fzTPC(track.fzTPC),
fCddTPC(track.fCddTPC),fCdzTPC(track.fCdzTPC),fCzzTPC(track.fCzzTPC),
+ fCchi2TPC(track.fCchi2TPC),
fD(track.fD),fZ(track.fZ),
fCdd(track.fCdd),fCdz(track.fCdz),fCzz(track.fCzz),
fCchi2(track.fCchi2),
fITSchi2(track.fITSchi2),
fTPCchi2(track.fTPCchi2),
+ fTPCchi2Iter1(track.fTPCchi2Iter1),
fTRDchi2(track.fTRDchi2),
fTOFchi2(track.fTOFchi2),
fHMPIDchi2(track.fHMPIDchi2),
+ fGlobalChi2(track.fGlobalChi2),
fITSsignal(track.fITSsignal),
fTPCsignal(track.fTPCsignal),
fTPCsignalS(track.fTPCsignalS),
fTOFsignalToT(track.fTOFsignalToT),
fTOFsignalRaw(track.fTOFsignalRaw),
fTOFsignalDz(track.fTOFsignalDz),
+ fTOFsignalDx(track.fTOFsignalDx),
+ fTOFdeltaBC(track.fTOFdeltaBC),
+ fTOFl0l1(track.fTOFl0l1),
+ fCaloDx(track.fCaloDx),
+ fCaloDz(track.fCaloDz),
fHMPIDtrkX(track.fHMPIDtrkX),
fHMPIDtrkY(track.fHMPIDtrkY),
fHMPIDmipX(track.fHMPIDmipX),
fTPCncls(track.fTPCncls),
fTPCnclsF(track.fTPCnclsF),
fTPCsignalN(track.fTPCsignalN),
+ fTPCnclsIter1(track.fTPCnclsIter1),
+ fTPCnclsFIter1(track.fTPCnclsIter1),
fITSncls(track.fITSncls),
fITSClusterMap(track.fITSClusterMap),
fTRDncls(track.fTRDncls),
fTRDncls0(track.fTRDncls0),
- fTRDpidQuality(track.fTRDpidQuality),
+ fTRDntracklets(track.fTRDntracklets),
fTRDnSlices(track.fTRDnSlices),
- fTRDslices(0x0)
+ fTRDslices(0x0),
+ fVertexID(track.fVertexID),
+ fESDEvent(track.fESDEvent)
{
//
//copy constructor
for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=track.fITSr[i];
//
for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=track.fTPCr[i];
+ for (Int_t i=0;i<4;i++) {fITSdEdxSamples[i]=track.fITSdEdxSamples[i];}
for (Int_t i=0;i<4;i++) {fTPCPoints[i]=track.fTPCPoints[i];}
for (Int_t i=0; i<3;i++) { fKinkIndexes[i]=track.fKinkIndexes[i];}
for (Int_t i=0; i<3;i++) { fV0Indexes[i]=track.fV0Indexes[i];}
if (track.fIp) fIp=new AliExternalTrackParam(*track.fIp);
if (track.fTPCInner) fTPCInner=new AliExternalTrackParam(*track.fTPCInner);
if (track.fOp) fOp=new AliExternalTrackParam(*track.fOp);
-
+ if (track.fHMPIDp) fHMPIDp=new AliExternalTrackParam(*track.fHMPIDp);
+
if (track.fFriendTrack) fFriendTrack=new AliESDfriendTrack(*(track.fFriendTrack));
}
+//_______________________________________________________________________
+AliESDtrack::AliESDtrack(const AliVTrack *track) :
+ AliExternalTrackParam(track),
+ fCp(0),
+ fIp(0),
+ fTPCInner(0),
+ fOp(0),
+ fHMPIDp(0),
+ fFriendTrack(0),
+ fTPCClusterMap(159),//number of padrows
+ fTPCSharedMap(159),//number of padrows
+ fFlags(0),
+ fID(),
+ fLabel(0),
+ fITSLabel(0),
+ fTPCLabel(0),
+ fTRDLabel(0),
+ fTOFCalChannel(-1),
+ fTOFindex(-1),
+ fHMPIDqn(0),
+ fHMPIDcluIdx(-1),
+ fCaloIndex(kEMCALNoMatch),
+ fHMPIDtrkTheta(0),
+ fHMPIDtrkPhi(0),
+ fHMPIDsignal(0),
+ fTrackLength(0),
+ fdTPC(0),fzTPC(0),
+ fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
+ fCchi2TPC(0),
+ fD(0),fZ(0),
+ fCdd(0),fCdz(0),fCzz(0),
+ fCchi2(0),
+ fITSchi2(0),
+ fTPCchi2(0),
+ fTPCchi2Iter1(0),
+ fTRDchi2(0),
+ fTOFchi2(0),
+ fHMPIDchi2(0),
+ fGlobalChi2(0),
+ fITSsignal(0),
+ fTPCsignal(0),
+ fTPCsignalS(0),
+ fTRDsignal(0),
+ fTRDQuality(0),
+ fTRDBudget(0),
+ fTOFsignal(99999),
+ fTOFsignalToT(99999),
+ fTOFsignalRaw(99999),
+ fTOFsignalDz(999),
+ fTOFsignalDx(999),
+ fTOFdeltaBC(999),
+ fTOFl0l1(999),
+ fCaloDx(0),
+ fCaloDz(0),
+ fHMPIDtrkX(0),
+ fHMPIDtrkY(0),
+ fHMPIDmipX(0),
+ fHMPIDmipY(0),
+ fTPCncls(0),
+ fTPCnclsF(0),
+ fTPCsignalN(0),
+ fTPCnclsIter1(0),
+ fTPCnclsFIter1(0),
+ fITSncls(0),
+ fITSClusterMap(0),
+ fTRDncls(0),
+ fTRDncls0(0),
+ fTRDntracklets(0),
+ fTRDnSlices(0),
+ fTRDslices(0x0),
+ fVertexID(-2), // -2 means an orphan track
+ fESDEvent(0)
+{
+ //
+ // ESD track from AliVTrack.
+ // This is not a copy constructor !
+ //
+
+ if (track->InheritsFrom("AliExternalTrackParam")) {
+ AliError("This is not a copy constructor. Use AliESDtrack(const AliESDtrack &) !");
+ AliWarning("Calling the default constructor...");
+ AliESDtrack();
+ return;
+ }
+
+ // Reset all the arrays
+ Int_t i;
+ for (i=0; i<AliPID::kSPECIES; i++) {
+ fTrackTime[i]=0.;
+ fR[i]=0.;
+ fITSr[i]=0.;
+ fTPCr[i]=0.;
+ fTRDr[i]=0.;
+ fTOFr[i]=0.;
+ fHMPIDr[i]=0.;
+ }
+
+ for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
+ for (i=0; i<3; i++) { fV0Indexes[i]=-1;}
+ for (i=0;i<kTRDnPlanes;i++) {
+ fTRDTimBin[i]=0;
+ }
+ for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
+ for (i=0;i<4;i++) {fTPCPoints[i]=0;}
+ for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
+ for (i=0;i<10;i++) {fTOFInfo[i]=0;}
+ for (i=0;i<12;i++) {fITSModule[i]=-1;}
+
+ // Set the ID
+ SetID(track->GetID());
+
+ // Set ITS cluster map
+ fITSClusterMap=track->GetITSClusterMap();
+
+ fITSncls=0;
+ for(i=0; i<6; i++) {
+ if(HasPointOnITSLayer(i)) fITSncls++;
+ }
+
+ // Set TPC ncls
+ fTPCncls=track->GetTPCNcls();
+
+
+ // Set the combined PID
+ const Double_t *pid = track->PID();
+ if(pid){
+ for (i=0; i<AliPID::kSPECIES; i++) fR[i]=pid[i];
+ }
+ // AliESD track label
+ SetLabel(track->GetLabel());
+ // Set the status
+ SetStatus(track->GetStatus());
+}
+
//_______________________________________________________________________
AliESDtrack::AliESDtrack(TParticle * part) :
AliExternalTrackParam(),
fIp(0),
fTPCInner(0),
fOp(0),
+ fHMPIDp(0),
fFriendTrack(0),
fTPCClusterMap(159),//number of padrows
fTPCSharedMap(159),//number of padrows
fITSLabel(0),
fTPCLabel(0),
fTRDLabel(0),
- fTOFCalChannel(0),
+ fTOFCalChannel(-1),
fTOFindex(-1),
fHMPIDqn(0),
- fHMPIDcluIdx(0),
- fEMCALindex(kEMCALNoMatch),
+ fHMPIDcluIdx(-1),
+ fCaloIndex(kEMCALNoMatch),
fHMPIDtrkTheta(0),
fHMPIDtrkPhi(0),
fHMPIDsignal(0),
fTrackLength(0),
fdTPC(0),fzTPC(0),
fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
+ fCchi2TPC(0),
fD(0),fZ(0),
fCdd(0),fCdz(0),fCzz(0),
fCchi2(0),
fITSchi2(0),
fTPCchi2(0),
+ fTPCchi2Iter1(0),
fTRDchi2(0),
fTOFchi2(0),
fHMPIDchi2(0),
+ fGlobalChi2(0),
fITSsignal(0),
fTPCsignal(0),
fTPCsignalS(0),
fTRDsignal(0),
fTRDQuality(0),
fTRDBudget(0),
- fTOFsignal(0),
- fTOFsignalToT(0),
- fTOFsignalRaw(0),
- fTOFsignalDz(0),
+ fTOFsignal(99999),
+ fTOFsignalToT(99999),
+ fTOFsignalRaw(99999),
+ fTOFsignalDz(999),
+ fTOFsignalDx(999),
+ fTOFdeltaBC(999),
+ fTOFl0l1(999),
+ fCaloDx(0),
+ fCaloDz(0),
fHMPIDtrkX(0),
fHMPIDtrkY(0),
fHMPIDmipX(0),
fTPCncls(0),
fTPCnclsF(0),
fTPCsignalN(0),
+ fTPCnclsIter1(0),
+ fTPCnclsFIter1(0),
fITSncls(0),
fITSClusterMap(0),
fTRDncls(0),
fTRDncls0(0),
- fTRDpidQuality(0),
+ fTRDntracklets(0),
fTRDnSlices(0),
- fTRDslices(0x0)
+ fTRDslices(0x0),
+ fVertexID(-2), // -2 means an orphan track
+ fESDEvent(0)
{
//
// ESD track from TParticle
for (i=0;i<kTRDnPlanes;i++) {
fTRDTimBin[i]=0;
}
+ for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
for (i=0;i<4;i++) {fTPCPoints[i]=0;}
- for (i=0;i<3;i++) {fTOFLabel[i]=0;}
+ for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
for (i=0;i<10;i++) {fTOFInfo[i]=0;}
for (i=0;i<12;i++) {fITSModule[i]=-1;}
delete fIp;
delete fTPCInner;
delete fOp;
+ delete fHMPIDp;
delete fCp;
delete fFriendTrack;
if(fTRDnSlices)
fOp = 0;
}
+
+ if(source.fHMPIDp){
+ // we have the trackparam: assign or copy construct
+ if(fHMPIDp) *fHMPIDp = *source.fHMPIDp;
+ else fHMPIDp = new AliExternalTrackParam(*source.fHMPIDp);
+ }
+ else{
+ // no track param delete the old one
+ if(fHMPIDp)delete fHMPIDp;
+ fHMPIDp = 0;
+ }
+
+
// copy also the friend track
// use copy constructor
if(source.fFriendTrack){
fTOFindex = source.fTOFindex;
fHMPIDqn = source.fHMPIDqn;
fHMPIDcluIdx = source.fHMPIDcluIdx;
- fEMCALindex = source.fEMCALindex;
+ fCaloIndex = source.fCaloIndex;
for(int i = 0; i< 3;++i){
fKinkIndexes[i] = source.fKinkIndexes[i];
fCddTPC = source.fCddTPC;
fCdzTPC = source.fCdzTPC;
fCzzTPC = source.fCzzTPC;
+ fCchi2TPC = source.fCchi2TPC;
+
fD = source.fD;
fZ = source.fZ;
fCdd = source.fCdd;
fCdz = source.fCdz;
fCzz = source.fCzz;
-
fCchi2 = source.fCchi2;
+
fITSchi2 = source.fITSchi2;
fTPCchi2 = source.fTPCchi2;
+ fTPCchi2Iter1 = source.fTPCchi2Iter1;
fTRDchi2 = source.fTRDchi2;
fTOFchi2 = source.fTOFchi2;
fHMPIDchi2 = source.fHMPIDchi2;
+ fGlobalChi2 = source.fGlobalChi2;
fITSsignal = source.fITSsignal;
+ for (Int_t i=0;i<4;i++) {fITSdEdxSamples[i]=source.fITSdEdxSamples[i];}
fTPCsignal = source.fTPCsignal;
fTPCsignalS = source.fTPCsignalS;
for(int i = 0; i< 4;++i){
fTOFsignalToT = source.fTOFsignalToT;
fTOFsignalRaw = source.fTOFsignalRaw;
fTOFsignalDz = source.fTOFsignalDz;
-
+ fTOFsignalDx = source.fTOFsignalDx;
+ fTOFdeltaBC = source.fTOFdeltaBC;
+ fTOFl0l1 = source.fTOFl0l1;
+
for(int i = 0;i<10;++i){
fTOFInfo[i] = source.fTOFInfo[i];
}
fTPCncls = source.fTPCncls;
fTPCnclsF = source.fTPCnclsF;
fTPCsignalN = source.fTPCsignalN;
+ fTPCnclsIter1 = source.fTPCnclsIter1;
+ fTPCnclsFIter1 = source.fTPCnclsFIter1;
fITSncls = source.fITSncls;
fITSClusterMap = source.fITSClusterMap;
fTRDncls = source.fTRDncls;
fTRDncls0 = source.fTRDncls0;
- fTRDpidQuality = source.fTRDpidQuality;
+ fTRDntracklets = source.fTRDntracklets;
+ fVertexID = source.fVertexID;
return *this;
}
}
-const Bool_t AliESDtrack::FillTPCOnlyTrack(AliESDtrack &track){
+Bool_t AliESDtrack::FillTPCOnlyTrack(AliESDtrack &track){
// Fills the information of the TPC-only first reconstruction pass
// into the passed ESDtrack object. For consistency fTPCInner is also filled
// again
+
+
+ // For data produced before r26675
+ // RelateToVertexTPC was not properly called during reco
+ // so you'll have to call it again, before FillTPCOnlyTrack
+ // Float_t p[2],cov[3];
+ // track->GetImpactParametersTPC(p,cov);
+ // if(p[0]==0&&p[1]==0) // <- Default values
+ // track->RelateToVertexTPC(esd->GetPrimaryVertexTPC(),esd->GetMagneticField(),kVeryBig);
+
+
if(!fTPCInner)return kFALSE;
// fill the TPC track params to the global track parameters
track.fCddTPC = fCddTPC;
track.fCdzTPC = fCdzTPC;
track.fCzzTPC = fCzzTPC;
+ track.fCchi2TPC = fCchi2TPC;
// copy all other TPC specific parameters
track.fTPCLabel = fTPCLabel;
track.fTPCchi2 = fTPCchi2;
+ track.fTPCchi2Iter1 = fTPCchi2Iter1;
track.fTPCsignal = fTPCsignal;
track.fTPCsignalS = fTPCsignalS;
for(int i = 0;i<4;++i)track.fTPCPoints[i] = fTPCPoints[i];
track.fTPCncls = fTPCncls;
track.fTPCnclsF = fTPCnclsF;
track.fTPCsignalN = fTPCsignalN;
+ track.fTPCnclsIter1 = fTPCnclsIter1;
+ track.fTPCnclsFIter1 = fTPCnclsFIter1;
// PID
for(int i=0;i<AliPID::kSPECIES;++i){
track.fFlags = kTPCin;
track.fID = fID;
+ track.fFlags |= fFlags & kTPCpid; //copy the TPCpid status flag
for (Int_t i=0;i<3;i++) track.fKinkIndexes[i] = fKinkIndexes[i];
// Reset track parameters constrained to the primary vertex
delete fCp;fCp = 0;
- fCchi2 = 0;
// Reset track parameters at the inner wall of TPC
delete fIp;fIp = 0;
delete fTPCInner;fTPCInner=0;
// Reset track parameters at the inner wall of the TRD
delete fOp;fOp = 0;
+ // Reset track parameters at the HMPID
+ delete fHMPIDp;fHMPIDp = 0;
// Reset ITS track related information
fITSncls = 0;
fITSClusterMap=0;
fITSsignal = 0;
+ for (Int_t i=0;i<4;i++) fITSdEdxSamples[i] = 0.;
for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=0;
fITSLabel = 0;
// Reset TPC related track information
fTPCchi2 = 0;
+ fTPCchi2Iter1 = 0;
fTPCncls = 0;
fTPCnclsF = 0;
+ fTPCnclsIter1 = 0;
+ fTPCnclsFIter1 = 0;
fTPCClusterMap = 0;
fTPCSharedMap = 0;
fTPCsignal= 0;
for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i] = 0;
fTRDLabel = 0;
fTRDQuality = 0;
- fTRDpidQuality = 0;
+ fTRDntracklets = 0;
if(fTRDnSlices)
delete[] fTRDslices;
fTRDslices=0x0;
// Reset TOF related track information
fTOFchi2 = 0;
fTOFindex = -1;
- fTOFsignal = 0;
- fTOFCalChannel = 0;
- fTOFsignalToT = 0;
- fTOFsignalRaw = 0;
- fTOFsignalDz = 0;
+ fTOFsignal = 99999;
+ fTOFCalChannel = -1;
+ fTOFsignalToT = 99999;
+ fTOFsignalRaw = 99999;
+ fTOFsignalDz = 999;
+ fTOFsignalDx = 999;
+ fTOFdeltaBC = 999;
+ fTOFl0l1 = 999;
for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i] = 0;
- for (Int_t i=0;i<3;i++) fTOFLabel[i] = 0;
+ for (Int_t i=0;i<3;i++) fTOFLabel[i] = -1;
for (Int_t i=0;i<10;i++) fTOFInfo[i] = 0;
// Reset HMPID related track information
fHMPIDchi2 = 0;
fHMPIDqn = 0;
- fHMPIDcluIdx = 0;
+ fHMPIDcluIdx = -1;
fHMPIDsignal = 0;
for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i] = 0;
fHMPIDtrkTheta = 0;
fHMPIDtrkY = 0;
fHMPIDmipX = 0;
fHMPIDmipY = 0;
- fEMCALindex = kEMCALNoMatch;
+ fCaloIndex = kEMCALNoMatch;
+
+ // reset global track chi2
+ fGlobalChi2 = 0;
+
+ fVertexID = -2; // an orphan track
delete fFriendTrack; fFriendTrack = 0;
}
//_______________________________________________________________________
Double_t AliESDtrack::GetMass() const {
// Returns the mass of the most probable particle type
+
+ Int_t i;
+ for (i=0; i<AliPID::kSPECIES-1; i++) {
+ if (fR[i] != fR[i+1]) break;
+ }
+ // If all the probabilities are equal, return the pion mass
+ if (i == AliPID::kSPECIES-1) return AliPID::ParticleMass(AliPID::kPion);
+
Float_t max=0.;
Int_t k=-1;
- for (
Int_t i=0; i<AliPID::kSPECIES; i++) {
+ for (i=0; i<AliPID::kSPECIES; i++) {
if (fR[i]>max) {k=i; max=fR[i];}
}
if (k==0) { // dE/dx "crossing points" in the TPC
return AliPID::ParticleMass(AliPID::kPion);
}
+//______________________________________________________________________________
+Double_t AliESDtrack::M() const
+{
+ // Returns the assumed mass
+ // (the pion mass, if the particle can't be identified properly).
+
+ AliWarning("This is the ESD mass. Use it with care !");
+ return GetMass();
+}
+
//______________________________________________________________________________
Double_t AliESDtrack::E() const
{
//
// This function updates track's running parameters
//
- Int_t *index=0;
Bool_t rc=kTRUE;
SetStatus(flags);
}
Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
+ if (flags==kITSout) fFriendTrack->SetITSOut(*t);
+ if (flags==kTPCout) fFriendTrack->SetTPCOut(*t);
+ if (flags==kTRDrefit) fFriendTrack->SetTRDIn(*t);
switch (flags) {
case kITSin: case kITSout: case kITSrefit:
+ {
fITSClusterMap=0;
fITSncls=t->GetNumberOfClusters();
- index=fFriendTrack->GetITSindices();
+ Int_t* indexITS = new Int_t[AliESDfriendTrack::kMaxITScluster];
for (Int_t i=0;i<AliESDfriendTrack::kMaxITScluster;i++) {
- index[i]=t->GetClusterIndex(i);
+ indexITS[i]=t->GetClusterIndex(i);
+
if (i<fITSncls) {
- Int_t l=(index[i] & 0xf0000000) >> 28;
+ Int_t l=(indexITS[i] & 0xf0000000) >> 28;
SETBIT(fITSClusterMap,l);
}
}
+ fFriendTrack->SetITSIndices(indexITS,AliESDfriendTrack::kMaxITScluster);
+ delete [] indexITS;
+
fITSchi2=t->GetChi2();
fITSsignal=t->GetPIDsignal();
fITSLabel = t->GetLabel();
+ // keep in fOp the parameters outside ITS for ITS stand-alone tracks
+ if (flags==kITSout) {
+ if (!fOp) fOp=new AliExternalTrackParam(*t);
+ else
+ fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
+ }
+ }
break;
case kTPCin: case kTPCrefit:
+ {
fTPCLabel = t->GetLabel();
- if (flags==kTPCin) fTPCInner=new AliExternalTrackParam(*t);
+ if (flags==kTPCin) {
+ fTPCInner=new AliExternalTrackParam(*t);
+ fTPCnclsIter1=t->GetNumberOfClusters();
+ fTPCchi2Iter1=t->GetChi2();
+ }
if (!fIp) fIp=new AliExternalTrackParam(*t);
else
fIp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
+ }
case kTPCout:
- index=fFriendTrack->GetTPCindices();
+ {
+ Int_t* indexTPC = new Int_t[AliESDfriendTrack::kMaxTPCcluster];
if (flags & kTPCout){
if (!fOp) fOp=new AliExternalTrackParam(*t);
else
// for (Int_t i=0;i<fTPCncls;i++)
for (Int_t i=0;i<AliESDfriendTrack::kMaxTPCcluster;i++)
{
- index[i]=t->GetClusterIndex(i);
- Int_t idx = index[i];
+ indexTPC[i]=t->GetClusterIndex(i);
+ Int_t idx = indexTPC[i];
if (idx<0) continue;
}
// End Of Piotr's Cluster Map for HBT
}
+ fFriendTrack->SetTPCIndices(indexTPC,AliESDfriendTrack::kMaxTPCcluster);
+ delete [] indexTPC;
+
}
fTPCsignal=t->GetPIDsignal();
+ }
break;
- case kTRDout: case kTRDin: case kTRDrefit:
- index = fFriendTrack->GetTRDindices();
+ case kTRDin: case kTRDrefit:
+ break;
+ case kTRDout:
+ {
fTRDLabel = t->GetLabel();
fTRDchi2 = t->GetChi2();
fTRDncls = t->GetNumberOfClusters();
- for (Int_t i=0;i<6;i++) index[i]=t->GetTrackletIndex(i);
+ Int_t* indexTRD = new Int_t[AliESDfriendTrack::kMaxTRDcluster];
+ for (Int_t i=0;i<AliESDfriendTrack::kMaxTRDcluster;i++) indexTRD[i]=-2;
+ for (Int_t i=0;i<6;i++) indexTRD[i]=t->GetTrackletIndex(i);
+ fFriendTrack->SetTRDIndices(indexTRD,AliESDfriendTrack::kMaxTRDcluster);
+ delete [] indexTRD;
+
fTRDsignal=t->GetPIDsignal();
+ }
break;
case kTRDbackup:
if (!fOp) fOp=new AliExternalTrackParam(*t);
break;
case kTRDStop:
break;
+ case kHMPIDout:
+ if (!fHMPIDp) fHMPIDp=new AliExternalTrackParam(*t);
+ else
+ fHMPIDp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
+ break;
default:
AliError("Wrong flag !");
return kFALSE;
return kTRUE;
}
+void
+AliESDtrack::SetOuterParam(const AliExternalTrackParam *p, ULong_t flags) {
+ //
+ // This is a direct setter for the outer track parameters
+ //
+ SetStatus(flags);
+ if (fOp) delete fOp;
+ fOp=new AliExternalTrackParam(*p);
+}
+
+void
+AliESDtrack::SetOuterHmpParam(const AliExternalTrackParam *p, ULong_t flags) {
+ //
+ // This is a direct setter for the outer track parameters
+ //
+ SetStatus(flags);
+ if (fHMPIDp) delete fHMPIDp;
+ fHMPIDp=new AliExternalTrackParam(*p);
+}
+
Bool_t
AliESDtrack::GetOuterExternalParameters
(Double_t &alpha, Double_t &x, Double_t p[5]) const {
return kTRUE;
}
+Bool_t
+AliESDtrack::GetOuterHmpExternalParameters
+ (Double_t &alpha, Double_t &x, Double_t p[5]) const {
+ //---------------------------------------------------------------------
+ // This function returns external representation of the track parameters
+ // at the inner layer of TRD
+ //---------------------------------------------------------------------
+ if (!fHMPIDp) return kFALSE;
+ alpha=fHMPIDp->GetAlpha();
+ x=fHMPIDp->GetX();
+ for (Int_t i=0; i<5; i++) p[i]=fHMPIDp->GetParameter()[i];
+ return kTRUE;
+}
+
Bool_t
AliESDtrack::GetOuterExternalCovariance(Double_t cov[15]) const {
//---------------------------------------------------------------------
return kTRUE;
}
+Bool_t
+AliESDtrack::GetOuterHmpExternalCovariance(Double_t cov[15]) const {
+ //---------------------------------------------------------------------
+ // This function returns external representation of the cov. matrix
+ // at the inner layer of TRD
+ //---------------------------------------------------------------------
+ if (!fHMPIDp) return kFALSE;
+ for (Int_t i=0; i<15; i++) cov[i]=fHMPIDp->GetCovariance()[i];
+ return kTRUE;
+}
+
Int_t AliESDtrack::GetNcls(Int_t idet) const
{
// Get number of clusters by subdetector index
if (fTOFindex != -1)
ncls = 1;
break;
+ case 4: //PHOS
+ break;
+ case 5: //HMPID
+ if ((fHMPIDcluIdx >= 0) && (fHMPIDcluIdx < 7000000)) {
+ if ((fHMPIDcluIdx%1000000 != 9999) && (fHMPIDcluIdx%1000000 != 99999)) {
+ ncls = 1;
+ }
+ }
+ break;
default:
break;
}
case 4: //PHOS
break;
case 5:
- if (fHMPIDcluIdx != 0) {
- idx[0] = GetHMPIDcluIdx();
- ncls = 1;
+ if ((fHMPIDcluIdx >= 0) && (fHMPIDcluIdx < 7000000)) {
+ if ((fHMPIDcluIdx%1000000 != 9999) && (fHMPIDcluIdx%1000000 != 99999)) {
+ idx[0] = GetHMPIDcluIdx();
+ ncls = 1;
+ }
}
break;
case 6: //EMCAL
//---------------------------------------------------------------------
// This function returns indices of the assgined ITS clusters
//---------------------------------------------------------------------
- if (idx!=0) {
- Int_t *index=fFriendTrack->GetITSindices();
- for (Int_t i=0; i<AliESDfriendTrack::kMaxITScluster; i++) idx[i]=index[i];
+ if (idx) {
+ Int_t *index=fFriendTrack->GetITSindices();
+ for (Int_t i=0; i<AliESDfriendTrack::kMaxITScluster; i++) {
+ if ( (i>=fITSncls) && (i<6) ) idx[i]=-1;
+ else {
+ if (index) {
+ idx[i]=index[i];
+ }
+ else idx[i]= -2;
+ }
+ }
}
return fITSncls;
}
//----------------------------------------------------------------------
if(fITSModule[ilayer]==-1) {
- AliError("fModule was not set !");
idet = -1;
status=0;
xloc=-99.; zloc=-99.;
//---------------------------------------------------------------------
// This function returns indices of the assgined ITS clusters
//---------------------------------------------------------------------
- if (idx!=0) {
+ if (idx) {
Int_t *index=fFriendTrack->GetTPCindices();
- for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=index[i];
+
+ if (index){
+ for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=index[i];
+ }
+ else {
+ for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=-2;
+ }
}
return fTPCncls;
}
//---------------------------------------------------------------------
// This function returns indices of the assgined TRD clusters
//---------------------------------------------------------------------
- if (idx!=0) {
- Int_t *index=fFriendTrack->GetTRDindices();
- for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=index[i];
+ if (idx) {
+ Int_t *index=fFriendTrack->GetTRDindices();
+
+ if (index) {
+ for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=index[i];
+ }
+ else {
+ for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=-2;
+ }
}
return fTRDncls;
}
//_______________________________________________________________________
UChar_t AliESDtrack::GetTRDtracklets(Int_t *idx) const {
- //---------------------------------------------------------------------
- // This function returns indices of the assigned TRD tracklets
- //---------------------------------------------------------------------
- if (idx!=0) {
- Int_t *index=fFriendTrack->GetTRDindices();
- for (Int_t i=0; i<6/*AliESDfriendTrack::kMaxTRDcluster*/; i++) idx[i]=index[i];
+//
+// This function returns the number of TRD tracklets used in tracking
+// and it fills the indices of these tracklets in the array "idx" as they
+// are registered in the TRD track list.
+//
+// Caution :
+// 1. The idx array has to be allocated with a size >= AliESDtrack::kTRDnPlanes
+// 2. The idx array store not only the index but also the layer of the tracklet.
+// Therefore tracks with TRD gaps contain default values for indices [-1]
+
+ if (!idx) return GetTRDntracklets();
+ Int_t *index=fFriendTrack->GetTRDindices();
+ Int_t n = 0;
+ for (Int_t i=0; i<kTRDnPlanes; i++){
+ if (index){
+ if(index[i]>=0) n++;
+ idx[i]=index[i];
+ }
+ else idx[i] = -2;
}
- return fTRDncls;
+ return n;
}
//_______________________________________________________________________
return fTRDr[iSpecies];
}
+//____________________________________________________
+Int_t AliESDtrack::GetNumberOfTRDslices() const
+{
+ // built in backward compatibility
+ Int_t idx = fTRDnSlices - (kTRDnPlanes<<1);
+ return idx<18 ? fTRDnSlices/kTRDnPlanes : idx/kTRDnPlanes;
+}
+
+//____________________________________________________
+Double_t AliESDtrack::GetTRDmomentum(Int_t plane, Double_t *sp) const
+{
+//Returns momentum estimation and optional its error (sp)
+// in TRD layer "plane".
+
+ if (!fTRDnSlices) {
+ AliDebug(2, "No TRD info allocated for this track.");
+ return -1.;
+ }
+ if ((plane<0) || (plane>=kTRDnPlanes)) {
+ AliWarning(Form("Request for TRD plane[%d] outside range.", plane));
+ return -1.;
+ }
+
+ Int_t idx = fTRDnSlices-(kTRDnPlanes<<1)+plane;
+ // Protection for backward compatibility
+ if(idx<(GetNumberOfTRDslices()*kTRDnPlanes)) return -1.;
+
+ if(sp) (*sp) = fTRDslices[idx+kTRDnPlanes];
+ return fTRDslices[idx];
+}
+
+//____________________________________________________
+Double_t AliESDtrack::GetTRDslice(Int_t plane, Int_t slice) const {
+ //Gets the charge from the slice of the plane
+
+ if(!fTRDslices) {
+ //AliError("No TRD slices allocated for this track !");
+ return -1.;
+ }
+ if ((plane<0) || (plane>=kTRDnPlanes)) {
+ AliError("Info for TRD plane not available !");
+ return -1.;
+ }
+ Int_t ns=GetNumberOfTRDslices();
+ if ((slice<-1) || (slice>=ns)) {
+ //AliError("Wrong TRD slice !");
+ return -1.;
+ }
+
+ if(slice>=0) return fTRDslices[plane*ns + slice];
+
+ // return average of the dEdx measurements
+ Double_t q=0.; Double32_t *s = &fTRDslices[plane*ns];
+ for (Int_t i=0; i<ns; i++, s++) if((*s)>0.) q+=(*s);
+ return q/ns;
+}
+
+//____________________________________________________
void AliESDtrack::SetNumberOfTRDslices(Int_t n) {
//Sets the number of slices used for PID
- if (fTRDnSlices != 0) return;
- fTRDnSlices=kTRDnPlanes*n;
+ if (fTRDnSlices) return;
+
+ fTRDnSlices=n;
fTRDslices=new Double32_t[fTRDnSlices];
- for (Int_t i=0; i<fTRDnSlices; i++) fTRDslices[i]=-1.;
+
+ // set-up correctly the allocated memory
+ memset(fTRDslices, 0, n*sizeof(Double32_t));
+ for (Int_t i=GetNumberOfTRDslices(); i--;) fTRDslices[i]=-1.;
}
+//____________________________________________________
void AliESDtrack::SetTRDslice(Double_t q, Int_t plane, Int_t slice) {
//Sets the charge q in the slice of the plane
- Int_t ns=GetNumberOfTRDslices();
- if (ns==0) {
+ if(!fTRDslices) {
AliError("No TRD slices allocated for this track !");
return;
}
-
if ((plane<0) || (plane>=kTRDnPlanes)) {
- AliError("Wrong TRD plane !");
+ AliError("Info for TRD plane not allocated !");
return;
}
+ Int_t ns=GetNumberOfTRDslices();
if ((slice<0) || (slice>=ns)) {
AliError("Wrong TRD slice !");
return;
fTRDslices[n]=q;
}
-Double_t AliESDtrack::GetTRDslice(Int_t plane, Int_t slice) const {
- //Gets the charge from the slice of the plane
- Int_t ns=GetNumberOfTRDslices();
- if (ns==0) {
- //AliError("No TRD slices allocated for this track !");
- return -1.;
- }
- if ((plane<0) || (plane>=kTRDnPlanes)) {
- AliError("Wrong TRD plane !");
- return -1.;
+//____________________________________________________
+void AliESDtrack::SetTRDmomentum(Double_t p, Int_t plane, Double_t *sp)
+{
+ if(!fTRDslices) {
+ AliError("No TRD slices allocated for this track !");
+ return;
}
- if ((slice<-1) || (slice>=ns)) {
- //AliError("Wrong TRD slice !");
- return -1.;
+ if ((plane<0) || (plane>=kTRDnPlanes)) {
+ AliError("Info for TRD plane not allocated !");
+ return;
}
- if (slice==-1) {
- Double_t q=0.;
- for (Int_t i=0; i<ns; i++) q+=fTRDslices[plane*ns + i];
- return q/ns;
- }
+ Int_t idx = fTRDnSlices-(kTRDnPlanes<<1)+plane;
+ // Protection for backward compatibility
+ if(idx<GetNumberOfTRDslices()*kTRDnPlanes) return;
- return fTRDslices[plane*ns + slice];
+ if(sp) fTRDslices[idx+kTRDnPlanes] = (*sp);
+ fTRDslices[idx] = p;
}
}
//_______________________________________________________________________
-Bool_t AliESDtrack::RelateToVertexTPC
-(const AliESDVertex *vtx, Double_t b, Double_t maxd) {
+Bool_t AliESDtrack::RelateToVertexTPC(const AliESDVertex *vtx,
+Double_t b, Double_t maxd, AliExternalTrackParam *cParam) {
//
- // Try to relate the TPC-only track paramters to the vertex "vtx",
+ // Try to relate the TPC-only track parameters to the vertex "vtx",
// if the (rough) transverse impact parameter is not bigger then "maxd".
// Magnetic field is "b" (kG).
//
// a) The TPC-only paramters are extapolated to the DCA to the vertex.
// b) The impact parameters and their covariance matrix are calculated.
+ // c) An attempt to constrain the TPC-only params to the vertex is done.
+ // The constrained params are returned via "cParam".
//
+ // In the case of success, the returned value is kTRUE
+ // otherwise, it's kFALSE)
+ //
if (!fTPCInner) return kFALSE;
if (!vtx) return kFALSE;
fCdzTPC = cov[1];
fCzzTPC = cov[2];
+ Double_t covar[6]; vtx->GetCovMatrix(covar);
+ Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
+ Double_t c[3]={covar[2],0.,covar[5]};
+
+ Double_t chi2=GetPredictedChi2(p,c);
+ if (chi2>kVeryBig) return kFALSE;
+
+ fCchi2TPC=chi2;
+
+ if (!cParam) return kTRUE;
+
+ *cParam = *fTPCInner;
+ if (!cParam->Update(p,c)) return kFALSE;
+
return kTRUE;
}
//_______________________________________________________________________
-Bool_t AliESDtrack::RelateToVertex
-(const AliESDVertex *vtx, Double_t b, Double_t maxd) {
+Bool_t AliESDtrack::RelateToVertexTPCBxByBz(const AliESDVertex *vtx,
+Double_t b[3], Double_t maxd, AliExternalTrackParam *cParam) {
+ //
+ // Try to relate the TPC-only track parameters to the vertex "vtx",
+ // if the (rough) transverse impact parameter is not bigger then "maxd".
+ //
+ // All three components of the magnetic field ,"b[3]" (kG),
+ // are taken into account.
+ //
+ // a) The TPC-only paramters are extapolated to the DCA to the vertex.
+ // b) The impact parameters and their covariance matrix are calculated.
+ // c) An attempt to constrain the TPC-only params to the vertex is done.
+ // The constrained params are returned via "cParam".
+ //
+ // In the case of success, the returned value is kTRUE
+ // otherwise, it's kFALSE)
+ //
+
+ if (!fTPCInner) return kFALSE;
+ if (!vtx) return kFALSE;
+
+ Double_t dz[2],cov[3];
+ if (!fTPCInner->PropagateToDCABxByBz(vtx, b, maxd, dz, cov)) return kFALSE;
+
+ fdTPC = dz[0];
+ fzTPC = dz[1];
+ fCddTPC = cov[0];
+ fCdzTPC = cov[1];
+ fCzzTPC = cov[2];
+
+ Double_t covar[6]; vtx->GetCovMatrix(covar);
+ Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
+ Double_t c[3]={covar[2],0.,covar[5]};
+
+ Double_t chi2=GetPredictedChi2(p,c);
+ if (chi2>kVeryBig) return kFALSE;
+
+ fCchi2TPC=chi2;
+
+ if (!cParam) return kTRUE;
+
+ *cParam = *fTPCInner;
+ if (!cParam->Update(p,c)) return kFALSE;
+
+ return kTRUE;
+}
+
+//_______________________________________________________________________
+Bool_t AliESDtrack::RelateToVertex(const AliESDVertex *vtx,
+Double_t b, Double_t maxd, AliExternalTrackParam *cParam) {
//
// Try to relate this track to the vertex "vtx",
// if the (rough) transverse impact parameter is not bigger then "maxd".
// a) The track gets extapolated to the DCA to the vertex.
// b) The impact parameters and their covariance matrix are calculated.
// c) An attempt to constrain this track to the vertex is done.
+ // The constrained params are returned via "cParam".
//
- // In the case of success, the returned value is kTRUE
- // (otherwise, it's kFALSE)
+ // In the case of success, the returned value is kTRUE
+ // (otherwise, it's kFALSE)
//
if (!vtx) return kFALSE;
Double_t c[3]={covar[2],0.,covar[5]};
Double_t chi2=GetPredictedChi2(p,c);
- if (chi2>77.) return kFALSE;
+ if (chi2>kVeryBig) return kFALSE;
+
+ fCchi2=chi2;
+
+ //--- Could now these lines be removed ? ---
delete fCp;
fCp=new AliExternalTrackParam(*this);
if (!fCp->Update(p,c)) {delete fCp; fCp=0; return kFALSE;}
+ //----------------------------------------
+
+ fVertexID = vtx->GetID();
+
+ if (!cParam) return kTRUE;
+
+ *cParam = *this;
+ if (!cParam->Update(p,c)) return kFALSE;
+
+ return kTRUE;
+}
+
+//_______________________________________________________________________
+Bool_t AliESDtrack::RelateToVertexBxByBz(const AliESDVertex *vtx,
+Double_t b[3], Double_t maxd, AliExternalTrackParam *cParam) {
+ //
+ // Try to relate this track to the vertex "vtx",
+ // if the (rough) transverse impact parameter is not bigger then "maxd".
+ // Magnetic field is "b" (kG).
+ //
+ // a) The track gets extapolated to the DCA to the vertex.
+ // b) The impact parameters and their covariance matrix are calculated.
+ // c) An attempt to constrain this track to the vertex is done.
+ // The constrained params are returned via "cParam".
+ //
+ // In the case of success, the returned value is kTRUE
+ // (otherwise, it's kFALSE)
+ //
+
+ if (!vtx) return kFALSE;
+
+ Double_t dz[2],cov[3];
+ if (!PropagateToDCABxByBz(vtx, b, maxd, dz, cov)) return kFALSE;
+
+ fD = dz[0];
+ fZ = dz[1];
+ fCdd = cov[0];
+ fCdz = cov[1];
+ fCzz = cov[2];
+ Double_t covar[6]; vtx->GetCovMatrix(covar);
+ Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
+ Double_t c[3]={covar[2],0.,covar[5]};
+
+ Double_t chi2=GetPredictedChi2(p,c);
+ if (chi2>kVeryBig) return kFALSE;
+
fCchi2=chi2;
+
+
+ //--- Could now these lines be removed ? ---
+ delete fCp;
+ fCp=new AliExternalTrackParam(*this);
+
+ if (!fCp->Update(p,c)) {delete fCp; fCp=0; return kFALSE;}
+ //----------------------------------------
+
+ fVertexID = vtx->GetID();
+
+ if (!cParam) return kTRUE;
+
+ *cParam = *this;
+ if (!cParam->Update(p,c)) return kFALSE;
+
return kTRUE;
}
arrayRef.AddLast(new AliExternalTrackParam(*this));
if (fIp) arrayRef.AddLast(new AliExternalTrackParam(*fIp));
if (fOp) arrayRef.AddLast(new AliExternalTrackParam(*fOp));
+ if (fHMPIDp) arrayRef.AddLast(new AliExternalTrackParam(*fHMPIDp));
//
Double_t mpos[3]={0,0,0};
Int_t entries=arrayRef.GetEntries();
}
}
}
+
+//_______________________________________________________________________
+void AliESDtrack::SetITSdEdxSamples(const Double_t s[4]) {
+ //
+ // Store the dE/dx samples measured by the two SSD and two SDD layers.
+ // These samples are corrected for the track segment length.
+ //
+ for (Int_t i=0; i<4; i++) fITSdEdxSamples[i]=s[i];
+}
+
+//_______________________________________________________________________
+void AliESDtrack::GetITSdEdxSamples(Double_t *s) const {
+ //
+ // Get the dE/dx samples measured by the two SSD and two SDD layers.
+ // These samples are corrected for the track segment length.
+ //
+ for (Int_t i=0; i<4; i++) s[i]=fITSdEdxSamples[i];
+}
+
+
+UShort_t AliESDtrack::GetTPCnclsS(Int_t i0,Int_t i1) const{
+ //
+ // get number of shared clusters
+ //
+ return fTPCSharedMap.CountBits(i0)-fTPCSharedMap.CountBits(i1);
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff