// Author: Anders Vestbo <mailto:vestbo@fi.uib.no>
//*-- Copyright © ALICE HLT Group
-#include "AliL3StandardIncludes.h"
+/** \class AliL3Evaluate
+<pre>
+//_____________________________________________________________
+// AliL3Evaluate
+//
+// Evaluation class for tracking; plots, efficiencies etc..
+//
+</pre>
+*/
+
+#include <TObject.h>
#include <TFile.h>
#include <TH1.h>
#include <TParticle.h>
#include <TTree.h>
#include <TClonesArray.h>
+#include <TTree.h>
+#include <TNtuple.h>
#include <AliRun.h>
#include <AliSimDigits.h>
#include <AliComplexCluster.h>
#include <AliStack.h>
-#if __GNUC__ == 3
-#include <fstream>
-#include <iosfwd>
-#else
-#include <fstream.h>
-#endif
-
+#include "AliL3StandardIncludes.h"
#include "AliL3Logging.h"
#include "AliL3Transform.h"
#include "AliL3SpacePointData.h"
#include "AliL3Evaluate.h"
#if __GNUC__ == 3
+#include <iosfwd>
using namespace std;
#endif
-/** \class AliL3Evaluate
-<pre>
-//_____________________________________________________________
-// AliL3Evaluate
-//
-// Evaluation class for tracking; plots, efficiencies etc..
-//
-</pre>
-*/
-
ClassImp(AliL3Evaluate)
AliL3Evaluate::AliL3Evaluate()
-{
+{
+ //constructor
Clear();
}
-AliL3Evaluate::AliL3Evaluate(Char_t *datapath,Int_t min_clusters,Int_t minhits,Double_t minpt,Double_t maxpt,Int_t *slice)
-{
+AliL3Evaluate::AliL3Evaluate(Char_t *datapath,Int_t minclusters,Int_t minhits,Double_t minpt,Double_t maxpt,Int_t *slice)
+{
+ //constructor
Clear();
if(slice)
}
sprintf(fPath,"%s",datapath);
- fMinPointsOnTrack = min_clusters;
+ fMinPointsOnTrack = minclusters;
fMinHitsFromParticle = minhits;
fMinGoodPt = minpt;
fMaxGoodPt = maxpt;
}
AliL3Evaluate::~AliL3Evaluate()
-{
+{
+ //destructor
if(fGoodTracks) delete[] fGoodTracks;
if(fTracks) delete fTracks;
if(fPtRes) delete fPtRes;
}
void AliL3Evaluate::Clear()
-{
+{
+ //clear
fTracks = 0;
fMinSlice=0;
fMaxSlice=0;
}
void AliL3Evaluate::LoadData(Int_t event,Bool_t sp)
-{
+{
+ //load cluster points
Char_t fname[1024];
for(Int_t s=fMinSlice; s<=fMaxSlice; s++)
}
void AliL3Evaluate::AssignPIDs()
-{
+{
+ //assign pid
if(!fTracks) return;
fTracks->QSort();
LOG(AliL3Log::kDebug,"AliL3Evaluate::AssignPIDs","Track Loop")
}
void AliL3Evaluate::AssignIDs()
-{
+{
//Assign MC id to the tracks.
#ifndef do_mc
cerr<<"AliL3Evaluate::AssignIDs() : You need to compile with the do_mc flag!"<<endl;
}
Float_t AliL3Evaluate::GetTrackPID(AliL3Track *track)
-{
+{
+ //get track pid
track->CalculateHelix();
// Track dEdx
Int_t nc=track->GetNHits();
return trackDEdx;
}
-struct S {Int_t lab; Int_t max;};
-Int_t AliL3Evaluate::GetMCTrackLabel(AliL3Track *track){
+Int_t AliL3Evaluate::GetMCTrackLabel(AliL3Track *track)
+{
//Returns the MCtrackID of the belonging clusters.
//If MCLabel < 0, means that track is fake.
//Definitions are identical to offline.
#ifdef do_mc
- Int_t num_of_clusters = track->GetNumberOfPoints();
- S *s=new S[num_of_clusters];
+ Int_t numofclusters = track->GetNumberOfPoints();
+ AliS *s=new AliS[numofclusters];
Int_t i;
- for (i=0; i<num_of_clusters; i++) s[i].lab=s[i].max=0;
+ for (i=0; i<numofclusters; i++) s[i].flab=s[i].fmax=0;
UInt_t *hitnum = track->GetHitNumbers();
UInt_t id;
Int_t lab=123456789;
- for (i=0; i<num_of_clusters; i++)
+ for (i=0; i<numofclusters; i++)
{
//Tricks to get the clusters belonging to this track:
id = hitnum[i];
lab=points[pos].fTrackID[0];
Int_t j;
- for (j=0; j<num_of_clusters; j++)
- if (s[j].lab==lab || s[j].max==0) break;
- s[j].lab=lab;
- s[j].max++;
+ for (j=0; j<numofclusters; j++)
+ if (s[j].flab==lab || s[j].fmax==0) break;
+ s[j].flab=lab;
+ s[j].fmax++;
}
Int_t max=0;
- for (i=0; i<num_of_clusters; i++)
- if (s[i].max>max) {max=s[i].max; lab=s[i].lab;}
+ for (i=0; i<numofclusters; i++)
+ if (s[i].fmax>max) {max=s[i].fmax; lab=s[i].flab;}
if(lab == -1)
return -1; //If most clusters is -1, this is a noise track.
delete[] s;
- for (i=0; i<num_of_clusters; i++)
+ for (i=0; i<numofclusters; i++)
{
id = hitnum[i];
Int_t slice = (id>>25) & 0x7f;
//Check if more than 10% of the clusters were assigned incorrectly:
- if (1.-Float_t(max)/num_of_clusters > fMaxFalseClusters)
+ if (1.-Float_t(max)/numofclusters > fMaxFalseClusters)
{
return -lab;
}
else //Check if at least half of the 10% innermost clusters are assigned correctly.
{
- Int_t tail=Int_t(0.10*num_of_clusters);
+ Int_t tail=Int_t(0.10*numofclusters);
max=0;
for (i=1; i<=tail; i++)
{
- id = hitnum[num_of_clusters - i];
+ id = hitnum[numofclusters - i];
Int_t slice = (id>>25) & 0x7f;
Int_t patch = (id>>22) & 0x7;
UInt_t pos = id&0x3fffff;
if(fGoodTracks)
delete [] fGoodTracks;
fGoodGen=0;
- fGoodTracks = new GoodTrack[MaxTracks];
+ fGoodTracks = new AliGoodTrack[MaxTracks];
if(fStandardComparison){
- while (in>>fGoodTracks[fGoodGen].label>>fGoodTracks[fGoodGen].code>>
- fGoodTracks[fGoodGen].px>>fGoodTracks[fGoodGen].py>>fGoodTracks[fGoodGen].pz>>
- fGoodTracks[fGoodGen].x>>fGoodTracks[fGoodGen].y>>fGoodTracks[fGoodGen].z)
+ while (in>>fGoodTracks[fGoodGen].flabel>>fGoodTracks[fGoodGen].fcode>>
+ fGoodTracks[fGoodGen].fpx>>fGoodTracks[fGoodGen].fpy>>fGoodTracks[fGoodGen].fpz>>
+ fGoodTracks[fGoodGen].fx>>fGoodTracks[fGoodGen].fy>>fGoodTracks[fGoodGen].fz)
{
- fGoodTracks[fGoodGen].nhits=-1;
- fGoodTracks[fGoodGen].sector=-1;
+ fGoodTracks[fGoodGen].fnhits=-1;
+ fGoodTracks[fGoodGen].fsector=-1;
fGoodGen++;
if (fGoodGen==MaxTracks)
{
}
}
} else {
- while (in>>fGoodTracks[fGoodGen].label>>fGoodTracks[fGoodGen].code>>
- fGoodTracks[fGoodGen].px>>fGoodTracks[fGoodGen].py>>fGoodTracks[fGoodGen].pz>>
- fGoodTracks[fGoodGen].x>>fGoodTracks[fGoodGen].y >>fGoodTracks[fGoodGen].z>>fGoodTracks[fGoodGen].nhits>>fGoodTracks[fGoodGen].sector)
+ while (in>>fGoodTracks[fGoodGen].flabel>>fGoodTracks[fGoodGen].fcode>>
+ fGoodTracks[fGoodGen].fpx>>fGoodTracks[fGoodGen].fpy>>fGoodTracks[fGoodGen].fpz>>
+ fGoodTracks[fGoodGen].fx>>fGoodTracks[fGoodGen].fy >>fGoodTracks[fGoodGen].fz>>
+ fGoodTracks[fGoodGen].fnhits>>fGoodTracks[fGoodGen].fsector)
{
fGoodGen++;
if (fGoodGen==MaxTracks)
}
}
-//has to be modified for fakes.
-
void AliL3Evaluate::FillEffHistos()
-{
+{
+ //has to be modified for fakes.
+
if(!fGoodTracks)
{
cerr<<"AliL3Evaluate::FillEffHistos : No good tracks"<<endl;
{
//cout<<"Checking particle "<<i<<endl;
if(!fStandardComparison)
- if(fGoodTracks[i].nhits < fMinHitsFromParticle) continue;
- Float_t ptg = TMath::Sqrt(fGoodTracks[i].px*fGoodTracks[i].px + fGoodTracks[i].py*fGoodTracks[i].py);
+ if(fGoodTracks[i].fnhits < fMinHitsFromParticle) continue;
+ Float_t ptg = TMath::Sqrt(fGoodTracks[i].fpx*fGoodTracks[i].fpx + fGoodTracks[i].fpy*fGoodTracks[i].fpy);
if(ptg < fMinGoodPt || ptg > fMaxGoodPt) continue;
- Float_t pzg=fGoodTracks[i].pz;
+ Float_t pzg=fGoodTracks[i].fpz;
Float_t dipangle=TMath::ATan2(pzg,ptg)*180./TMath::Pi();
//If we are only considering tracks on one side of the TPC:
Int_t tracklabel;
tracklabel = track->GetMCid();
- if(TMath::Abs(tracklabel) != fGoodTracks[i].label) continue;
+ if(TMath::Abs(tracklabel) != fGoodTracks[i].flabel) continue;
found=1;
Float_t pt=track->GetPt();
- if(tracklabel == fGoodTracks[i].label)
+ if(tracklabel == fGoodTracks[i].flabel)
{
fNFoundTracksPt->Fill(ptg);
fNFoundTracksEta->Fill(dipangle);
for(Int_t i=0; i<fGoodGen; i++)
{
if(!fStandardComparison)
- if(fGoodTracks[i].nhits < fMinHitsFromParticle) continue;
- Double_t ptg=TMath::Sqrt(fGoodTracks[i].px*fGoodTracks[i].px + fGoodTracks[i].py*fGoodTracks[i].py);
+ if(fGoodTracks[i].fnhits < fMinHitsFromParticle) continue;
+ Double_t ptg=TMath::Sqrt(fGoodTracks[i].fpx*fGoodTracks[i].fpx + fGoodTracks[i].fpy*fGoodTracks[i].fpy);
if(ptg < fMinGoodPt || ptg > fMaxGoodPt) continue;
- Double_t pzg=fGoodTracks[i].pz;
+ Double_t pzg=fGoodTracks[i].fpz;
Float_t dipangle=TMath::ATan2(pzg,ptg)*180./TMath::Pi();
//printf("filling particle with pt %f and dipangle %f\n",ptg,dipangle);
fNGoodTracksPt->Fill(ptg);
//Float_t pt=track->GetPt();
//fPtRes->Fill((pt-ptg)/ptg*100.);
//fNtuppel->Fill(ptg,pt,nHits);
-
}
}
void AliL3Evaluate::CalcEffHistos()
-{
+{
+ //calc eff histos
Stat_t ngood=fNGoodTracksPt->GetEntries();
Stat_t nfound=fNFoundTracksPt->GetEntries();
}
TNtuple *AliL3Evaluate::GetNtuple()
-{
+{
+ //get ntuple
if(!fNtupleRes)
{
fNtupleRes = new TNtuple("ntuppel","Residuals","residual_trans:residual_long:zHit:pt:dipangle:beta:padrow:nHits");
}
void AliL3Evaluate::CalculateResiduals()
-{
-
+{
+ //calculate residuals
TNtuple *ntuppel = GetNtuple();
for(Int_t i=0; i<fTracks->GetNTracks(); i++)
continue;
}
- Float_t xyz_cross[3] = {track->GetPointX(),track->GetPointY(),track->GetPointZ()};
- //AliL3Transform::Global2Local(xyz_cross,slice,kTRUE);
- AliL3Transform::Global2LocHLT(xyz_cross,slice);
+ Float_t xyzcross[3] = {track->GetPointX(),track->GetPointY(),track->GetPointZ()};
+ //AliL3Transform::Global2Local(xyzcross,slice,kTRUE);
+ AliL3Transform::Global2LocHLT(xyzcross,slice);
Double_t beta = track->GetCrossingAngle(padrow,slice);
- Double_t yres = xyz_cross[1] - xyz[1];
- Double_t zres = xyz_cross[2] - xyz[2];
+ Double_t yres = xyzcross[1] - xyz[1];
+ Double_t zres = xyzcross[2] - xyz[2];
Double_t dipangle = atan(track->GetTgl());
- ntuppel->Fill(yres,zres,xyz_cross[2],track->GetPt(),dipangle,beta,padrow,track->GetNumberOfPoints());
+ ntuppel->Fill(yres,zres,xyzcross[2],track->GetPt(),dipangle,beta,padrow,track->GetNumberOfPoints());
}
}
AliTPCClustersRow *ro = (AliTPCClustersRow *)arr->GetRow(cursec,currow);
TClonesArray *clusters = ro->GetArray();
- int num_of_offline=clusters->GetEntriesFast();
+ int numofoffline=clusters->GetEntriesFast();
//Get the found clusters:
Int_t slice,padrow;
if(!points)
continue;
- //cout<<"Slice "<<slice<<" padrow "<<padrow<<" has "<<num_of_offline<<" clusters "<<endl;
+ //cout<<"Slice "<<slice<<" padrow "<<padrow<<" has "<<numofoffline<<" clusters "<<endl;
Int_t clustercount=0;
Int_t crosscount=0;
- for(Int_t m=0; m<num_of_offline; m++)
+ for(Int_t m=0; m<numofoffline; m++)
{
AliComplexCluster *cluster = (AliComplexCluster *)clusters->UncheckedAt(m);
#ifdef use_newio
cluster->fX < 1 || cluster->fX > AliL3Transform::GetNTimeBins() - 2)
continue;
#endif
- Float_t xyz_ex[3];
+ Float_t xyzex[3];
#ifdef use_newio
- AliL3Transform::Raw2Local(xyz_ex,cursec,currow,cluster->GetY(),cluster->GetX());
+ AliL3Transform::Raw2Local(xyzex,cursec,currow,cluster->GetY(),cluster->GetX());
#else
- AliL3Transform::Raw2Local(xyz_ex,cursec,currow,cluster->fY,cluster->fX);
+ AliL3Transform::Raw2Local(xyzex,cursec,currow,cluster->fY,cluster->fX);
#endif
//In function AliTPC::Hits2ExactClusters the time offset is not included,
//so we have to substract it again here.
if(slice<18)
- xyz_ex[2]-=AliL3Transform::GetZOffset();
+ xyzex[2]-=AliL3Transform::GetZOffset();
else
- xyz_ex[2]+=AliL3Transform::GetZOffset();
+ xyzex[2]+=AliL3Transform::GetZOffset();
//Outside our cone:
- if(param->GetPadRowRadii(cursec,currow)<230./250.*fabs(xyz_ex[2]))
+ if(param->GetPadRowRadii(cursec,currow)<230./250.*fabs(xyzex[2]))
continue;
TParticle *part = astack->Particle(mcId);
for(UInt_t c=0; c<fNcl[slice][patch]; c++)
{
if((Int_t)points[c].fPadRow!=padrow) continue;
- Float_t xyz_cl[3] = {points[c].fX,points[c].fY,points[c].fZ};
+ Float_t xyzcl[3] = {points[c].fX,points[c].fY,points[c].fZ};
if(!offline)
- AliL3Transform::Global2Local(xyz_cl,cursec);
+ AliL3Transform::Global2Local(xyzcl,cursec);
tempcount++;
if(points[c].fTrackID[0] != mcId &&
continue;
//Residuals:
- Float_t resy = xyz_cl[1] - xyz_ex[1];
- Float_t resz = xyz_cl[2] - xyz_ex[2];
+ Float_t resy = xyzcl[1] - xyzex[1];
+ Float_t resz = xyzcl[2] - xyzex[2];
//Cluster shape
Int_t charge = (Int_t)points[c].fCharge;
- Float_t beta = GetCrossingAngle(part,slice,padrow,xyz_ex);
- Double_t tanl = xyz_ex[2]/sqrt(xyz_ex[0]*xyz_ex[0]+xyz_ex[1]*xyz_ex[1]);
- Float_t psigmaY2 = AliL3Transform::GetParSigmaY2(padrow,xyz_ex[2],beta);
- Float_t psigmaZ2 = AliL3Transform::GetParSigmaZ2(padrow,xyz_ex[2],tanl);
+ Float_t beta = GetCrossingAngle(part,slice,padrow,xyzex);
+ Double_t tanl = xyzex[2]/sqrt(xyzex[0]*xyzex[0]+xyzex[1]*xyzex[1]);
+ Float_t psigmaY2 = AliL3Transform::GetParSigmaY2(padrow,xyzex[2],beta);
+ Float_t psigmaZ2 = AliL3Transform::GetParSigmaZ2(padrow,xyzex[2],tanl);
Float_t sigmaY2 = points[c].fSigmaY2;
Float_t sigmaZ2 = points[c].fSigmaZ2;
- ntuppel->Fill(slice,padrow,charge,resy,resz,xyz_ex[2],part->Pt(),beta,sigmaY2,sigmaZ2,psigmaY2,psigmaZ2);
+ ntuppel->Fill(slice,padrow,charge,resy,resz,xyzex[2],part->Pt(),beta,sigmaY2,sigmaZ2,psigmaY2,psigmaZ2);
}
clustercount=tempcount;
}
ntuppel->Write();
ntuppel2->Write();
ofile->Close();
-
#endif
}
tangent[0] = -1.*(xyz[1] - yc)/radius;
tangent[1] = (xyz[0] - xc)/radius;
- Double_t perp_padrow[2] = {1,0}; //locally in slice
+ Double_t perppadrow[2] = {1,0}; //locally in slice
- Double_t cos_beta = fabs(tangent[0]*perp_padrow[0] + tangent[1]*perp_padrow[1]);
- if(cos_beta > 1) cos_beta=1;
- return acos(cos_beta);
+ Double_t cosbeta = fabs(tangent[0]*perppadrow[0] + tangent[1]*perppadrow[1]);
+ if(cosbeta > 1) cosbeta=1;
+ return acos(cosbeta);
}
Int_t AliL3Evaluate::FindPrimaries(Int_t nparticles)
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff