#include <TMath.h>
#include <TParticle.h>
+#include <TDatabasePDG.h>
#include "AliESDVertex.h"
#include "AliESDtrack.h"
fIp(0),
fTPCInner(0),
fOp(0),
+ fHMPIDp(0),
fFriendTrack(new AliESDfriendTrack()),
fTPCClusterMap(159),//number of padrows
fTPCSharedMap(159),//number of padrows
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<10;i++) {fTOFInfo[i]=0;}
fIp(0),
fTPCInner(0),
fOp(0),
+ fHMPIDp(0),
fFriendTrack(0),
fTPCClusterMap(track.fTPCClusterMap),
fTPCSharedMap(track.fTPCSharedMap),
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));
}
fIp(0),
fTPCInner(0),
fOp(0),
+ fHMPIDp(0),
fFriendTrack(0),
fTPCClusterMap(159),//number of padrows
fTPCSharedMap(159),//number of padrows
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<10;i++) {fTOFInfo[i]=0;}
fIp(0),
fTPCInner(0),
fOp(0),
+ fHMPIDp(0),
fFriendTrack(0),
fTPCClusterMap(159),//number of padrows
fTPCSharedMap(159),//number of padrows
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<10;i++) {fTOFInfo[i]=0;}
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(fOp) *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){
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){
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;
Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
if (flags==kITSout) fFriendTrack->SetITSOut(*t);
if (flags==kTPCout) fFriendTrack->SetTPCOut(*t);
- if (flags==kTRDin || flags==kTRDrefit) fFriendTrack->SetTRDIn(*t);
+ if (flags==kTRDrefit) fFriendTrack->SetTRDIn(*t);
switch (flags) {
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;
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
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) {
+ AliError("No TRD info allocated for this track !");
+ return -1.;
+ }
+ if ((plane<0) || (plane>=kTRDnPlanes)) {
+ AliError("Info for TRD plane not available!");
+ 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;
}
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];
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff