// Author: Anders Vestbo <mailto:vestbo@fi.uib.no>
//*-- Copyright © ALICE HLT Group
-/** \class AliL3Evaluate
+/** \class AliHLTEvaluate
<pre>
//_____________________________________________________________
-// AliL3Evaluate
+// AliHLTEvaluate
//
// Evaluation class for tracking; plots, efficiencies etc..
//
#include <AliComplexCluster.h>
#include <AliStack.h>
-#include "AliL3StandardIncludes.h"
-#include "AliL3Logging.h"
-#include "AliL3Transform.h"
-#include "AliL3SpacePointData.h"
-#include "AliL3Track.h"
-#include "AliL3FileHandler.h"
-#include "AliL3TrackArray.h"
-#include "AliL3Evaluate.h"
+#include "AliHLTStandardIncludes.h"
+#include "AliHLTLogging.h"
+#include "AliHLTTransform.h"
+#include "AliHLTSpacePointData.h"
+#include "AliHLTTrack.h"
+#include "AliHLTFileHandler.h"
+#include "AliHLTTrackArray.h"
+#include "AliHLTEvaluate.h"
#if __GNUC__ == 3
#include <iosfwd>
using namespace std;
#endif
-ClassImp(AliL3Evaluate)
+ClassImp(AliHLTEvaluate)
-AliL3Evaluate::AliL3Evaluate()
+AliHLTEvaluate::AliHLTEvaluate()
{
//constructor
Clear();
}
-AliL3Evaluate::AliL3Evaluate(Char_t *datapath,Int_t minclusters,Int_t minhits,Double_t minpt,Double_t maxpt,Int_t *slice)
+AliHLTEvaluate::AliHLTEvaluate(Char_t *datapath,Int_t minclusters,Int_t minhits,Double_t minpt,Double_t maxpt,Int_t *slice)
{
//constructor
Clear();
fMaxGoodPt = maxpt;
}
-AliL3Evaluate::~AliL3Evaluate()
+AliHLTEvaluate::~AliHLTEvaluate()
{
//destructor
if(fGoodTracks) delete[] fGoodTracks;
}
}
-void AliL3Evaluate::Clear()
+void AliHLTEvaluate::Clear()
{
//clear
fTracks = 0;
sprintf(fPath,"./");
}
-void AliL3Evaluate::LoadData(Int_t event,Bool_t sp)
+void AliHLTEvaluate::LoadData(Int_t event,Bool_t sp)
{
//load cluster points
Char_t fname[1024];
for(Int_t s=fMinSlice; s<=fMaxSlice; s++)
{
- for(Int_t p=0; p<AliL3Transform::GetNPatches(); p++)
+ for(Int_t p=0; p<AliHLTTransform::GetNPatches(); p++)
{
Int_t patch;
if(sp==kTRUE)
if(fClustersFile[s][p])
delete fClustersFile[s][p];
fClusters[s][p] = 0;
- fClustersFile[s][p] = new AliL3FileHandler();
+ fClustersFile[s][p] = new AliHLTFileHandler();
if(event<0)
sprintf(fname,"%s/points_%d_%d.raw",fPath,s,patch);
else
sprintf(fname,"%s/points_%d_%d_%d.raw",fPath,event,s,patch);
if(!fClustersFile[s][p]->SetBinaryInput(fname))
{
- LOG(AliL3Log::kError,"AliL3Evaluation::Setup","File Open")
+ LOG(AliHLTLog::kError,"AliHLTEvaluation::Setup","File Open")
<<"Inputfile "<<fname<<" does not exist"<<ENDLOG;
delete fClustersFile[s][p];
fClustersFile[s][p] = 0;
continue;
}
- fClusters[s][p] = (AliL3SpacePointData*)fClustersFile[s][p]->Allocate();
+ fClusters[s][p] = (AliHLTSpacePointData*)fClustersFile[s][p]->Allocate();
fClustersFile[s][p]->Binary2Memory(fNcl[s][p],fClusters[s][p]);
fClustersFile[s][p]->CloseBinaryInput();
if(sp==kTRUE)
}
sprintf(fname,"%s/tracks_%d.raw",fPath,event);
- AliL3FileHandler *tfile = new AliL3FileHandler();
+ AliHLTFileHandler *tfile = new AliHLTFileHandler();
if(!tfile->SetBinaryInput(fname)){
- LOG(AliL3Log::kError,"AliL3Evaluation::Setup","File Open")
+ LOG(AliHLTLog::kError,"AliHLTEvaluation::Setup","File Open")
<<"Inputfile "<<fname<<" does not exist"<<ENDLOG;
return;
}
if(fTracks)
delete fTracks;
- fTracks = new AliL3TrackArray();
+ fTracks = new AliHLTTrackArray();
tfile->Binary2TrackArray(fTracks);
tfile->CloseBinaryInput();
fTracks->QSort();
delete tfile;
}
-void AliL3Evaluate::AssignPIDs()
+void AliHLTEvaluate::AssignPIDs()
{
//assign pid
if(!fTracks) return;
fTracks->QSort();
- LOG(AliL3Log::kDebug,"AliL3Evaluate::AssignPIDs","Track Loop")
+ LOG(AliHLTLog::kDebug,"AliHLTEvaluate::AssignPIDs","Track Loop")
<<"Assigning pid to the found tracks...."<<ENDLOG;
for(Int_t i=0; i<fTracks->GetNTracks(); i++)
{
- AliL3Track *track = (AliL3Track*)fTracks->GetCheckedTrack(i);
+ AliHLTTrack *track = (AliHLTTrack*)fTracks->GetCheckedTrack(i);
if(!track) continue;
if(track->GetNumberOfPoints() < fMinPointsOnTrack)
track->SetPID(0);
}
}
-void AliL3Evaluate::AssignIDs()
+void AliHLTEvaluate::AssignIDs()
{
//Assign MC id to the tracks.
#ifndef do_mc
- cerr<<"AliL3Evaluate::AssignIDs() : You need to compile with the do_mc flag!"<<endl;
+ cerr<<"AliHLTEvaluate::AssignIDs() : You need to compile with the do_mc flag!"<<endl;
return;
#else
if(!fTracks) return;
fGoodFound=0;
fTracks->QSort();
- LOG(AliL3Log::kDebug,"AliL3Evaluate::AssignIDs","Track Loop")
+ LOG(AliHLTLog::kDebug,"AliHLTEvaluate::AssignIDs","Track Loop")
<<"Assigning MC id to the found tracks...."<<ENDLOG;
for(Int_t i=0; i<fTracks->GetNTracks(); i++)
{
- AliL3Track *track = (AliL3Track*)fTracks->GetCheckedTrack(i);
+ AliHLTTrack *track = (AliHLTTrack*)fTracks->GetCheckedTrack(i);
if(!track) continue;
if(track->GetNumberOfPoints() < fMinPointsOnTrack) break;
#endif
}
-Float_t AliL3Evaluate::GetTrackPID(AliL3Track *track)
+Float_t AliHLTEvaluate::GetTrackPID(AliHLTTrack *track)
{
//get track pid
track->CalculateHelix();
Int_t iSector = (hitID>>25) & 0x7f;
Int_t patch = (hitID>>22) & 0x7;
UInt_t position = hitID&0x3fffff;
- AliL3SpacePointData *points = fClusters[iSector][patch];
+ AliHLTSpacePointData *points = fClusters[iSector][patch];
if(!points) continue;
if(position>=fNcl[iSector][patch])
{
- LOG(AliL3Log::kError,"AliL3Evaluate::GetMCTrackLabel","Clusterarray")
- <<AliL3Log::kDec<<"ERROR"<<ENDLOG;
+ LOG(AliHLTLog::kError,"AliHLTEvaluate::GetMCTrackLabel","Clusterarray")
+ <<AliHLTLog::kDec<<"ERROR"<<ENDLOG;
continue;
}
UChar_t padrow = points[position].fPadRow;
- Float_t pWidth = AliL3Transform::GetPadPitchWidthLow();
+ Float_t pWidth = AliHLTTransform::GetPadPitchWidthLow();
if (padrow>63)
- pWidth = AliL3Transform::GetPadPitchWidthUp();
+ pWidth = AliHLTTransform::GetPadPitchWidthUp();
Float_t corr=1.; if (padrow>63) corr=0.67;
sampleDEdx[iHit] = points[position].fCharge/pWidth*corr;
Double_t crossingangle = track->GetCrossingAngle(padrow,iSector);
}
#ifdef do_mc
-Int_t AliL3Evaluate::GetMCTrackLabel(AliL3Track *track)
+Int_t AliHLTEvaluate::GetMCTrackLabel(AliHLTTrack *track)
{
//Returns the MCtrackID of the belonging clusters.
//If MCLabel < 0, means that track is fake.
Int_t patch = (id>>22) & 0x7;
UInt_t pos = id&0x3fffff;
- AliL3SpacePointData *points = fClusters[slice][patch];
+ AliHLTSpacePointData *points = fClusters[slice][patch];
if(!points) continue;
if(pos>=fNcl[slice][patch])
{
- LOG(AliL3Log::kError,"AliL3Evaluate::GetMCTrackLabel","Clusterarray")
- <<AliL3Log::kDec<<"ERROR"<<ENDLOG;
+ LOG(AliHLTLog::kError,"AliHLTEvaluate::GetMCTrackLabel","Clusterarray")
+ <<AliHLTLog::kDec<<"ERROR"<<ENDLOG;
continue;
}
if(lab == -1)
return -1; //If most clusters is -1, this is a noise track.
if(lab < 0)
- cerr<<"AliL3Evaluate::GetMCTrackLabel : Track label negative :"<<lab<<endl;
+ cerr<<"AliHLTEvaluate::GetMCTrackLabel : Track label negative :"<<lab<<endl;
delete[] s;
Int_t patch = (id>>22) & 0x7;
UInt_t pos = id&0x3fffff;
- AliL3SpacePointData *points = fClusters[slice][patch];
+ AliHLTSpacePointData *points = fClusters[slice][patch];
if(!points) continue;
if(pos>=fNcl[slice][patch])
{
- LOG(AliL3Log::kError,"AliL3Evaluate::GetMCTrackLabel","Clusterarray")
- <<AliL3Log::kDec<<"ERROR"<<ENDLOG;
+ LOG(AliHLTLog::kError,"AliHLTEvaluate::GetMCTrackLabel","Clusterarray")
+ <<AliHLTLog::kDec<<"ERROR"<<ENDLOG;
continue;
}
Int_t patch = (id>>22) & 0x7;
UInt_t pos = id&0x3fffff;
- AliL3SpacePointData *points = fClusters[slice][patch];
+ AliHLTSpacePointData *points = fClusters[slice][patch];
if(!points) continue;
if(lab == abs(points[pos].fTrackID[0]) ||
lab == abs(points[pos].fTrackID[1]) ||
return lab;
#else //If we are running with mc_ids or not
- Int_t AliL3Evaluate::GetMCTrackLabel(AliL3Track */*track*/)
+ Int_t AliHLTEvaluate::GetMCTrackLabel(AliHLTTrack */*track*/)
{
// Does nothing if do_mc undefined
return 0;
}
-void AliL3Evaluate::GetFastClusterIDs(Char_t *path)
+void AliHLTEvaluate::GetFastClusterIDs(Char_t *path)
{
//Get the MC id of space points in case of using the fast simulator.
char name[256];
fclose(infile);
}
-void AliL3Evaluate::CreateHistos(Int_t nbin,Float_t xlow,Float_t xup)
+void AliHLTEvaluate::CreateHistos(Int_t nbin,Float_t xlow,Float_t xup)
{
//Create the histograms
- LOG(AliL3Log::kInformational,"AliL3Evaluate::CreateHistos","Allocating")
+ LOG(AliHLTLog::kInformational,"AliHLTEvaluate::CreateHistos","Allocating")
<<"Creating histograms..."<<ENDLOG;
fNtuppel = new TNtuple("fNtuppel","Pt resolution","pt_gen:pt_found:nHits");
}
-void AliL3Evaluate::GetGoodParticles(Char_t *path,Int_t event,Int_t *padrowrange)
+void AliHLTEvaluate::GetGoodParticles(Char_t *path,Int_t event,Int_t *padrowrange)
{
//Read the good particles from file. This file should already have been
//generated by macro AliTPCComparison.C.
ifstream in(filename);
if(!in)
{
- cerr<<"AliL3Evaluate::GetGoodParticles : Problems opening file :"<<filename<<endl;
+ cerr<<"AliHLTEvaluate::GetGoodParticles : Problems opening file :"<<filename<<endl;
return;
}
Int_t MaxTracks=20000;
fGoodGen++;
if (fGoodGen==MaxTracks)
{
- cerr<<"AliL3Evaluate::GetGoodParticles : Too many good tracks !\n";
+ cerr<<"AliHLTEvaluate::GetGoodParticles : Too many good tracks !\n";
break;
}
}
fGoodGen++;
if (fGoodGen==MaxTracks)
{
- cerr<<"AliL3Evaluate::GetGoodParticles : Too many good tracks !\n";
+ cerr<<"AliHLTEvaluate::GetGoodParticles : Too many good tracks !\n";
break;
}
}
}
}
-void AliL3Evaluate::FillEffHistos()
+void AliHLTEvaluate::FillEffHistos()
{
//has to be modified for fakes.
if(!fGoodTracks)
{
- cerr<<"AliL3Evaluate::FillEffHistos : No good tracks"<<endl;
+ cerr<<"AliHLTEvaluate::FillEffHistos : No good tracks"<<endl;
return;
}
if(!fTracks) return;
for(Int_t k=0; k<fTracks->GetNTracks(); k++)
{
- AliL3Track *track = fTracks->GetCheckedTrack(k);
+ AliHLTTrack *track = fTracks->GetCheckedTrack(k);
if(!track) continue;
Int_t nHits = track->GetNumberOfPoints();
if(nHits < fMinPointsOnTrack) break;
}
}
-void AliL3Evaluate::FillEffHistosNAIVE()
+void AliHLTEvaluate::FillEffHistosNAIVE()
{
//Fill the efficiency histograms.
for(Int_t k=0; k<fTracks->GetNTracks(); k++)
{
- AliL3Track *track = fTracks->GetCheckedTrack(k);
+ AliHLTTrack *track = fTracks->GetCheckedTrack(k);
if(!track) continue;
Int_t nHits = track->GetNumberOfPoints();
if(nHits < fMinPointsOnTrack) break;
}
}
-void AliL3Evaluate::CalcEffHistos()
+void AliHLTEvaluate::CalcEffHistos()
{
//calc eff histos
Stat_t nfound=fNFoundTracksPt->GetEntries();
Stat_t nfake=fNFakeTracksPt->GetEntries();
- LOG(AliL3Log::kInformational,"AliL3Evaluate::FillEffHistos","Efficiency")
- <<AliL3Log::kDec<<"There was "<<ngood<<" generated good tracks"<<ENDLOG;
- LOG(AliL3Log::kInformational,"AliL3Evaluate::FillEffHistos","Efficiency")
- <<AliL3Log::kDec<<"Found "<<nfound<<" tracks"<<ENDLOG;
- LOG(AliL3Log::kInformational,"AliL3Evaluate::FillEffHistos","Efficiency")
- <<AliL3Log::kDec<<"Integral efficiency is about "<<nfound/ngood*100<<ENDLOG;
- LOG(AliL3Log::kInformational,"AliL3Evaluate::FillEffHistos","Efficiency")
- <<AliL3Log::kDec<<"Fake tracks relative is about "<<nfake/ngood*100<<ENDLOG;
- //LOG(AliL3Log::kInformational,"AliL3Evaluate::FillEffHistos","Efficiency")
- //<<AliL3Log::kDec<<"Naive efficiency "<<(Double_t)fGoodFound/(Double_t)fGoodGen<<ENDLOG;
+ LOG(AliHLTLog::kInformational,"AliHLTEvaluate::FillEffHistos","Efficiency")
+ <<AliHLTLog::kDec<<"There was "<<ngood<<" generated good tracks"<<ENDLOG;
+ LOG(AliHLTLog::kInformational,"AliHLTEvaluate::FillEffHistos","Efficiency")
+ <<AliHLTLog::kDec<<"Found "<<nfound<<" tracks"<<ENDLOG;
+ LOG(AliHLTLog::kInformational,"AliHLTEvaluate::FillEffHistos","Efficiency")
+ <<AliHLTLog::kDec<<"Integral efficiency is about "<<nfound/ngood*100<<ENDLOG;
+ LOG(AliHLTLog::kInformational,"AliHLTEvaluate::FillEffHistos","Efficiency")
+ <<AliHLTLog::kDec<<"Fake tracks relative is about "<<nfake/ngood*100<<ENDLOG;
+ //LOG(AliHLTLog::kInformational,"AliHLTEvaluate::FillEffHistos","Efficiency")
+ //<<AliHLTLog::kDec<<"Naive efficiency "<<(Double_t)fGoodFound/(Double_t)fGoodGen<<ENDLOG;
fNFoundTracksPt->Sumw2(); fNGoodTracksPt->Sumw2();
fTrackEffPt->Divide(fNFoundTracksPt,fNGoodTracksPt,1,1.,"b");
fFakeTrackEffEta->SetFillColor(2);
}
-void AliL3Evaluate::Write2File(Char_t *outputfile)
+void AliHLTEvaluate::Write2File(Char_t *outputfile)
{
//Write histograms to file:
TFile *of = TFile::Open(outputfile,"RECREATE");
if(!of->IsOpen())
{
- LOG(AliL3Log::kError,"AliL3Evaluate::Write2File","File Open")
+ LOG(AliHLTLog::kError,"AliHLTEvaluate::Write2File","File Open")
<<"Problems opening rootfile"<<ENDLOG;
return;
}
of->Close();
}
-TNtuple *AliL3Evaluate::GetNtuple()
+TNtuple *AliHLTEvaluate::GetNtuple()
{
//get ntuple
if(!fNtupleRes)
return fNtupleRes;
}
-void AliL3Evaluate::CalculateResiduals()
+void AliHLTEvaluate::CalculateResiduals()
{
//calculate residuals
TNtuple *ntuppel = GetNtuple();
for(Int_t i=0; i<fTracks->GetNTracks(); i++)
{
- AliL3Track *track = (AliL3Track*)fTracks->GetCheckedTrack(i);
+ AliHLTTrack *track = (AliHLTTrack*)fTracks->GetCheckedTrack(i);
if(!track) continue;
if(track->GetNHits() < fMinPointsOnTrack) break;
//if(slice<18) continue;
- AliL3SpacePointData *points = fClusters[slice][patch];
+ AliHLTSpacePointData *points = fClusters[slice][patch];
if(!points)
{
- LOG(AliL3Log::kError,"AliL3Evaluate::CalculateResiduals","Clusterarray")
+ LOG(AliHLTLog::kError,"AliHLTEvaluate::CalculateResiduals","Clusterarray")
<<"No points at slice "<<slice<<" patch "<<patch<<" pos "<<pos<<ENDLOG;
continue;
}
if(pos>=fNcl[slice][patch])
{
- LOG(AliL3Log::kError,"AliL3Evaluate::CalculateResiduals","Clusterarray")
- <<AliL3Log::kDec<<"ERROR"<<ENDLOG;
+ LOG(AliHLTLog::kError,"AliHLTEvaluate::CalculateResiduals","Clusterarray")
+ <<AliHLTLog::kDec<<"ERROR"<<ENDLOG;
continue;
}
xyz[1] = points[pos].fY;
xyz[2] = points[pos].fZ;
padrow = points[pos].fPadRow;
- //AliL3Transform::Global2Local(xyz,slice,kTRUE);
- AliL3Transform::Global2LocHLT(xyz,slice);
+ //AliHLTTransform::Global2Local(xyz,slice,kTRUE);
+ AliHLTTransform::Global2LocHLT(xyz,slice);
Float_t angle = 0;
- AliL3Transform::Local2GlobalAngle(&angle,slice);
- if(!track->CalculateReferencePoint(angle,AliL3Transform::Row2X(padrow)))
+ AliHLTTransform::Local2GlobalAngle(&angle,slice);
+ if(!track->CalculateReferencePoint(angle,AliHLTTransform::Row2X(padrow)))
{
- LOG(AliL3Log::kError,"AliL3Evaluate::CalculateResiduals","Crossing point")
+ LOG(AliHLTLog::kError,"AliHLTEvaluate::CalculateResiduals","Crossing point")
<<"Track does not crossing padrow "<<padrow<<" in slice "<<slice<<ENDLOG;
continue;
}
Float_t xyzcross[3] = {track->GetPointX(),track->GetPointY(),track->GetPointZ()};
- //AliL3Transform::Global2Local(xyzcross,slice,kTRUE);
- AliL3Transform::Global2LocHLT(xyzcross,slice);
+ //AliHLTTransform::Global2Local(xyzcross,slice,kTRUE);
+ AliHLTTransform::Global2LocHLT(xyzcross,slice);
Double_t beta = track->GetCrossingAngle(padrow,slice);
enum tagprimary {kPrimaryCharged = 0x4000};
#ifndef do_mc
-void AliL3Evaluate::EvaluatePoints(Char_t */*rootfile*/,Char_t */*exactfile*/,Char_t */*tofile*/,Int_t /*nevent*/,Bool_t /*offline*/,Bool_t /*sp*/)
+void AliHLTEvaluate::EvaluatePoints(Char_t */*rootfile*/,Char_t */*exactfile*/,Char_t */*tofile*/,Int_t /*nevent*/,Bool_t /*offline*/,Bool_t /*sp*/)
{
// Does nothing if do_mc undefined
- cerr<<"AliL3Evaluate::EvaluatePoints : Compile with do_mc flag!"<<endl;
+ cerr<<"AliHLTEvaluate::EvaluatePoints : Compile with do_mc flag!"<<endl;
return;
#else
-void AliL3Evaluate::EvaluatePoints(Char_t *rootfile,Char_t *exactfile,Char_t *tofile,Int_t nevent,Bool_t offline,Bool_t sp)
+void AliHLTEvaluate::EvaluatePoints(Char_t *rootfile,Char_t *exactfile,Char_t *tofile,Int_t nevent,Bool_t offline,Bool_t sp)
{
//Compare points to the exact crossing points of track and padrows.
//The input file to this function, contains the exact clusters calculated
gAlice = (AliRun*)exfile->Get("gAlice");
if (!gAlice)
{
- LOG(AliL3Log::kError,"AliL3Evaluate::InitMC","gAlice")
+ LOG(AliHLTLog::kError,"AliHLTEvaluate::InitMC","gAlice")
<<"AliRun object non existing on file"<<ENDLOG;
return;
}
- AliTPCParam *param = (AliTPCParam*)exfile->Get(AliL3Transform::GetParamName());
+ AliTPCParam *param = (AliTPCParam*)exfile->Get(AliHLTTransform::GetParamName());
TFile *exact = TFile::Open(exactfile);
if(!exact)
{
- cerr<<"AliL3Evaluate::EvaluatePoints : Problems opening file :"<<exactfile<<endl;
+ cerr<<"AliHLTEvaluate::EvaluatePoints : Problems opening file :"<<exactfile<<endl;
return;
}
char treeName[500];
sprintf(treeName,"TreeCExact_%s_%d",param->GetTitle(),event);
Bool_t clusterok = arr->ConnectTree(treeName);//Segment Tree (for offline clusters)
- if(!clusterok) {printf("AliL3Evaluate::EvaluatePoints : Error in clusterloading\n"); return;}
+ if(!clusterok) {printf("AliHLTEvaluate::EvaluatePoints : Error in clusterloading\n"); return;}
//cout<<"Entering loop with "<<(Int_t)arr->GetTree()->GetEntries()<<endl;
for(Int_t i=0; i<arr->GetTree()->GetEntries(); i++)
//Get the found clusters:
Int_t slice,padrow;
- AliL3Transform::Sector2Slice(slice,padrow,cursec,currow);
+ AliHLTTransform::Sector2Slice(slice,padrow,cursec,currow);
if(slice < fMinSlice) continue;
if(slice > fMaxSlice) break;
- Int_t patch = AliL3Transform::GetPatch(padrow);
+ Int_t patch = AliHLTTransform::GetPatch(padrow);
if(sp)
patch=0;
- AliL3SpacePointData *points = fClusters[slice][patch];
+ AliHLTSpacePointData *points = fClusters[slice][patch];
if(!points)
continue;
if(mcId <0) continue;
#ifdef use_newio
- if(cluster->GetY() < 1 || cluster->GetY() > AliL3Transform::GetNPads(padrow) - 2 ||
- cluster->GetX() < 1 || cluster->GetX() > AliL3Transform::GetNTimeBins() - 2)
+ if(cluster->GetY() < 1 || cluster->GetY() > AliHLTTransform::GetNPads(padrow) - 2 ||
+ cluster->GetX() < 1 || cluster->GetX() > AliHLTTransform::GetNTimeBins() - 2)
continue;
#else
- if(cluster->fY < 1 || cluster->fY > AliL3Transform::GetNPads(padrow) - 2 ||
- cluster->fX < 1 || cluster->fX > AliL3Transform::GetNTimeBins() - 2)
+ if(cluster->fY < 1 || cluster->fY > AliHLTTransform::GetNPads(padrow) - 2 ||
+ cluster->fX < 1 || cluster->fX > AliHLTTransform::GetNTimeBins() - 2)
continue;
#endif
Float_t xyzex[3];
#ifdef use_newio
- AliL3Transform::Raw2Local(xyzex,cursec,currow,cluster->GetY(),cluster->GetX());
+ AliHLTTransform::Raw2Local(xyzex,cursec,currow,cluster->GetY(),cluster->GetX());
#else
- AliL3Transform::Raw2Local(xyzex,cursec,currow,cluster->fY,cluster->fX);
+ AliHLTTransform::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)
- xyzex[2]-=AliL3Transform::GetZOffset();
+ xyzex[2]-=AliHLTTransform::GetZOffset();
else
- xyzex[2]+=AliL3Transform::GetZOffset();
+ xyzex[2]+=AliHLTTransform::GetZOffset();
//Outside our cone:
if(param->GetPadRowRadii(cursec,currow)<230./250.*fabs(xyzex[2]))
Float_t xyzcl[3] = {points[c].fX,points[c].fY,points[c].fZ};
if(!offline)
- AliL3Transform::Global2Local(xyzcl,cursec);
+ AliHLTTransform::Global2Local(xyzcl,cursec);
tempcount++;
if(points[c].fTrackID[0] != mcId &&
Int_t charge = (Int_t)points[c].fCharge;
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 psigmaY2 = AliHLTTransform::GetParSigmaY2(padrow,xyzex[2],beta);
+ Float_t psigmaZ2 = AliHLTTransform::GetParSigmaZ2(padrow,xyzex[2],tanl);
Float_t sigmaY2 = points[c].fSigmaY2;
Float_t sigmaZ2 = points[c].fSigmaZ2;
ntuppel->Fill(slice,padrow,charge,resy,resz,xyzex[2],part->Pt(),beta,sigmaY2,sigmaZ2,psigmaY2,psigmaZ2);
}
#ifndef do_mc
-void AliL3Evaluate::GetCFeff(Char_t */*path*/,Char_t */*outfile*/,Int_t /*nevent*/,Bool_t /*sp*/)
+void AliHLTEvaluate::GetCFeff(Char_t */*path*/,Char_t */*outfile*/,Int_t /*nevent*/,Bool_t /*sp*/)
{
// Does nothing if do_mc undefined
- cerr<<"AliL3Evaluate::GetCFeff : Compile with do_mc flag"<<endl;
+ cerr<<"AliHLTEvaluate::GetCFeff : Compile with do_mc flag"<<endl;
return;
#else
-void AliL3Evaluate::GetCFeff(Char_t *path,Char_t *outfile,Int_t nevent,Bool_t sp)
+void AliHLTEvaluate::GetCFeff(Char_t *path,Char_t *outfile,Int_t nevent,Bool_t sp)
{
//Evaluate the cluster finder efficiency.
AliStack *astack=gAlice->Stack();
- AliTPCParam *param = (AliTPCParam*)rfile->Get(AliL3Transform::GetParamName());
+ AliTPCParam *param = (AliTPCParam*)rfile->Get(AliHLTTransform::GetParamName());
Int_t zero=param->GetZeroSup();
crossed=recs=0;
if (!TD->GetEvent(i)) continue;
param->AdjustSectorRow(digits->GetID(),sec,row);
- AliL3Transform::Sector2Slice(sl,sr,sec,row);
+ AliHLTTransform::Sector2Slice(sl,sr,sec,row);
if(sl < fMinSlice) continue;
if(sl > fMaxSlice) break;
cout<<"Processing slice "<<sl<<" row "<<sr<<endl;
Short_t dig = digits->GetDigit(it,ip);
if(dig<=param->GetZeroSup()) continue;
- AliL3Transform::Raw2Local(xyz,sec,row,ip,it);
+ AliHLTTransform::Raw2Local(xyz,sec,row,ip,it);
if(param->GetPadRowRadii(sec,row)<230./250.*fabs(xyz[2]))
continue;
}
}
- Int_t patch = AliL3Transform::GetPatch(sr);
+ Int_t patch = AliHLTTransform::GetPatch(sr);
if(sp==kTRUE)
patch=0;
- AliL3SpacePointData *points = fClusters[sl][patch];
+ AliHLTSpacePointData *points = fClusters[sl][patch];
if(!points)
continue;
for(UInt_t k=0; k<fNcl[sl][patch]; k++)
#endif
}
-Float_t AliL3Evaluate::GetCrossingAngle(TParticle *part,Int_t slice,Int_t /*padrow*/,Float_t *xyz)
+Float_t AliHLTEvaluate::GetCrossingAngle(TParticle *part,Int_t slice,Int_t /*padrow*/,Float_t *xyz)
{
//Calculate the padrow crossing angle of the particle
- Double_t kappa = AliL3Transform::GetBField()*AliL3Transform::GetBFact()/part->Pt();
+ Double_t kappa = AliHLTTransform::GetBField()*AliHLTTransform::GetBFact()/part->Pt();
Double_t radius = 1/fabs(kappa);
if(part->GetPdgCode() > 0) kappa = -kappa;
Float_t angl[1] = {part->Phi()};
- AliL3Transform::Global2LocalAngle(angl,slice);
+ AliHLTTransform::Global2LocalAngle(angl,slice);
Double_t charge = -1.*kappa;
- Double_t trackPhi0 = angl[0] + charge*0.5*AliL3Transform::Pi()/fabs(charge);
+ Double_t trackPhi0 = angl[0] + charge*0.5*AliHLTTransform::Pi()/fabs(charge);
Double_t x0=0;
Double_t y0=0;
return acos(cosbeta);
}
-Int_t AliL3Evaluate::FindPrimaries(Int_t nparticles)
+Int_t AliHLTEvaluate::FindPrimaries(Int_t nparticles)
{
// cuts:
Double_t vertcut = 0.001;
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff