#include "AliKalmanTrack.h"
#include "AliLog.h"
#include "AliTrackPointArray.h"
+#include "TPolyMarker3D.h"
ClassImp(AliESDtrack)
fITSClusterMap(0),
fTRDncls(0),
fTRDncls0(0),
- fTRDpidQuality(0)
+ fTRDpidQuality(0),
+ fTRDnSlices(0),
+ fTRDslices(0x0)
+
{
//
// The default ESD constructor
//
- Int_t i, j;
+ Int_t i;
for (i=0; i<AliPID::kSPECIES; i++) {
fTrackTime[i]=0.;
fR[i]=0.;
for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
for (i=0; i<3; i++) { fV0Indexes[i]=0;}
- for (i=0;i<kNPlane;i++) {
- for (j=0;j<kNSlice;j++) {
- fTRDsignals[i][j]=0.;
- }
+ for (i=0;i<kTRDnPlanes;i++) {
fTRDTimBin[i]=0;
}
for (i=0;i<4;i++) {fTPCPoints[i]=0;}
fITSClusterMap(track.fITSClusterMap),
fTRDncls(track.fTRDncls),
fTRDncls0(track.fTRDncls0),
- fTRDpidQuality(track.fTRDpidQuality)
+ fTRDpidQuality(track.fTRDpidQuality),
+ fTRDnSlices(track.fTRDnSlices),
+ fTRDslices(0x0)
{
//
//copy constructor
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<kNPlane;i++) {
- for (Int_t j=0;j<kNSlice;j++) {
- fTRDsignals[i][j]=track.fTRDsignals[i][j];
- }
+ for (Int_t i=0;i<kTRDnPlanes;i++) {
fTRDTimBin[i]=track.fTRDTimBin[i];
}
+
+ if (fTRDnSlices) {
+ fTRDslices=new Double32_t[fTRDnSlices];
+ for (Int_t i=0; i<fTRDnSlices; i++) fTRDslices[i]=track.fTRDslices[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];
fITSClusterMap(0),
fTRDncls(0),
fTRDncls0(0),
- fTRDpidQuality(0)
+ fTRDpidQuality(0),
+ fTRDnSlices(0),
+ fTRDslices(0x0)
{
//
// ESD track from TParticle
//
// Reset all the arrays
- Int_t i, j;
+ Int_t i;
for (i=0; i<AliPID::kSPECIES; i++) {
fTrackTime[i]=0.;
fR[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.;
- }
+ for (i=0;i<kTRDnPlanes;i++) {
fTRDTimBin[i]=0;
}
for (i=0;i<4;i++) {fTPCPoints[i]=0;}
delete fOp;
delete fCp;
delete fFriendTrack;
+ if(fTRDnSlices)
+ delete[] fTRDslices;
+}
+
+AliESDtrack &AliESDtrack::operator=(const AliESDtrack &source){
+
+
+ if(&source == this) return *this;
+ AliExternalTrackParam::operator=(source);
+
+
+ if(source.fCp){
+ // we have the trackparam: assign or copy construct
+ if(fCp)*fCp = *source.fCp;
+ else fCp = new AliExternalTrackParam(*source.fCp);
+ }
+ else{
+ // no track param delete the old one
+ if(fCp)delete fCp;
+ fCp = 0;
+ }
+
+ if(source.fIp){
+ // we have the trackparam: assign or copy construct
+ if(fIp)*fIp = *source.fIp;
+ else fIp = new AliExternalTrackParam(*source.fIp);
+ }
+ else{
+ // no track param delete the old one
+ if(fIp)delete fIp;
+ fIp = 0;
+ }
+
+
+ if(source.fTPCInner){
+ // we have the trackparam: assign or copy construct
+ if(fTPCInner) *fTPCInner = *source.fTPCInner;
+ else fTPCInner = new AliExternalTrackParam(*source.fTPCInner);
+ }
+ else{
+ // no track param delete the old one
+ if(fTPCInner)delete fTPCInner;
+ fTPCInner = 0;
+ }
+
+
+ if(source.fOp){
+ // we have the trackparam: assign or copy construct
+ if(fOp) *fOp = *source.fOp;
+ else fOp = new AliExternalTrackParam(*source.fOp);
+ }
+ else{
+ // no track param delete the old one
+ if(fOp)delete fOp;
+ fOp = 0;
+ }
+
+ // copy also the friend track
+ // use copy constructor
+ if(source.fFriendTrack){
+ // we have the trackparam: assign or copy construct
+ delete fFriendTrack; fFriendTrack=new AliESDfriendTrack(*source.fFriendTrack);
+ }
+ else{
+ // no track param delete the old one
+ delete fFriendTrack; fFriendTrack= 0;
+ }
+
+ fTPCClusterMap = source.fTPCClusterMap;
+ fTPCSharedMap = source.fTPCSharedMap;
+ // the simple stuff
+ fFlags = source.fFlags;
+ fID = source.fID;
+ fLabel = source.fLabel;
+ fITSLabel = source.fITSLabel;
+ for(int i = 0; i< 12;++i){
+ fITSModule[i] = source.fITSModule[i];
+ }
+ fTPCLabel = source.fTPCLabel;
+ fTRDLabel = source.fTRDLabel;
+ for(int i = 0; i< 3;++i){
+ fTOFLabel[i] = source.fTOFLabel[i];
+ }
+ fTOFCalChannel = source.fTOFCalChannel;
+ fTOFindex = source.fTOFindex;
+ fHMPIDqn = source.fHMPIDqn;
+ fHMPIDcluIdx = source.fHMPIDcluIdx;
+ fEMCALindex = source.fEMCALindex;
+
+ for(int i = 0; i< 3;++i){
+ fKinkIndexes[i] = source.fKinkIndexes[i];
+ fV0Indexes[i] = source.fV0Indexes[i];
+ }
+
+ for(int i = 0; i< AliPID::kSPECIES;++i){
+ fR[i] = source.fR[i];
+ fITSr[i] = source.fITSr[i];
+ fTPCr[i] = source.fTPCr[i];
+ fTRDr[i] = source.fTRDr[i];
+ fTOFr[i] = source.fTOFr[i];
+ fHMPIDr[i] = source.fHMPIDr[i];
+ fTrackTime[i] = source.fTrackTime[i];
+ }
+
+ fHMPIDtrkTheta = source.fHMPIDtrkTheta;
+ fHMPIDtrkPhi = source.fHMPIDtrkPhi;
+ fHMPIDsignal = source.fHMPIDsignal;
+
+
+ fTrackLength = source. fTrackLength;
+ fD = source.fD;
+ fZ = source.fZ;
+ fCdd = source.fCdd;
+ fCdz = source.fCdz;
+ fCzz = source.fCzz;
+
+ fCchi2 = source.fCchi2;
+ fITSchi2 = source.fITSchi2;
+ fTPCchi2 = source.fTPCchi2;
+ fTRDchi2 = source.fTRDchi2;
+ fTOFchi2 = source.fTOFchi2;
+ fHMPIDchi2 = source.fHMPIDchi2;
+
+
+ fITSsignal = source.fITSsignal;
+ fTPCsignal = source.fTPCsignal;
+ fTPCsignalS = source.fTPCsignalS;
+ for(int i = 0; i< 4;++i){
+ fTPCPoints[i] = source.fTPCPoints[i];
+ }
+ fTRDsignal = source.fTRDsignal;
+
+ for(int i = 0;i < kTRDnPlanes;++i){
+ fTRDTimBin[i] = source.fTRDTimBin[i];
+ }
+
+ if(fTRDnSlices)
+ delete[] fTRDslices;
+ fTRDslices=0;
+ fTRDnSlices=source.fTRDnSlices;
+ if (fTRDnSlices) {
+ fTRDslices=new Double32_t[fTRDnSlices];
+ for(int j = 0;j < fTRDnSlices;++j) fTRDslices[j] = source.fTRDslices[j];
+ }
+
+ fTRDQuality = source.fTRDQuality;
+ fTRDBudget = source.fTRDBudget;
+ fTOFsignal = source.fTOFsignal;
+ fTOFsignalToT = source.fTOFsignalToT;
+ fTOFsignalRaw = source.fTOFsignalRaw;
+ fTOFsignalDz = source.fTOFsignalDz;
+
+ for(int i = 0;i<10;++i){
+ fTOFInfo[i] = source.fTOFInfo[i];
+ }
+
+ fHMPIDtrkX = source.fHMPIDtrkX;
+ fHMPIDtrkY = source.fHMPIDtrkY;
+ fHMPIDmipX = source.fHMPIDmipX;
+ fHMPIDmipY = source.fHMPIDmipY;
+
+ fTPCncls = source.fTPCncls;
+ fTPCnclsF = source.fTPCnclsF;
+ fTPCsignalN = source.fTPCsignalN;
+
+ fITSncls = source.fITSncls;
+ fITSClusterMap = source.fITSClusterMap;
+ fTRDncls = source.fTRDncls;
+ fTRDncls0 = source.fTRDncls0;
+ fTRDpidQuality = source.fTRDpidQuality;
+ return *this;
+}
+
+
+
+void AliESDtrack::Copy(TObject &obj) const {
+
+ // this overwrites the virtual TOBject::Copy()
+ // to allow run time copying without casting
+ // in AliESDEvent
+
+ if(this==&obj)return;
+ AliESDtrack *robj = dynamic_cast<AliESDtrack*>(&obj);
+ if(!robj)return; // not an AliESDtrack
+ *robj = *this;
+
}
+
+
void AliESDtrack::AddCalibObject(TObject * object){
//
// add calib object to the list
fTRDncls = 0;
fTRDncls0 = 0;
fTRDsignal = 0;
- for (Int_t i=0;i<kNPlane;i++) {
- for (Int_t j=0;j<kNSlice;j++) {
- fTRDsignals[i][j] = 0;
- }
+ for (Int_t i=0;i<kTRDnPlanes;i++) {
fTRDTimBin[i] = 0;
}
for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i] = 0;
fTRDLabel = 0;
fTRDQuality = 0;
fTRDpidQuality = 0;
+ if(fTRDnSlices)
+ delete[] fTRDslices;
+ fTRDslices=0x0;
+ fTRDnSlices=0;
fTRDBudget = 0;
// Reset TOF related track information
break;
case kTRDout: case kTRDin: case kTRDrefit:
- index=fFriendTrack->GetTRDindices();
+ index = fFriendTrack->GetTRDindices();
fTRDLabel = t->GetLabel();
- fTRDchi2=t->GetChi2();
- fTRDncls=6;//t->GetNumberOfTracklets(); //t->GetNumberOfClusters();
- //for (Int_t i=0;i<fTRDncls;i++) index[i]=t->GetClusterIndex(i);
+ fTRDchi2 = t->GetChi2();
+ fTRDncls = t->GetNumberOfClusters();
for (Int_t i=0;i<6;i++) index[i]=t->GetTrackletIndex(i);
fTRDsignal=t->GetPIDsignal();
ncls = 1;
}
break;
+ case 4: //PHOS
+ break;
+ case 5:
+ if (fHMPIDcluIdx != 0) {
+ idx[0] = GetHMPIDcluIdx();
+ ncls = 1;
+ }
+ break;
+ case 6: //EMCAL
+ break;
default:
break;
}
return fTRDr[iSpecies];
}
+void AliESDtrack::SetNumberOfTRDslices(Int_t n) {
+ //Sets the number of slices used for PID
+ if (fTRDnSlices != 0) return;
+ fTRDnSlices=kTRDnPlanes*n;
+ fTRDslices=new Double32_t[fTRDnSlices];
+ for (Int_t i=0; i<fTRDnSlices; 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) {
+ AliError("No TRD slices allocated for this track !");
+ return;
+ }
+
+ if ((plane<0) || (plane>=kTRDnPlanes)) {
+ AliError("Wrong TRD plane !");
+ return;
+ }
+ if ((slice<0) || (slice>=ns)) {
+ AliError("Wrong TRD slice !");
+ return;
+ }
+ Int_t n=plane*ns + slice;
+ 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.;
+ }
+ if ((slice<-1) || (slice>=ns)) {
+ //AliError("Wrong TRD slice !");
+ return -1.;
+ }
+
+ if (slice==-1) {
+ Double_t q=0.;
+ for (Int_t i=0; i<ns; i++) q+=fTRDslices[plane*ns + i];
+ return q/ns;
+ }
+
+ return fTRDslices[plane*ns + slice];
+}
+
+
//_______________________________________________________________________
void AliESDtrack::SetTOFpid(const Double_t *p) {
// Sets the probability of each particle type (in TOF)
GetTRDpid(p) ;
for(index = 0 ; index < AliPID::kSPECIES; index++)
printf("%f, ", p[index]) ;
- printf("\n signal = %f\n", GetTRDsignal()) ;
+ printf("\n signal = %f\n", GetTRDsignal()) ;
}
if( IsOn(kTOFpid) ){
printf("From TOF: ") ;
}
}
+
+//
+// Draw functionality
+// Origin: Marian Ivanov, Marian.Ivanov@cern.ch
+//
+void AliESDtrack::FillPolymarker(TPolyMarker3D *pol, Float_t magF, Float_t minR, Float_t maxR, Float_t stepR){
+ //
+ // Fill points in the polymarker
+ //
+ TObjArray arrayRef;
+ arrayRef.AddLast(new AliExternalTrackParam(*this));
+ if (fIp) arrayRef.AddLast(new AliExternalTrackParam(*fIp));
+ if (fOp) arrayRef.AddLast(new AliExternalTrackParam(*fOp));
+ //
+ Double_t mpos[3]={0,0,0};
+ Int_t entries=arrayRef.GetEntries();
+ for (Int_t i=0;i<entries;i++){
+ Double_t pos[3];
+ ((AliExternalTrackParam*)arrayRef.At(i))->GetXYZ(pos);
+ mpos[0]+=pos[0]/entries;
+ mpos[1]+=pos[1]/entries;
+ mpos[2]+=pos[2]/entries;
+ }
+ // Rotate to the mean position
+ //
+ Float_t fi= TMath::ATan2(mpos[1],mpos[0]);
+ for (Int_t i=0;i<entries;i++){
+ Bool_t res = ((AliExternalTrackParam*)arrayRef.At(i))->Rotate(fi);
+ if (!res) delete arrayRef.RemoveAt(i);
+ }
+ Int_t counter=0;
+ for (Double_t r=minR; r<maxR; r+=stepR){
+ Double_t sweight=0;
+ Double_t mlpos[3]={0,0,0};
+ for (Int_t i=0;i<entries;i++){
+ Double_t point[3]={0,0,0};
+ AliExternalTrackParam *param = ((AliExternalTrackParam*)arrayRef.At(i));
+ if (!param) continue;
+ if (param->GetXYZAt(r,magF,point)){
+ Double_t weight = 1./(10.+(r-param->GetX())*(r-param->GetX()));
+ sweight+=weight;
+ mlpos[0]+=point[0]*weight;
+ mlpos[1]+=point[1]*weight;
+ mlpos[2]+=point[2]*weight;
+ }
+ }
+ if (sweight>0){
+ mlpos[0]/=sweight;
+ mlpos[1]/=sweight;
+ mlpos[2]/=sweight;
+ pol->SetPoint(counter,mlpos[0],mlpos[1], mlpos[2]);
+ printf("xyz\t%f\t%f\t%f\n",mlpos[0], mlpos[1],mlpos[2]);
+ counter++;
+ }
+ }
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff