// e-mail: Jouri.Belikov@cern.ch
//-----------------------------------------------------------------
-#include "TMath.h"
+#include <TMath.h>
+#include <TParticle.h>
#include "AliESDVertex.h"
#include "AliESDtrack.h"
#include "AliKalmanTrack.h"
-#include "AliTrackPointArray.h"
#include "AliLog.h"
+#include "AliTrackPointArray.h"
ClassImp(AliESDtrack)
fOp(0),
fITSchi2(0),
fITSncls(0),
+ fITSClusterMap(0),
fITSsignal(0),
fITSLabel(0),
- fITSFakeRatio(0),
- fITStrack(0),
fTPCchi2(0),
fTPCncls(0),
fTPCnclsF(0),
fTPCClusterMap(159),//number of padrows
+ fTPCSharedMap(159),//number of padrows
fTPCsignal(0),
fTPCsignalN(0),
fTPCsignalS(0),
fTRDLabel(0),
fTRDQuality(0),
fTRDBudget(0),
- fTRDtrack(0),
fTOFchi2(0),
fTOFindex(0),
fTOFCalChannel(-1),
fTOFsignal(-1),
fTOFsignalToT(0),
- // fPHOSsignal(-1),
- fRICHchi2(1e10),
- fRICHncls(0),
- fRICHindex(0),
- fRICHsignal(-1),
- fRICHtheta(-1),
- fRICHphi(-1),
- fRICHdx(-1),
- fRICHdy(-1),
- fRICHmipX(-1),
- fRICHmipY(-1),
- fPoints(0)
+ fTOFsignalRaw(0),
+ fTOFsignalDz(0),
+ fHMPIDchi2(1e10),
+ fHMPIDqn(-1),
+ fHMPIDcluIdx(-1),
+ fHMPIDsignal(-1),
+ fHMPIDtrkTheta(-1),
+ fHMPIDtrkPhi(-1),
+ fHMPIDtrkX(-1),
+ fHMPIDtrkY(-1),
+ fHMPIDmipX(-1),
+ fHMPIDmipY(-1),
+ fEMCALindex(kEMCALNoMatch),
+ fFriendTrack(new AliESDfriendTrack())
{
//
// The default ESD constructor
//
- Int_t i;
+ Int_t i, j;
for (i=0; i<AliPID::kSPECIES; i++) {
fTrackTime[i]=0.;
fR[i]=1.;
fTPCr[i]=1.;
fTRDr[i]=1.;
fTOFr[i]=1.;
- fRICHr[i]=1.;
+ fHMPIDr[i]=1.;
}
- for (i=0; i<kMaxITScluster; i++) fITSchi2MIP[i]=1e10;
- for (i=0; i<kMaxITScluster; i++) { fITSindex[i]=-1; }
- for (i=0; i<kMaxTPCcluster; i++) { fTPCindex[i]=-2; }
for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
for (i=0; i<3; i++) { fV0Indexes[i]=-1;}
- for (i=0; i<kMaxTRDcluster; i++) { fTRDindex[i]=-2; }
- for (i=0;i<kNPlane;i++) {fTRDsignals[i]=0.; fTRDTimBin[i]=-1;}
+ for (i=0;i<kNPlane;i++) {
+ for (j=0;j<kNSlice;j++) {
+ fTRDsignals[i][j]=0.;
+ }
+ fTRDTimBin[i]=-1;
+ }
for (i=0;i<4;i++) {fTPCPoints[i]=-1;}
for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
for (i=0;i<10;i++) {fTOFInfo[i]=-1;}
fOp(0),
fITSchi2(track.fITSchi2),
fITSncls(track.fITSncls),
+ fITSClusterMap(track.fITSClusterMap),
fITSsignal(track.fITSsignal),
fITSLabel(track.fITSLabel),
- fITSFakeRatio(track.fITSFakeRatio),
- fITStrack(0), //coping separatelly - in user code
fTPCchi2(track.fTPCchi2),
fTPCncls(track.fTPCncls),
fTPCnclsF(track.fTPCnclsF),
fTPCClusterMap(track.fTPCClusterMap),
+ fTPCSharedMap(track.fTPCSharedMap),
fTPCsignal(track.fTPCsignal),
fTPCsignalN(track.fTPCsignalN),
fTPCsignalS(track.fTPCsignalS),
fTRDLabel(track.fTRDLabel),
fTRDQuality(track.fTRDQuality),
fTRDBudget(track.fTRDBudget),
- fTRDtrack(0),
fTOFchi2(track.fTOFchi2),
fTOFindex(track.fTOFindex),
fTOFCalChannel(track.fTOFCalChannel),
fTOFsignal(track.fTOFsignal),
fTOFsignalToT(track.fTOFsignalToT),
- //fPHOSsignal(track.fPHOSsignal),
- fRICHchi2(track.fRICHchi2),
- fRICHncls(track.fRICHncls),
- fRICHindex(track.fRICHindex),
- fRICHsignal(track.fRICHsignal),
- fRICHtheta(track.fRICHtheta),
- fRICHphi(track.fRICHphi),
- fRICHdx(track.fRICHdx),
- fRICHdy(track.fRICHdy),
- fRICHmipX(track.fRICHmipX),
- fRICHmipY(track.fRICHmipY)
+ fTOFsignalRaw(track.fTOFsignalRaw),
+ fTOFsignalDz(track.fTOFsignalDz),
+ fHMPIDchi2(track.fHMPIDchi2),
+ fHMPIDqn(track.fHMPIDqn),
+ fHMPIDcluIdx(track.fHMPIDcluIdx),
+ fHMPIDsignal(track.fHMPIDsignal),
+ fHMPIDtrkTheta(track.fHMPIDtrkTheta),
+ fHMPIDtrkPhi(track.fHMPIDtrkPhi),
+ fHMPIDtrkX(track.fHMPIDtrkX),
+ fHMPIDtrkY(track.fHMPIDtrkY),
+ fHMPIDmipX(track.fHMPIDmipX),
+ fHMPIDmipY(track.fHMPIDmipY),
+ fEMCALindex(track.fEMCALindex),
+ fFriendTrack(0)
{
//
//copy constructor
for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i]=track.fTrackTime[i];
for (Int_t i=0;i<AliPID::kSPECIES;i++) fR[i]=track.fR[i];
//
- for (Int_t i=0;i<kMaxITScluster;i++) fITSchi2MIP[i]=track.fITSchi2MIP[i];
- for (Int_t i=0;i<kMaxITScluster;i++) fITSindex[i]=track.fITSindex[i];
for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=track.fITSr[i];
//
- for (Int_t i=0;i<kMaxTPCcluster;i++) fTPCindex[i]=track.fTPCindex[i];
for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=track.fTPCr[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];}
//
- for (Int_t i=0;i<kMaxTRDcluster;i++) fTRDindex[i]=track.fTRDindex[i];
for (Int_t i=0;i<kNPlane;i++) {
- fTRDsignals[i]=track.fTRDsignals[i];
- fTRDTimBin[i]=track.fTRDTimBin[i];
+ for (Int_t j=0;j<kNSlice;j++) {
+ fTRDsignals[i][j]=track.fTRDsignals[i][j];
+ }
+ fTRDTimBin[i]=track.fTRDTimBin[i];
}
for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i]=track.fTRDr[i];
for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i]=track.fTOFr[i];
for (Int_t i=0;i<3;i++) fTOFLabel[i]=track.fTOFLabel[i];
for (Int_t i=0;i<10;i++) fTOFInfo[i]=track.fTOFInfo[i];
- for (Int_t i=0;i<AliPID::kSPECIES;i++) fRICHr[i]=track.fRICHr[i];
+ for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i]=track.fHMPIDr[i];
if (track.fCp) fCp=new AliExternalTrackParam(*track.fCp);
if (track.fIp) fIp=new AliExternalTrackParam(*track.fIp);
if (track.fOp) fOp=new AliExternalTrackParam(*track.fOp);
- fPoints =0;
- if (track.fPoints){
- fPoints = new AliTrackPointArray(*(track.fPoints));
+
+ if (track.fFriendTrack) fFriendTrack=new AliESDfriendTrack(*(track.fFriendTrack));
+}
+
+//_______________________________________________________________________
+AliESDtrack::AliESDtrack(TParticle * part) :
+ AliExternalTrackParam(),
+ fFlags(0),
+ fLabel(0),
+ fID(0),
+ fTrackLength(0),
+ fD(0),fZ(0),
+ fCdd(0),fCdz(0),fCzz(0),
+ fStopVertex(0),
+ fCp(0),
+ fCchi2(1e10),
+ fIp(0),
+ fOp(0),
+ fITSchi2(0),
+ fITSncls(0),
+ fITSClusterMap(0),
+ fITSsignal(0),
+ fITSLabel(0),
+ fTPCchi2(0),
+ fTPCncls(0),
+ fTPCnclsF(0),
+ fTPCClusterMap(159),//number of padrows
+ fTPCSharedMap(159),//number of padrows
+ fTPCsignal(0),
+ fTPCsignalN(0),
+ fTPCsignalS(0),
+ fTPCLabel(0),
+ fTRDchi2(0),
+ fTRDncls(0),
+ fTRDncls0(0),
+ fTRDsignal(0),
+ fTRDLabel(0),
+ fTRDQuality(0),
+ fTRDBudget(0),
+ fTOFchi2(0),
+ fTOFindex(0),
+ fTOFCalChannel(-1),
+ fTOFsignal(-1),
+ fTOFsignalToT(0),
+ fTOFsignalRaw(0),
+ fTOFsignalDz(0),
+ fHMPIDchi2(1e10),
+ fHMPIDqn(-1),
+ fHMPIDcluIdx(-1),
+ fHMPIDsignal(-1),
+ fHMPIDtrkTheta(-1),
+ fHMPIDtrkPhi(-1),
+ fHMPIDtrkX(-1),
+ fHMPIDtrkY(-1),
+ fHMPIDmipX(-1),
+ fHMPIDmipY(-1),
+ fEMCALindex(kEMCALNoMatch),
+ fFriendTrack(0)
+{
+ //
+ // ESD track from TParticle
+ //
+
+ // Reset all the arrays
+ Int_t i, j;
+ 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<kNPlane;i++) {
+ for (j=0;j<kNSlice;j++) {
+ fTRDsignals[i][j]=0.;
+ }
+ fTRDTimBin[i]=-1;
+ }
+ for (i=0;i<4;i++) {fTPCPoints[i]=-1;}
+ for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
+ for (i=0;i<10;i++) {fTOFInfo[i]=-1;}
+
+ // Calculate the AliExternalTrackParam content
+
+ Double_t xref;
+ Double_t alpha;
+ Double_t param[5];
+ Double_t covar[15];
+
+ // Calculate alpha: the rotation angle of the corresponding local system (TPC sector)
+ alpha = part->Phi()*180./TMath::Pi();
+ if (alpha<0) alpha+= 360.;
+ if (alpha>360) alpha -= 360.;
+
+ Int_t sector = (Int_t)(alpha/20.);
+ alpha = 10. + 20.*sector;
+ alpha /= 180;
+ alpha *= TMath::Pi();
+
+ // Covariance matrix: no errors, the parameters are exact
+ for (i=0; i<15; i++) covar[i]=0.;
+
+ // Get the vertex of origin and the momentum
+ TVector3 ver(part->Vx(),part->Vy(),part->Vz());
+ TVector3 mom(part->Px(),part->Py(),part->Pz());
+
+ // Rotate to the local coordinate system (TPC sector)
+ ver.RotateZ(-alpha);
+ mom.RotateZ(-alpha);
+
+ // X of the referense plane
+ xref = ver.X();
+
+ Int_t pdgCode = part->GetPdgCode();
+
+ Double_t charge =
+ TDatabasePDG::Instance()->GetParticle(pdgCode)->Charge();
+
+ param[0] = ver.Y();
+ param[1] = ver.Z();
+ param[2] = TMath::Sin(mom.Phi());
+ param[3] = mom.Pz()/mom.Pt();
+ param[4] = TMath::Sign(1/mom.Pt(),charge);
+
+ // Set AliExternalTrackParam
+ Set(xref, alpha, param, covar);
+
+ // Set the PID
+ Int_t indexPID = 99;
+
+ switch (TMath::Abs(pdgCode)) {
+
+ case 11: // electron
+ indexPID = 0;
+ break;
+
+ case 13: // muon
+ indexPID = 1;
+ break;
+
+ case 211: // pion
+ indexPID = 2;
+ break;
+
+ case 321: // kaon
+ indexPID = 3;
+ break;
+
+ case 2212: // proton
+ indexPID = 4;
+ break;
+
+ default:
+ break;
}
+
+ // If the particle is not e,mu,pi,K or p the PID probabilities are set to 0
+ if (indexPID < AliPID::kSPECIES) {
+ fR[indexPID]=1.;
+ fITSr[indexPID]=1.;
+ fTPCr[indexPID]=1.;
+ fTRDr[indexPID]=1.;
+ fTOFr[indexPID]=1.;
+ fHMPIDr[indexPID]=1.;
+
+ }
+ // AliESD track label
+ SetLabel(part->GetUniqueID());
+
}
+
//_______________________________________________________________________
AliESDtrack::~AliESDtrack(){
//
delete fIp;
delete fOp;
delete fCp;
- delete fITStrack;
- delete fTRDtrack;
- delete fPoints;
+ delete fFriendTrack;
}
+void AliESDtrack::AddCalibObject(TObject * object){
+ //
+ // add calib object to the list
+ //
+ if (!fFriendTrack) fFriendTrack = new AliESDfriendTrack;
+ fFriendTrack->AddCalibObject(object);
+}
+
+TObject * AliESDtrack::GetCalibObject(Int_t index){
+ //
+ // return calib objct at given position
+ //
+ if (!fFriendTrack) return 0;
+ return fFriendTrack->GetCalibObject(index);
+}
+
+
//_______________________________________________________________________
void AliESDtrack::MakeMiniESDtrack(){
// Resets everything except
// fD: Impact parameter in XY-plane
// fZ: Impact parameter in Z
// fR[AliPID::kSPECIES]: combined "detector response probability"
- // Running track parameters
- // fRalpha: track rotation angle
- // fRx: X-coordinate of the track reference plane
- // fRp[5]: external track parameters
- // fRc[15]: external cov. matrix of the track parameters
+ // Running track parameters in the base class (AliExternalTrackParam)
fTrackLength = 0;
for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i] = 0;
// Reset ITS track related information
fITSchi2 = 0;
- for (Int_t i=0;i<kMaxITScluster;i++) fITSchi2MIP[i]=0;
fITSncls = 0;
- for (Int_t i=0;i<kMaxITScluster;i++) fITSindex[i]=-1;
+ fITSClusterMap=0;
fITSsignal = 0;
for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=0;
fITSLabel = 0;
- fITSFakeRatio = 0;
- fITStrack =0;
// Reset TPC related track information
fTPCchi2 = 0;
fTPCncls = 0;
fTPCnclsF = 0;
- for (Int_t i=0;i<kMaxTPCcluster;i++) fTPCindex[i] = -2;
fTPCClusterMap = 0;
+ fTPCSharedMap = 0;
fTPCsignal= 0;
fTPCsignalS= 0;
fTPCsignalN= 0;
fTRDchi2 = 0;
fTRDncls = 0;
fTRDncls0 = 0;
- for (Int_t i=0;i<kMaxTRDcluster;i++) fTRDindex[i] = -2;
fTRDsignal = 0;
for (Int_t i=0;i<kNPlane;i++) {
- fTRDsignals[i] = 0;
- fTRDTimBin[i] = 0;
+ for (Int_t j=0;j<kNSlice;j++) {
+ fTRDsignals[i][j] = 0;
+ }
+ fTRDTimBin[i] = 0;
}
for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i] = 0;
fTRDLabel = 0;
- fTRDtrack = 0;
fTRDQuality = 0;
fTRDBudget = 0;
fTOFsignal = 0;
fTOFCalChannel = -1;
fTOFsignalToT = 0;
+ fTOFsignalRaw = 0;
+ fTOFsignalDz = 0;
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<10;i++) fTOFInfo[i] = 0;
- // Reset PHOS related track information
- //for (Int_t i=0;i<3;i++) fPHOSpos[i] = 0;
- //fPHOSsignal = 0;
- //for (Int_t i=0;i<AliPID::kSPECIESN;i++) fPHOSr[i] = 0;
-
- // Reset RICH related track information
- fRICHchi2 = 0;
- fRICHncls = 0;
- fRICHindex = 0;
- fRICHsignal = 0;
- for (Int_t i=0;i<AliPID::kSPECIES;i++) fRICHr[i] = 0;
- fRICHtheta = 0;
- fRICHphi = 0;
- fRICHdx = 0;
- fRICHdy = 0;
-
- fPoints = 0;
+ // Reset HMPID related track information
+ fHMPIDchi2 = 0;
+ fHMPIDqn = -1;
+ fHMPIDcluIdx = -1;
+ fHMPIDsignal = 0;
+ for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i] = 0;
+ fHMPIDtrkTheta = -1;
+ fHMPIDtrkPhi = -1;
+ fHMPIDtrkX = -1;
+ fHMPIDtrkY = -1;
+ fHMPIDmipX = -1;
+ fHMPIDmipY = -1;
+ fEMCALindex = kEMCALNoMatch;
+
+ delete fFriendTrack; fFriendTrack = 0;
}
//_______________________________________________________________________
Double_t AliESDtrack::GetMass() const {
//
// This function updates track's running parameters
//
+ Int_t *index=0;
Bool_t rc=kTRUE;
SetStatus(flags);
SetIntegratedLength(t->GetIntegratedLength());
}
- Set(*t);
+ Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
switch (flags) {
case kITSin: case kITSout: case kITSrefit:
fITSncls=t->GetNumberOfClusters();
+ index=fFriendTrack->GetITSindices();
+ for (Int_t i=0;i<AliESDfriendTrack::kMaxITScluster;i++) {
+ index[i]=t->GetClusterIndex(i);
+ if (i<fITSncls) {
+ Int_t l=(index[i] & 0xf0000000) >> 28;
+ SETBIT(fITSClusterMap,l);
+ }
+ }
fITSchi2=t->GetChi2();
- for (Int_t i=0;i<kMaxITScluster;i++) fITSindex[i]=t->GetClusterIndex(i);
fITSsignal=t->GetPIDsignal();
fITSLabel = t->GetLabel();
- fITSFakeRatio = t->GetFakeRatio();
break;
case kTPCin: case kTPCrefit:
fTPCLabel = t->GetLabel();
if (!fIp) fIp=new AliExternalTrackParam(*t);
- else fIp->Set(*t);
+ else
+ fIp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
case kTPCout:
+ index=fFriendTrack->GetTPCindices();
if (flags & kTPCout){
if (!fOp) fOp=new AliExternalTrackParam(*t);
- else fOp->Set(*t);
+ else
+ fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
}
fTPCncls=t->GetNumberOfClusters();
fTPCchi2=t->GetChi2();
//"jump to case label crosses initialization of `Int_t prevrow'"
Int_t prevrow = -1;
// for (Int_t i=0;i<fTPCncls;i++)
- for (Int_t i=0;i<kMaxTPCcluster;i++)
+ for (Int_t i=0;i<AliESDfriendTrack::kMaxTPCcluster;i++)
{
- fTPCindex[i]=t->GetClusterIndex(i);
+ index[i]=t->GetClusterIndex(i);
+ Int_t idx = index[i];
- if (fTPCindex[i]<0) continue;
+ if (idx<0) continue;
// Piotr's Cluster Map for HBT
// ### please change accordingly if cluster array is changing
// to "New TPC Tracking" style (with gaps in array)
- Int_t idx = fTPCindex[i];
Int_t sect = (idx&0xff000000)>>24;
Int_t row = (idx&0x00ff0000)>>16;
if (sect > 18) row +=63; //if it is outer sector, add number of inner sectors
break;
case kTRDout: case kTRDin: case kTRDrefit:
+ index=fFriendTrack->GetTRDindices();
fTRDLabel = t->GetLabel();
fTRDncls=t->GetNumberOfClusters();
fTRDchi2=t->GetChi2();
- for (Int_t i=0;i<fTRDncls;i++) fTRDindex[i]=t->GetClusterIndex(i);
+ for (Int_t i=0;i<fTRDncls;i++) index[i]=t->GetClusterIndex(i);
fTRDsignal=t->GetPIDsignal();
break;
case kTRDbackup:
if (!fOp) fOp=new AliExternalTrackParam(*t);
- else fOp->Set(*t);
+ else
+ fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
fTRDncls0 = t->GetNumberOfClusters();
break;
case kTOFin:
SetStatus(AliESDtrack::kITSpid);
}
-void AliESDtrack::SetITSChi2MIP(const Float_t *chi2mip){
- for (Int_t i=0; i<kMaxITScluster; i++) fITSchi2MIP[i]=chi2mip[i];
-}
//_______________________________________________________________________
void AliESDtrack::GetITSpid(Double_t *p) const {
// Gets the probability of each particle type (in ITS)
//---------------------------------------------------------------------
// This function returns indices of the assgined ITS clusters
//---------------------------------------------------------------------
- for (Int_t i=0; i<kMaxITScluster; i++) idx[i]=fITSindex[i];
+ if (idx!=0) {
+ Int_t *index=fFriendTrack->GetITSindices();
+ for (Int_t i=0; i<AliESDfriendTrack::kMaxITScluster; i++) idx[i]=index[i];
+ }
return fITSncls;
}
//---------------------------------------------------------------------
// This function returns indices of the assgined ITS clusters
//---------------------------------------------------------------------
- if (idx!=0)
- for (Int_t i=0; i<kMaxTPCcluster; i++) idx[i]=fTPCindex[i]; // MI I prefer some constant
+ if (idx!=0) {
+ Int_t *index=fFriendTrack->GetTPCindices();
+ for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=index[i];
+ }
return fTPCncls;
}
Int_t good = 0;
Int_t found = 0;
//
+ Int_t *index=fFriendTrack->GetTPCindices();
for (Int_t i=row0;i<=row1;i++){
- Int_t index = fTPCindex[i];
- if (index!=-1) good++; // track outside of dead zone
- if (index>0) found++;
+ Int_t idx = index[i];
+ if (idx!=-1) good++; // track outside of dead zone
+ if (idx>0) found++;
}
Float_t density=0.5;
if (good>(row1-row0)*0.5) density = Float_t(found)/Float_t(good);
//---------------------------------------------------------------------
// This function returns indices of the assgined TRD clusters
//---------------------------------------------------------------------
- if (idx!=0)
- for (Int_t i=0; i<kMaxTRDcluster; i++) idx[i]=fTRDindex[i]; // MI I prefer some constant
+ if (idx!=0) {
+ Int_t *index=fFriendTrack->GetTRDindices();
+ for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=index[i];
+ }
return fTRDncls;
}
//_______________________________________________________________________
-void AliESDtrack::SetRICHpid(const Double_t *p) {
- // Sets the probability of each particle type (in RICH)
- SetPIDValues(fRICHr,p,AliPID::kSPECIES);
- SetStatus(AliESDtrack::kRICHpid);
+void AliESDtrack::SetHMPIDpid(const Double_t *p) {
+ // Sets the probability of each particle type (in HMPID)
+ SetPIDValues(fHMPIDr,p,AliPID::kSPECIES);
+ SetStatus(AliESDtrack::kHMPIDpid);
}
//_______________________________________________________________________
-void AliESDtrack::GetRICHpid(Double_t *p) const {
- // Gets probabilities of each particle type (in RICH)
- for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fRICHr[i];
+void AliESDtrack::GetHMPIDpid(Double_t *p) const {
+ // Gets probabilities of each particle type (in HMPID)
+ for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fHMPIDr[i];
}
// In the case of success, the returned value is kTRUE
// (otherwise, it's kFALSE)
//
+
+ if (!vtx) return kFALSE;
+
Double_t alpha=GetAlpha();
Double_t sn=TMath::Sin(alpha), cs=TMath::Cos(alpha);
Double_t x=GetX(), y=GetParameter()[0], snp=GetParameter()[2];
if (d > maxd) return kFALSE;
//Propagate to the DCA
- Double_t crv=0.299792458e-3*b*GetParameter()[4];
+ Double_t crv=kB2C*b*GetParameter()[4];
+ if (TMath::Abs(b) < kAlmost0Field) crv=0.;
+
Double_t tgfv=-(crv*x - snp)/(crv*y + TMath::Sqrt(1.-snp*snp));
- sn=tgfv/TMath::Sqrt(1.+ tgfv*tgfv); cs=TMath::Sqrt(1.- sn*sn);
+ sn=tgfv/TMath::Sqrt(1.+ tgfv*tgfv);
+ if (TMath::Abs(tgfv)>0.) cs = sn/tgfv;
+ else cs=1.;
x = xv*cs + yv*sn;
yv=-xv*sn + yv*cs; xv=x;
fZ = GetParameter()[1] - zv;
Double_t cov[6]; vtx->GetCovMatrix(cov);
- fCdd = GetCovariance()[0] + cov[2]; // neglecting non-diagonals
- fCdz = GetCovariance()[1]; // in the vertex's
- fCzz = GetCovariance()[2] + cov[5]; // covariance matrix
+
+ //***** Improvements by A.Dainese
+ alpha=GetAlpha(); sn=TMath::Sin(alpha); cs=TMath::Cos(alpha);
+ Double_t s2ylocvtx = cov[0]*sn*sn + cov[2]*cs*cs - 2.*cov[1]*cs*sn;
+ fCdd = GetCovariance()[0] + s2ylocvtx; // neglecting correlations
+ fCdz = GetCovariance()[1]; // between (x,y) and z
+ fCzz = GetCovariance()[2] + cov[5]; // in vertex's covariance matrix
+ //*****
{//Try to constrain
Double_t p[2]={yv,zv}, c[3]={cov[2],0.,cov[5]};
printf("%f, ", p[index]) ;
printf("\n signal = %f\n", GetTOFsignal()) ;
}
- if( IsOn(kRICHpid) ){
- printf("From RICH: ") ;
- GetRICHpid(p) ;
+ if( IsOn(kHMPIDpid) ){
+ printf("From HMPID: ") ;
+ GetHMPIDpid(p) ;
for(index = 0 ; index < AliPID::kSPECIES; index++)
printf("%f, ", p[index]) ;
- printf("\n signal = %f\n", GetRICHsignal()) ;
+ printf("\n signal = %f\n", GetHMPIDsignal()) ;
}
}
+
+Bool_t AliESDtrack::PropagateTo(Double_t xToGo, Double_t b, Double_t mass,
+Double_t maxStep, Bool_t rotateTo, Double_t maxSnp){
+ //----------------------------------------------------------------
+ //
+ // MI's function
+ //
+ // Propagates this track to the plane X=xk (cm)
+ // in the magnetic field "b" (kG),
+ // the correction for the material is included
+ //
+ // mass - mass used in propagation - used for energy loss correction
+ // maxStep - maximal step for propagation
+ //----------------------------------------------------------------
+ const Double_t kEpsilon = 0.00001;
+ Double_t xpos = GetX();
+ Double_t dir = (xpos<xToGo) ? 1.:-1.;
+ //
+ while ( (xToGo-xpos)*dir > kEpsilon){
+ Double_t step = dir*TMath::Min(TMath::Abs(xToGo-xpos), maxStep);
+ Double_t x = xpos+step;
+ Double_t xyz0[3],xyz1[3],param[7];
+ GetXYZ(xyz0); //starting global position
+ if (!GetXYZAt(x,b,xyz1)) return kFALSE; // no prolongation
+ xyz1[2]+=kEpsilon; // waiting for bug correction in geo
+ AliKalmanTrack::MeanMaterialBudget(xyz0,xyz1,param);
+ if (TMath::Abs(GetSnpAt(x,b)) >= maxSnp) return kFALSE;
+ if (!AliExternalTrackParam::PropagateTo(x,b)) return kFALSE;
+
+ Double_t rho=param[0],x0=param[1],distance=param[4];
+ Double_t d=distance*rho/x0;
+
+ if (!CorrectForMaterial(d,x0,mass)) return kFALSE;
+ if (rotateTo){
+ if (TMath::Abs(GetSnp()) >= maxSnp) return kFALSE;
+ GetXYZ(xyz0); // global position
+ Double_t alphan = TMath::ATan2(xyz0[1], xyz0[0]);
+ //
+ Double_t ca=TMath::Cos(alphan-GetAlpha()),
+ sa=TMath::Sin(alphan-GetAlpha());
+ Double_t sf=GetSnp(), cf=TMath::Sqrt(1.- sf*sf);
+ Double_t sinNew = sf*ca - cf*sa;
+ if (TMath::Abs(sinNew) >= maxSnp) return kFALSE;
+ if (!Rotate(alphan)) return kFALSE;
+ }
+ xpos = GetX();
+ }
+ return kTRUE;
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff