1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 // Implementation of the ESD track class
17 // ESD = Event Summary Data
18 // This is the class to deal with during the phisics analysis of data
19 // Origin: Iouri Belikov, CERN
20 // e-mail: Jouri.Belikov@cern.ch
21 //-----------------------------------------------------------------
24 #include <TParticle.h>
26 #include "AliESDVertex.h"
27 #include "AliESDtrack.h"
28 #include "AliKalmanTrack.h"
30 #include "AliTrackPointArray.h"
31 #include "TPolyMarker3D.h"
35 void SetPIDValues(Double_t * dest, const Double_t * src, Int_t n) {
36 // This function copies "n" PID weights from "scr" to "dest"
37 // and normalizes their sum to 1 thus producing conditional probabilities.
38 // The negative weights are set to 0.
39 // In case all the weights are non-positive they are replaced by
40 // uniform probabilities
44 Float_t uniform = 1./(Float_t)n;
47 for (Int_t i=0; i<n; i++)
57 for (Int_t i=0; i<n; i++) dest[i] /= sum;
59 for (Int_t i=0; i<n; i++) dest[i] = uniform;
62 //_______________________________________________________________________
63 AliESDtrack::AliESDtrack() :
64 AliExternalTrackParam(),
69 fFriendTrack(new AliESDfriendTrack()),
70 fTPCClusterMap(159),//number of padrows
71 fTPCSharedMap(159),//number of padrows
82 fEMCALindex(kEMCALNoMatch),
88 fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
90 fCdd(0),fCdz(0),fCzz(0),
124 // The default ESD constructor
127 for (i=0; i<AliPID::kSPECIES; i++) {
137 for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
138 for (i=0; i<3; i++) { fV0Indexes[i]=0;}
139 for (i=0;i<kTRDnPlanes;i++) {
142 for (i=0;i<4;i++) {fTPCPoints[i]=0;}
143 for (i=0;i<3;i++) {fTOFLabel[i]=0;}
144 for (i=0;i<10;i++) {fTOFInfo[i]=0;}
145 for (i=0;i<12;i++) {fITSModule[i]=-1;}
148 //_______________________________________________________________________
149 AliESDtrack::AliESDtrack(const AliESDtrack& track):
150 AliExternalTrackParam(track),
156 fTPCClusterMap(track.fTPCClusterMap),
157 fTPCSharedMap(track.fTPCSharedMap),
158 fFlags(track.fFlags),
160 fLabel(track.fLabel),
161 fITSLabel(track.fITSLabel),
162 fTPCLabel(track.fTPCLabel),
163 fTRDLabel(track.fTRDLabel),
164 fTOFCalChannel(track.fTOFCalChannel),
165 fTOFindex(track.fTOFindex),
166 fHMPIDqn(track.fHMPIDqn),
167 fHMPIDcluIdx(track.fHMPIDcluIdx),
168 fEMCALindex(track.fEMCALindex),
169 fHMPIDtrkTheta(track.fHMPIDtrkTheta),
170 fHMPIDtrkPhi(track.fHMPIDtrkPhi),
171 fHMPIDsignal(track.fHMPIDsignal),
172 fTrackLength(track.fTrackLength),
173 fdTPC(track.fdTPC),fzTPC(track.fzTPC),
174 fCddTPC(track.fCddTPC),fCdzTPC(track.fCdzTPC),fCzzTPC(track.fCzzTPC),
175 fD(track.fD),fZ(track.fZ),
176 fCdd(track.fCdd),fCdz(track.fCdz),fCzz(track.fCzz),
177 fCchi2(track.fCchi2),
178 fITSchi2(track.fITSchi2),
179 fTPCchi2(track.fTPCchi2),
180 fTRDchi2(track.fTRDchi2),
181 fTOFchi2(track.fTOFchi2),
182 fHMPIDchi2(track.fHMPIDchi2),
183 fITSsignal(track.fITSsignal),
184 fTPCsignal(track.fTPCsignal),
185 fTPCsignalS(track.fTPCsignalS),
186 fTRDsignal(track.fTRDsignal),
187 fTRDQuality(track.fTRDQuality),
188 fTRDBudget(track.fTRDBudget),
189 fTOFsignal(track.fTOFsignal),
190 fTOFsignalToT(track.fTOFsignalToT),
191 fTOFsignalRaw(track.fTOFsignalRaw),
192 fTOFsignalDz(track.fTOFsignalDz),
193 fHMPIDtrkX(track.fHMPIDtrkX),
194 fHMPIDtrkY(track.fHMPIDtrkY),
195 fHMPIDmipX(track.fHMPIDmipX),
196 fHMPIDmipY(track.fHMPIDmipY),
197 fTPCncls(track.fTPCncls),
198 fTPCnclsF(track.fTPCnclsF),
199 fTPCsignalN(track.fTPCsignalN),
200 fITSncls(track.fITSncls),
201 fITSClusterMap(track.fITSClusterMap),
202 fTRDncls(track.fTRDncls),
203 fTRDncls0(track.fTRDncls0),
204 fTRDpidQuality(track.fTRDpidQuality),
205 fTRDnSlices(track.fTRDnSlices),
211 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i]=track.fTrackTime[i];
212 for (Int_t i=0;i<AliPID::kSPECIES;i++) fR[i]=track.fR[i];
214 for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=track.fITSr[i];
216 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=track.fTPCr[i];
217 for (Int_t i=0;i<4;i++) {fTPCPoints[i]=track.fTPCPoints[i];}
218 for (Int_t i=0; i<3;i++) { fKinkIndexes[i]=track.fKinkIndexes[i];}
219 for (Int_t i=0; i<3;i++) { fV0Indexes[i]=track.fV0Indexes[i];}
221 for (Int_t i=0;i<kTRDnPlanes;i++) {
222 fTRDTimBin[i]=track.fTRDTimBin[i];
226 fTRDslices=new Double32_t[fTRDnSlices];
227 for (Int_t i=0; i<fTRDnSlices; i++) fTRDslices[i]=track.fTRDslices[i];
230 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i]=track.fTRDr[i];
231 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i]=track.fTOFr[i];
232 for (Int_t i=0;i<3;i++) fTOFLabel[i]=track.fTOFLabel[i];
233 for (Int_t i=0;i<10;i++) fTOFInfo[i]=track.fTOFInfo[i];
234 for (Int_t i=0;i<12;i++) fITSModule[i]=track.fITSModule[i];
235 for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i]=track.fHMPIDr[i];
237 if (track.fCp) fCp=new AliExternalTrackParam(*track.fCp);
238 if (track.fIp) fIp=new AliExternalTrackParam(*track.fIp);
239 if (track.fTPCInner) fTPCInner=new AliExternalTrackParam(*track.fTPCInner);
240 if (track.fOp) fOp=new AliExternalTrackParam(*track.fOp);
242 if (track.fFriendTrack) fFriendTrack=new AliESDfriendTrack(*(track.fFriendTrack));
245 //_______________________________________________________________________
246 AliESDtrack::AliESDtrack(TParticle * part) :
247 AliExternalTrackParam(),
253 fTPCClusterMap(159),//number of padrows
254 fTPCSharedMap(159),//number of padrows
265 fEMCALindex(kEMCALNoMatch),
271 fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
273 fCdd(0),fCdz(0),fCzz(0),
306 // ESD track from TParticle
309 // Reset all the arrays
311 for (i=0; i<AliPID::kSPECIES; i++) {
321 for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
322 for (i=0; i<3; i++) { fV0Indexes[i]=-1;}
323 for (i=0;i<kTRDnPlanes;i++) {
326 for (i=0;i<4;i++) {fTPCPoints[i]=0;}
327 for (i=0;i<3;i++) {fTOFLabel[i]=0;}
328 for (i=0;i<10;i++) {fTOFInfo[i]=0;}
329 for (i=0;i<12;i++) {fITSModule[i]=-1;}
331 // Calculate the AliExternalTrackParam content
338 // Calculate alpha: the rotation angle of the corresponding local system (TPC sector)
339 alpha = part->Phi()*180./TMath::Pi();
340 if (alpha<0) alpha+= 360.;
341 if (alpha>360) alpha -= 360.;
343 Int_t sector = (Int_t)(alpha/20.);
344 alpha = 10. + 20.*sector;
346 alpha *= TMath::Pi();
348 // Covariance matrix: no errors, the parameters are exact
349 for (i=0; i<15; i++) covar[i]=0.;
351 // Get the vertex of origin and the momentum
352 TVector3 ver(part->Vx(),part->Vy(),part->Vz());
353 TVector3 mom(part->Px(),part->Py(),part->Pz());
355 // Rotate to the local coordinate system (TPC sector)
359 // X of the referense plane
362 Int_t pdgCode = part->GetPdgCode();
365 TDatabasePDG::Instance()->GetParticle(pdgCode)->Charge();
369 param[2] = TMath::Sin(mom.Phi());
370 param[3] = mom.Pz()/mom.Pt();
371 param[4] = TMath::Sign(1/mom.Pt(),charge);
373 // Set AliExternalTrackParam
374 Set(xref, alpha, param, covar);
379 switch (TMath::Abs(pdgCode)) {
405 // If the particle is not e,mu,pi,K or p the PID probabilities are set to 0
406 if (indexPID < AliPID::kSPECIES) {
412 fHMPIDr[indexPID]=1.;
415 // AliESD track label
416 SetLabel(part->GetUniqueID());
420 //_______________________________________________________________________
421 AliESDtrack::~AliESDtrack(){
423 // This is destructor according Coding Conventrions
425 //printf("Delete track\n");
435 AliESDtrack &AliESDtrack::operator=(const AliESDtrack &source){
438 if(&source == this) return *this;
439 AliExternalTrackParam::operator=(source);
443 // we have the trackparam: assign or copy construct
444 if(fCp)*fCp = *source.fCp;
445 else fCp = new AliExternalTrackParam(*source.fCp);
448 // no track param delete the old one
454 // we have the trackparam: assign or copy construct
455 if(fIp)*fIp = *source.fIp;
456 else fIp = new AliExternalTrackParam(*source.fIp);
459 // no track param delete the old one
465 if(source.fTPCInner){
466 // we have the trackparam: assign or copy construct
467 if(fTPCInner) *fTPCInner = *source.fTPCInner;
468 else fTPCInner = new AliExternalTrackParam(*source.fTPCInner);
471 // no track param delete the old one
472 if(fTPCInner)delete fTPCInner;
478 // we have the trackparam: assign or copy construct
479 if(fOp) *fOp = *source.fOp;
480 else fOp = new AliExternalTrackParam(*source.fOp);
483 // no track param delete the old one
488 // copy also the friend track
489 // use copy constructor
490 if(source.fFriendTrack){
491 // we have the trackparam: assign or copy construct
492 delete fFriendTrack; fFriendTrack=new AliESDfriendTrack(*source.fFriendTrack);
495 // no track param delete the old one
496 delete fFriendTrack; fFriendTrack= 0;
499 fTPCClusterMap = source.fTPCClusterMap;
500 fTPCSharedMap = source.fTPCSharedMap;
502 fFlags = source.fFlags;
504 fLabel = source.fLabel;
505 fITSLabel = source.fITSLabel;
506 for(int i = 0; i< 12;++i){
507 fITSModule[i] = source.fITSModule[i];
509 fTPCLabel = source.fTPCLabel;
510 fTRDLabel = source.fTRDLabel;
511 for(int i = 0; i< 3;++i){
512 fTOFLabel[i] = source.fTOFLabel[i];
514 fTOFCalChannel = source.fTOFCalChannel;
515 fTOFindex = source.fTOFindex;
516 fHMPIDqn = source.fHMPIDqn;
517 fHMPIDcluIdx = source.fHMPIDcluIdx;
518 fEMCALindex = source.fEMCALindex;
520 for(int i = 0; i< 3;++i){
521 fKinkIndexes[i] = source.fKinkIndexes[i];
522 fV0Indexes[i] = source.fV0Indexes[i];
525 for(int i = 0; i< AliPID::kSPECIES;++i){
526 fR[i] = source.fR[i];
527 fITSr[i] = source.fITSr[i];
528 fTPCr[i] = source.fTPCr[i];
529 fTRDr[i] = source.fTRDr[i];
530 fTOFr[i] = source.fTOFr[i];
531 fHMPIDr[i] = source.fHMPIDr[i];
532 fTrackTime[i] = source.fTrackTime[i];
535 fHMPIDtrkTheta = source.fHMPIDtrkTheta;
536 fHMPIDtrkPhi = source.fHMPIDtrkPhi;
537 fHMPIDsignal = source.fHMPIDsignal;
540 fTrackLength = source. fTrackLength;
541 fdTPC = source.fdTPC;
542 fzTPC = source.fzTPC;
543 fCddTPC = source.fCddTPC;
544 fCdzTPC = source.fCdzTPC;
545 fCzzTPC = source.fCzzTPC;
552 fCchi2 = source.fCchi2;
553 fITSchi2 = source.fITSchi2;
554 fTPCchi2 = source.fTPCchi2;
555 fTRDchi2 = source.fTRDchi2;
556 fTOFchi2 = source.fTOFchi2;
557 fHMPIDchi2 = source.fHMPIDchi2;
560 fITSsignal = source.fITSsignal;
561 fTPCsignal = source.fTPCsignal;
562 fTPCsignalS = source.fTPCsignalS;
563 for(int i = 0; i< 4;++i){
564 fTPCPoints[i] = source.fTPCPoints[i];
566 fTRDsignal = source.fTRDsignal;
568 for(int i = 0;i < kTRDnPlanes;++i){
569 fTRDTimBin[i] = source.fTRDTimBin[i];
575 fTRDnSlices=source.fTRDnSlices;
577 fTRDslices=new Double32_t[fTRDnSlices];
578 for(int j = 0;j < fTRDnSlices;++j) fTRDslices[j] = source.fTRDslices[j];
581 fTRDQuality = source.fTRDQuality;
582 fTRDBudget = source.fTRDBudget;
583 fTOFsignal = source.fTOFsignal;
584 fTOFsignalToT = source.fTOFsignalToT;
585 fTOFsignalRaw = source.fTOFsignalRaw;
586 fTOFsignalDz = source.fTOFsignalDz;
588 for(int i = 0;i<10;++i){
589 fTOFInfo[i] = source.fTOFInfo[i];
592 fHMPIDtrkX = source.fHMPIDtrkX;
593 fHMPIDtrkY = source.fHMPIDtrkY;
594 fHMPIDmipX = source.fHMPIDmipX;
595 fHMPIDmipY = source.fHMPIDmipY;
597 fTPCncls = source.fTPCncls;
598 fTPCnclsF = source.fTPCnclsF;
599 fTPCsignalN = source.fTPCsignalN;
601 fITSncls = source.fITSncls;
602 fITSClusterMap = source.fITSClusterMap;
603 fTRDncls = source.fTRDncls;
604 fTRDncls0 = source.fTRDncls0;
605 fTRDpidQuality = source.fTRDpidQuality;
611 void AliESDtrack::Copy(TObject &obj) const {
613 // this overwrites the virtual TOBject::Copy()
614 // to allow run time copying without casting
617 if(this==&obj)return;
618 AliESDtrack *robj = dynamic_cast<AliESDtrack*>(&obj);
619 if(!robj)return; // not an AliESDtrack
626 void AliESDtrack::AddCalibObject(TObject * object){
628 // add calib object to the list
630 if (!fFriendTrack) fFriendTrack = new AliESDfriendTrack;
631 fFriendTrack->AddCalibObject(object);
634 TObject * AliESDtrack::GetCalibObject(Int_t index){
636 // return calib objct at given position
638 if (!fFriendTrack) return 0;
639 return fFriendTrack->GetCalibObject(index);
643 //_______________________________________________________________________
644 void AliESDtrack::MakeMiniESDtrack(){
645 // Resets everything except
646 // fFlags: Reconstruction status flags
647 // fLabel: Track label
648 // fID: Unique ID of the track
649 // Impact parameter information
650 // fR[AliPID::kSPECIES]: combined "detector response probability"
651 // Running track parameters in the base class (AliExternalTrackParam)
655 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i] = 0;
657 // Reset track parameters constrained to the primary vertex
661 // Reset track parameters at the inner wall of TPC
663 delete fTPCInner;fTPCInner=0;
664 // Reset track parameters at the inner wall of the TRD
668 // Reset ITS track related information
673 for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=0;
676 // Reset TPC related track information
685 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=0;
687 for (Int_t i=0;i<4;i++) fTPCPoints[i] = 0;
688 for (Int_t i=0; i<3;i++) fKinkIndexes[i] = 0;
689 for (Int_t i=0; i<3;i++) fV0Indexes[i] = 0;
691 // Reset TRD related track information
696 for (Int_t i=0;i<kTRDnPlanes;i++) {
699 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i] = 0;
709 // Reset TOF related track information
717 for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i] = 0;
718 for (Int_t i=0;i<3;i++) fTOFLabel[i] = 0;
719 for (Int_t i=0;i<10;i++) fTOFInfo[i] = 0;
721 // Reset HMPID related track information
726 for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i] = 0;
733 fEMCALindex = kEMCALNoMatch;
735 delete fFriendTrack; fFriendTrack = 0;
737 //_______________________________________________________________________
738 Double_t AliESDtrack::GetMass() const {
739 // Returns the mass of the most probable particle type
742 for (Int_t i=0; i<AliPID::kSPECIES; i++) {
743 if (fR[i]>max) {k=i; max=fR[i];}
745 if (k==0) { // dE/dx "crossing points" in the TPC
747 if ((p>0.38)&&(p<0.48))
748 if (fR[0]<fR[3]*10.) return AliPID::ParticleMass(AliPID::kKaon);
749 if ((p>0.75)&&(p<0.85))
750 if (fR[0]<fR[4]*10.) return AliPID::ParticleMass(AliPID::kProton);
753 if (k==1) return AliPID::ParticleMass(AliPID::kMuon);
754 if (k==2||k==-1) return AliPID::ParticleMass(AliPID::kPion);
755 if (k==3) return AliPID::ParticleMass(AliPID::kKaon);
756 if (k==4) return AliPID::ParticleMass(AliPID::kProton);
757 AliWarning("Undefined mass !");
758 return AliPID::ParticleMass(AliPID::kPion);
761 //______________________________________________________________________________
762 Double_t AliESDtrack::E() const
764 // Returns the energy of the particle given its assumed mass.
765 // Assumes the pion mass if the particle can't be identified properly.
769 return TMath::Sqrt(p*p + m*m);
772 //______________________________________________________________________________
773 Double_t AliESDtrack::Y() const
775 // Returns the rapidity of a particle given its assumed mass.
776 // Assumes the pion mass if the particle can't be identified properly.
780 if (e != TMath::Abs(pz)) { // energy was not equal to pz
781 return 0.5*TMath::Log((e+pz)/(e-pz));
782 } else { // energy was equal to pz
787 //_______________________________________________________________________
788 Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags){
790 // This function updates track's running parameters
796 fLabel=t->GetLabel();
798 if (t->IsStartedTimeIntegral()) {
800 Double_t times[10];t->GetIntegratedTimes(times); SetIntegratedTimes(times);
801 SetIntegratedLength(t->GetIntegratedLength());
804 Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
808 case kITSin: case kITSout: case kITSrefit:
810 fITSncls=t->GetNumberOfClusters();
811 index=fFriendTrack->GetITSindices();
812 for (Int_t i=0;i<AliESDfriendTrack::kMaxITScluster;i++) {
813 index[i]=t->GetClusterIndex(i);
815 Int_t l=(index[i] & 0xf0000000) >> 28;
816 SETBIT(fITSClusterMap,l);
819 fITSchi2=t->GetChi2();
820 fITSsignal=t->GetPIDsignal();
821 fITSLabel = t->GetLabel();
824 case kTPCin: case kTPCrefit:
825 fTPCLabel = t->GetLabel();
826 if (flags==kTPCin) fTPCInner=new AliExternalTrackParam(*t);
827 if (!fIp) fIp=new AliExternalTrackParam(*t);
829 fIp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
831 index=fFriendTrack->GetTPCindices();
832 if (flags & kTPCout){
833 if (!fOp) fOp=new AliExternalTrackParam(*t);
835 fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
837 fTPCncls=t->GetNumberOfClusters();
838 fTPCchi2=t->GetChi2();
840 {//prevrow must be declared in separate namespace, otherwise compiler cries:
841 //"jump to case label crosses initialization of `Int_t prevrow'"
843 // for (Int_t i=0;i<fTPCncls;i++)
844 for (Int_t i=0;i<AliESDfriendTrack::kMaxTPCcluster;i++)
846 index[i]=t->GetClusterIndex(i);
847 Int_t idx = index[i];
851 // Piotr's Cluster Map for HBT
852 // ### please change accordingly if cluster array is changing
853 // to "New TPC Tracking" style (with gaps in array)
854 Int_t sect = (idx&0xff000000)>>24;
855 Int_t row = (idx&0x00ff0000)>>16;
856 if (sect > 18) row +=63; //if it is outer sector, add number of inner sectors
858 fTPCClusterMap.SetBitNumber(row,kTRUE);
860 //Fill the gap between previous row and this row with 0 bits
861 //In case ### pleas change it as well - just set bit 0 in case there
862 //is no associated clusters for current "i"
865 prevrow = row;//if previous bit was not assigned yet == this is the first one
868 { //we don't know the order (inner to outer or reverse)
869 //just to be save in case it is going to change
882 for (Int_t j = n+1; j < m; j++)
884 fTPCClusterMap.SetBitNumber(j,kFALSE);
888 // End Of Piotr's Cluster Map for HBT
891 fTPCsignal=t->GetPIDsignal();
894 case kTRDout: case kTRDin: case kTRDrefit:
895 index = fFriendTrack->GetTRDindices();
896 fTRDLabel = t->GetLabel();
897 fTRDchi2 = t->GetChi2();
898 fTRDncls = t->GetNumberOfClusters();
899 for (Int_t i=0;i<6;i++) index[i]=t->GetTrackletIndex(i);
901 fTRDsignal=t->GetPIDsignal();
904 if (!fOp) fOp=new AliExternalTrackParam(*t);
906 fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
907 fTRDncls0 = t->GetNumberOfClusters();
916 AliError("Wrong flag !");
923 //_______________________________________________________________________
924 void AliESDtrack::GetExternalParameters(Double_t &x, Double_t p[5]) const {
925 //---------------------------------------------------------------------
926 // This function returns external representation of the track parameters
927 //---------------------------------------------------------------------
929 for (Int_t i=0; i<5; i++) p[i]=GetParameter()[i];
932 //_______________________________________________________________________
933 void AliESDtrack::GetExternalCovariance(Double_t cov[15]) const {
934 //---------------------------------------------------------------------
935 // This function returns external representation of the cov. matrix
936 //---------------------------------------------------------------------
937 for (Int_t i=0; i<15; i++) cov[i]=AliExternalTrackParam::GetCovariance()[i];
940 //_______________________________________________________________________
941 Bool_t AliESDtrack::GetConstrainedExternalParameters
942 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
943 //---------------------------------------------------------------------
944 // This function returns the constrained external track parameters
945 //---------------------------------------------------------------------
946 if (!fCp) return kFALSE;
947 alpha=fCp->GetAlpha();
949 for (Int_t i=0; i<5; i++) p[i]=fCp->GetParameter()[i];
953 //_______________________________________________________________________
955 AliESDtrack::GetConstrainedExternalCovariance(Double_t c[15]) const {
956 //---------------------------------------------------------------------
957 // This function returns the constrained external cov. matrix
958 //---------------------------------------------------------------------
959 if (!fCp) return kFALSE;
960 for (Int_t i=0; i<15; i++) c[i]=fCp->GetCovariance()[i];
965 AliESDtrack::GetInnerExternalParameters
966 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
967 //---------------------------------------------------------------------
968 // This function returns external representation of the track parameters
969 // at the inner layer of TPC
970 //---------------------------------------------------------------------
971 if (!fIp) return kFALSE;
972 alpha=fIp->GetAlpha();
974 for (Int_t i=0; i<5; i++) p[i]=fIp->GetParameter()[i];
979 AliESDtrack::GetInnerExternalCovariance(Double_t cov[15]) const {
980 //---------------------------------------------------------------------
981 // This function returns external representation of the cov. matrix
982 // at the inner layer of TPC
983 //---------------------------------------------------------------------
984 if (!fIp) return kFALSE;
985 for (Int_t i=0; i<15; i++) cov[i]=fIp->GetCovariance()[i];
990 AliESDtrack::GetOuterExternalParameters
991 (Double_t &alpha, Double_t &x, Double_t p[5]) const {
992 //---------------------------------------------------------------------
993 // This function returns external representation of the track parameters
994 // at the inner layer of TRD
995 //---------------------------------------------------------------------
996 if (!fOp) return kFALSE;
997 alpha=fOp->GetAlpha();
999 for (Int_t i=0; i<5; i++) p[i]=fOp->GetParameter()[i];
1004 AliESDtrack::GetOuterExternalCovariance(Double_t cov[15]) const {
1005 //---------------------------------------------------------------------
1006 // This function returns external representation of the cov. matrix
1007 // at the inner layer of TRD
1008 //---------------------------------------------------------------------
1009 if (!fOp) return kFALSE;
1010 for (Int_t i=0; i<15; i++) cov[i]=fOp->GetCovariance()[i];
1014 Int_t AliESDtrack::GetNcls(Int_t idet) const
1016 // Get number of clusters by subdetector index
1030 if (fTOFindex != -1)
1039 Int_t AliESDtrack::GetClusters(Int_t idet, Int_t *idx) const
1041 // Get cluster index array by subdetector index
1046 ncls = GetITSclusters(idx);
1049 ncls = GetTPCclusters(idx);
1052 ncls = GetTRDclusters(idx);
1055 if (fTOFindex != -1) {
1063 if (fHMPIDcluIdx != 0) {
1064 idx[0] = GetHMPIDcluIdx();
1076 //_______________________________________________________________________
1077 void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
1078 // Returns the array with integrated times for each particle hypothesis
1079 for (Int_t i=0; i<AliPID::kSPECIES; i++) times[i]=fTrackTime[i];
1082 //_______________________________________________________________________
1083 void AliESDtrack::SetIntegratedTimes(const Double_t *times) {
1084 // Sets the array with integrated times for each particle hypotesis
1085 for (Int_t i=0; i<AliPID::kSPECIES; i++) fTrackTime[i]=times[i];
1088 //_______________________________________________________________________
1089 void AliESDtrack::SetITSpid(const Double_t *p) {
1090 // Sets values for the probability of each particle type (in ITS)
1091 SetPIDValues(fITSr,p,AliPID::kSPECIES);
1092 SetStatus(AliESDtrack::kITSpid);
1095 //_______________________________________________________________________
1096 void AliESDtrack::GetITSpid(Double_t *p) const {
1097 // Gets the probability of each particle type (in ITS)
1098 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fITSr[i];
1101 //_______________________________________________________________________
1102 Char_t AliESDtrack::GetITSclusters(Int_t *idx) const {
1103 //---------------------------------------------------------------------
1104 // This function returns indices of the assgined ITS clusters
1105 //---------------------------------------------------------------------
1107 Int_t *index=fFriendTrack->GetITSindices();
1108 for (Int_t i=0; i<AliESDfriendTrack::kMaxITScluster; i++) idx[i]=index[i];
1113 //_______________________________________________________________________
1114 Bool_t AliESDtrack::GetITSModuleIndexInfo(Int_t ilayer,Int_t &idet,Int_t &status,
1115 Float_t &xloc,Float_t &zloc) const {
1116 //----------------------------------------------------------------------
1117 // This function encodes in the module number also the status of cluster association
1118 // "status" can have the following values:
1119 // 1 "found" (cluster is associated),
1120 // 2 "dead" (module is dead from OCDB),
1121 // 3 "skipped" (module or layer forced to be skipped),
1122 // 4 "outinz" (track out of z acceptance),
1123 // 5 "nocls" (no clusters in the road),
1124 // 6 "norefit" (cluster rejected during refit),
1125 // 7 "deadzspd" (holes in z in SPD)
1126 // Also given are the coordinates of the crossing point of track and module
1127 // (in the local module ref. system)
1128 // WARNING: THIS METHOD HAS TO BE SYNCHRONIZED WITH AliITStrackV2::GetModuleIndexInfo()!
1129 //----------------------------------------------------------------------
1131 if(fITSModule[ilayer]==-1) {
1132 AliError("fModule was not set !");
1135 xloc=-99.; zloc=-99.;
1139 Int_t module = fITSModule[ilayer];
1141 idet = Int_t(module/1000000);
1143 module -= idet*1000000;
1145 status = Int_t(module/100000);
1147 module -= status*100000;
1149 Int_t signs = Int_t(module/10000);
1151 module-=signs*10000;
1153 Int_t xInt = Int_t(module/100);
1156 Int_t zInt = module;
1158 if(signs==1) { xInt*=1; zInt*=1; }
1159 if(signs==2) { xInt*=1; zInt*=-1; }
1160 if(signs==3) { xInt*=-1; zInt*=1; }
1161 if(signs==4) { xInt*=-1; zInt*=-1; }
1163 xloc = 0.1*(Float_t)xInt;
1164 zloc = 0.1*(Float_t)zInt;
1166 if(status==4) idet = -1;
1171 //_______________________________________________________________________
1172 UShort_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
1173 //---------------------------------------------------------------------
1174 // This function returns indices of the assgined ITS clusters
1175 //---------------------------------------------------------------------
1177 Int_t *index=fFriendTrack->GetTPCindices();
1178 for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=index[i];
1183 Double_t AliESDtrack::GetTPCdensity(Int_t row0, Int_t row1) const{
1185 // GetDensity of the clusters on given region between row0 and row1
1186 // Dead zone effect takin into acoount
1191 Int_t *index=fFriendTrack->GetTPCindices();
1192 for (Int_t i=row0;i<=row1;i++){
1193 Int_t idx = index[i];
1194 if (idx!=-1) good++; // track outside of dead zone
1197 Float_t density=0.5;
1198 if (good>(row1-row0)*0.5) density = Float_t(found)/Float_t(good);
1202 //_______________________________________________________________________
1203 void AliESDtrack::SetTPCpid(const Double_t *p) {
1204 // Sets values for the probability of each particle type (in TPC)
1205 SetPIDValues(fTPCr,p,AliPID::kSPECIES);
1206 SetStatus(AliESDtrack::kTPCpid);
1209 //_______________________________________________________________________
1210 void AliESDtrack::GetTPCpid(Double_t *p) const {
1211 // Gets the probability of each particle type (in TPC)
1212 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTPCr[i];
1215 //_______________________________________________________________________
1216 UChar_t AliESDtrack::GetTRDclusters(Int_t *idx) const {
1217 //---------------------------------------------------------------------
1218 // This function returns indices of the assgined TRD clusters
1219 //---------------------------------------------------------------------
1221 Int_t *index=fFriendTrack->GetTRDindices();
1222 for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=index[i];
1227 //_______________________________________________________________________
1228 UChar_t AliESDtrack::GetTRDtracklets(Int_t *idx) const {
1229 //---------------------------------------------------------------------
1230 // This function returns indices of the assigned TRD tracklets
1231 //---------------------------------------------------------------------
1233 Int_t *index=fFriendTrack->GetTRDindices();
1234 for (Int_t i=0; i<6/*AliESDfriendTrack::kMaxTRDcluster*/; i++) idx[i]=index[i];
1239 //_______________________________________________________________________
1240 void AliESDtrack::SetTRDpid(const Double_t *p) {
1241 // Sets values for the probability of each particle type (in TRD)
1242 SetPIDValues(fTRDr,p,AliPID::kSPECIES);
1243 SetStatus(AliESDtrack::kTRDpid);
1246 //_______________________________________________________________________
1247 void AliESDtrack::GetTRDpid(Double_t *p) const {
1248 // Gets the probability of each particle type (in TRD)
1249 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTRDr[i];
1252 //_______________________________________________________________________
1253 void AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
1255 // Sets the probability of particle type iSpecies to p (in TRD)
1256 fTRDr[iSpecies] = p;
1259 Double_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
1261 // Returns the probability of particle type iSpecies (in TRD)
1262 return fTRDr[iSpecies];
1265 void AliESDtrack::SetNumberOfTRDslices(Int_t n) {
1266 //Sets the number of slices used for PID
1267 if (fTRDnSlices != 0) return;
1268 fTRDnSlices=kTRDnPlanes*n;
1269 fTRDslices=new Double32_t[fTRDnSlices];
1270 for (Int_t i=0; i<fTRDnSlices; i++) fTRDslices[i]=-1.;
1273 void AliESDtrack::SetTRDslice(Double_t q, Int_t plane, Int_t slice) {
1274 //Sets the charge q in the slice of the plane
1275 Int_t ns=GetNumberOfTRDslices();
1277 AliError("No TRD slices allocated for this track !");
1281 if ((plane<0) || (plane>=kTRDnPlanes)) {
1282 AliError("Wrong TRD plane !");
1285 if ((slice<0) || (slice>=ns)) {
1286 AliError("Wrong TRD slice !");
1289 Int_t n=plane*ns + slice;
1293 Double_t AliESDtrack::GetTRDslice(Int_t plane, Int_t slice) const {
1294 //Gets the charge from the slice of the plane
1295 Int_t ns=GetNumberOfTRDslices();
1297 //AliError("No TRD slices allocated for this track !");
1301 if ((plane<0) || (plane>=kTRDnPlanes)) {
1302 AliError("Wrong TRD plane !");
1305 if ((slice<-1) || (slice>=ns)) {
1306 //AliError("Wrong TRD slice !");
1312 for (Int_t i=0; i<ns; i++) q+=fTRDslices[plane*ns + i];
1316 return fTRDslices[plane*ns + slice];
1320 //_______________________________________________________________________
1321 void AliESDtrack::SetTOFpid(const Double_t *p) {
1322 // Sets the probability of each particle type (in TOF)
1323 SetPIDValues(fTOFr,p,AliPID::kSPECIES);
1324 SetStatus(AliESDtrack::kTOFpid);
1327 //_______________________________________________________________________
1328 void AliESDtrack::SetTOFLabel(const Int_t *p) {
1330 for (Int_t i=0; i<3; i++) fTOFLabel[i]=p[i];
1333 //_______________________________________________________________________
1334 void AliESDtrack::GetTOFpid(Double_t *p) const {
1335 // Gets probabilities of each particle type (in TOF)
1336 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTOFr[i];
1339 //_______________________________________________________________________
1340 void AliESDtrack::GetTOFLabel(Int_t *p) const {
1342 for (Int_t i=0; i<3; i++) p[i]=fTOFLabel[i];
1345 //_______________________________________________________________________
1346 void AliESDtrack::GetTOFInfo(Float_t *info) const {
1348 for (Int_t i=0; i<10; i++) info[i]=fTOFInfo[i];
1351 //_______________________________________________________________________
1352 void AliESDtrack::SetTOFInfo(Float_t*info) {
1354 for (Int_t i=0; i<10; i++) fTOFInfo[i]=info[i];
1359 //_______________________________________________________________________
1360 void AliESDtrack::SetHMPIDpid(const Double_t *p) {
1361 // Sets the probability of each particle type (in HMPID)
1362 SetPIDValues(fHMPIDr,p,AliPID::kSPECIES);
1363 SetStatus(AliESDtrack::kHMPIDpid);
1366 //_______________________________________________________________________
1367 void AliESDtrack::GetHMPIDpid(Double_t *p) const {
1368 // Gets probabilities of each particle type (in HMPID)
1369 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fHMPIDr[i];
1374 //_______________________________________________________________________
1375 void AliESDtrack::SetESDpid(const Double_t *p) {
1376 // Sets the probability of each particle type for the ESD track
1377 SetPIDValues(fR,p,AliPID::kSPECIES);
1378 SetStatus(AliESDtrack::kESDpid);
1381 //_______________________________________________________________________
1382 void AliESDtrack::GetESDpid(Double_t *p) const {
1383 // Gets probability of each particle type for the ESD track
1384 for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fR[i];
1387 //_______________________________________________________________________
1388 Bool_t AliESDtrack::RelateToVertexTPC
1389 (const AliESDVertex *vtx, Double_t b, Double_t maxd) {
1391 // Try to relate the TPC-only track paramters to the vertex "vtx",
1392 // if the (rough) transverse impact parameter is not bigger then "maxd".
1393 // Magnetic field is "b" (kG).
1395 // a) The TPC-only paramters are extapolated to the DCA to the vertex.
1396 // b) The impact parameters and their covariance matrix are calculated.
1399 if (!fTPCInner) return kFALSE;
1400 if (!vtx) return kFALSE;
1402 Double_t dz[2],cov[3];
1403 if (!fTPCInner->PropagateToDCA(vtx, b, maxd, dz, cov)) return kFALSE;
1414 //_______________________________________________________________________
1415 Bool_t AliESDtrack::RelateToVertex
1416 (const AliESDVertex *vtx, Double_t b, Double_t maxd) {
1418 // Try to relate this track to the vertex "vtx",
1419 // if the (rough) transverse impact parameter is not bigger then "maxd".
1420 // Magnetic field is "b" (kG).
1422 // a) The track gets extapolated to the DCA to the vertex.
1423 // b) The impact parameters and their covariance matrix are calculated.
1424 // c) An attempt to constrain this track to the vertex is done.
1426 // In the case of success, the returned value is kTRUE
1427 // (otherwise, it's kFALSE)
1430 if (!vtx) return kFALSE;
1432 Double_t dz[2],cov[3];
1433 if (!PropagateToDCA(vtx, b, maxd, dz, cov)) return kFALSE;
1441 Double_t covar[6]; vtx->GetCovMatrix(covar);
1442 Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
1443 Double_t c[3]={covar[2],0.,covar[5]};
1445 Double_t chi2=GetPredictedChi2(p,c);
1446 if (chi2>77.) return kFALSE;
1449 fCp=new AliExternalTrackParam(*this);
1451 if (!fCp->Update(p,c)) {delete fCp; fCp=0; return kFALSE;}
1457 //_______________________________________________________________________
1458 void AliESDtrack::Print(Option_t *) const {
1459 // Prints info on the track
1461 printf("ESD track info\n") ;
1462 Double_t p[AliPID::kSPECIESN] ;
1464 if( IsOn(kITSpid) ){
1465 printf("From ITS: ") ;
1467 for(index = 0 ; index < AliPID::kSPECIES; index++)
1468 printf("%f, ", p[index]) ;
1469 printf("\n signal = %f\n", GetITSsignal()) ;
1471 if( IsOn(kTPCpid) ){
1472 printf("From TPC: ") ;
1474 for(index = 0 ; index < AliPID::kSPECIES; index++)
1475 printf("%f, ", p[index]) ;
1476 printf("\n signal = %f\n", GetTPCsignal()) ;
1478 if( IsOn(kTRDpid) ){
1479 printf("From TRD: ") ;
1481 for(index = 0 ; index < AliPID::kSPECIES; index++)
1482 printf("%f, ", p[index]) ;
1483 printf("\n signal = %f\n", GetTRDsignal()) ;
1485 if( IsOn(kTOFpid) ){
1486 printf("From TOF: ") ;
1488 for(index = 0 ; index < AliPID::kSPECIES; index++)
1489 printf("%f, ", p[index]) ;
1490 printf("\n signal = %f\n", GetTOFsignal()) ;
1492 if( IsOn(kHMPIDpid) ){
1493 printf("From HMPID: ") ;
1495 for(index = 0 ; index < AliPID::kSPECIES; index++)
1496 printf("%f, ", p[index]) ;
1497 printf("\n signal = %f\n", GetHMPIDsignal()) ;
1503 // Draw functionality
1504 // Origin: Marian Ivanov, Marian.Ivanov@cern.ch
1506 void AliESDtrack::FillPolymarker(TPolyMarker3D *pol, Float_t magF, Float_t minR, Float_t maxR, Float_t stepR){
1508 // Fill points in the polymarker
1511 arrayRef.AddLast(new AliExternalTrackParam(*this));
1512 if (fIp) arrayRef.AddLast(new AliExternalTrackParam(*fIp));
1513 if (fOp) arrayRef.AddLast(new AliExternalTrackParam(*fOp));
1515 Double_t mpos[3]={0,0,0};
1516 Int_t entries=arrayRef.GetEntries();
1517 for (Int_t i=0;i<entries;i++){
1519 ((AliExternalTrackParam*)arrayRef.At(i))->GetXYZ(pos);
1520 mpos[0]+=pos[0]/entries;
1521 mpos[1]+=pos[1]/entries;
1522 mpos[2]+=pos[2]/entries;
1524 // Rotate to the mean position
1526 Float_t fi= TMath::ATan2(mpos[1],mpos[0]);
1527 for (Int_t i=0;i<entries;i++){
1528 Bool_t res = ((AliExternalTrackParam*)arrayRef.At(i))->Rotate(fi);
1529 if (!res) delete arrayRef.RemoveAt(i);
1532 for (Double_t r=minR; r<maxR; r+=stepR){
1534 Double_t mlpos[3]={0,0,0};
1535 for (Int_t i=0;i<entries;i++){
1536 Double_t point[3]={0,0,0};
1537 AliExternalTrackParam *param = ((AliExternalTrackParam*)arrayRef.At(i));
1538 if (!param) continue;
1539 if (param->GetXYZAt(r,magF,point)){
1540 Double_t weight = 1./(10.+(r-param->GetX())*(r-param->GetX()));
1542 mlpos[0]+=point[0]*weight;
1543 mlpos[1]+=point[1]*weight;
1544 mlpos[2]+=point[2]*weight;
1551 pol->SetPoint(counter,mlpos[0],mlpos[1], mlpos[2]);
1552 printf("xyz\t%f\t%f\t%f\n",mlpos[0], mlpos[1],mlpos[2]);