///////////////////////////////////////////////////////////////////////////////
#include <TObject.h>
-#include <TROOT.h>
#include <TMath.h>
-#include <TStopwatch.h>
#include <TTreeStream.h>
#include "AliLog.h"
-
+#include "AliTRDcluster.h"
#include "AliTRDgeometry.h"
#include "AliTRDpadPlane.h"
#include "AliTRDchamberTimeBin.h"
//_____________________________________________________________________________
AliTRDchamberTimeBin::AliTRDchamberTimeBin(Int_t plane, Int_t stack, Int_t sector, Double_t z0, Double_t zLength)
:TObject()
- ,fReconstructor(0x0)
+ ,fkReconstructor(NULL)
,fPlane(plane)
,fStack(stack)
,fSector(sector)
//_____________________________________________________________________________
AliTRDchamberTimeBin::AliTRDchamberTimeBin(const AliTRDchamberTimeBin &layer):
TObject()
- ,fReconstructor(layer.fReconstructor)
+ ,fkReconstructor(layer.fkReconstructor)
,fPlane(layer.fPlane)
,fStack(layer.fStack)
,fSector(layer.fSector)
//_____________________________________________________________________________
void AliTRDchamberTimeBin::Clear(const Option_t *)
{
+ // Reset the Chamber Timebin
if(IsOwner())
for(Int_t it = 0; it<kMaxClustersLayer; it++)
delete fClusters[it];
// Copy method. Performs a deep copy of all data from this object to object o.
AliTRDchamberTimeBin &layer = (AliTRDchamberTimeBin &)o;
- layer.fReconstructor = fReconstructor;
+ layer.fkReconstructor = fkReconstructor;
layer.fPlane = fPlane;
layer.fStack = fStack;
layer.fSector = fSector;
// Reinitialize all data members from the clusters array
// It has to be used after reading from disk
- fReconstructor = rec;
+ fkReconstructor = rec;
fPlane = AliTRDgeometry::GetLayer(det);
fStack = AliTRDgeometry::GetStack(det);
fSector = AliTRDgeometry::GetSector(det);
Int_t nClStack = 0; // Internal counter
for(Int_t i = 0; i < fN; i++){
if(fClusters[i]->IsUsed() || fClusters[i]->IsShared()){
- fClusters[i] = 0x0;
+ fClusters[i] = NULL;
fIndex[i] = 0xffff;
} else nClStack++;
}
nClStack = 0;
// Defining iterators
AliTRDcluster **fcliter = &fClusters[0], **hcliter = &helpCL[0]; UInt_t *finditer = &fIndex[0], *hinditer = &helpInd[0];
- AliTRDcluster *tmpcl = 0x0;
+ AliTRDcluster *tmpcl = NULL;
for(Int_t i = 0; i < TMath::Min(fN, kMaxClustersLayer); i++){
if(!(tmpcl = *(fcliter++))){
finditer++;
}
*(hcliter++) = tmpcl;
*(hinditer++) = *finditer;
- tmpcl = 0x0;
+ tmpcl = NULL;
*(finditer++) = 0xffff;
nClStack++;
}
fX += cl->GetX();
// Debug Streaming
- if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 3){
+ if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 3){
AliTRDcluster dcl(*cl);
- TTreeSRedirector &cstream = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+ TTreeSRedirector &cstream = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
cstream << "BuildIndices"
<< "Plane=" << fPlane
<< "Stack=" << fStack
}
//_____________________________________________________________________________
-void AliTRDchamberTimeBin::BuildCond(AliTRDcluster *cl, Double_t *cond, UChar_t Layer, Double_t theta, Double_t phi)
+void AliTRDchamberTimeBin::BuildCond(AliTRDcluster * const cl, Double_t *cond, UChar_t Layer, Double_t theta, Double_t phi)
{
// Helper function to calculate the area where to expect a cluster in THIS
// layer.
//End_Html
//
- if(!fReconstructor){
+ if(!fkReconstructor){
AliError("Reconstructor not set.");
return;
}
if(Layer == 0){
cond[0] = cl->GetY(); // center: y-Direction
cond[1] = cl->GetZ(); // center: z-Direction
- cond[2] = fReconstructor->GetRecoParam()->GetMaxPhi() * (cl->GetX() - GetX()) + 1.0; // deviation: y-Direction
- cond[3] = fReconstructor->GetRecoParam()->GetMaxTheta() * (cl->GetX() - GetX()) + 1.0; // deviation: z-Direction
+ cond[2] = fkReconstructor->GetRecoParam()->GetMaxPhi() * (cl->GetX() - GetX()) + 1.0; // deviation: y-Direction
+ cond[3] = fkReconstructor->GetRecoParam()->GetMaxTheta() * (cl->GetX() - GetX()) + 1.0; // deviation: z-Direction
} else {
cond[0] = cl->GetY() + phi * (GetX() - cl->GetX());
cond[1] = cl->GetZ() + theta * (GetX() - cl->GetX());
- cond[2] = fReconstructor->GetRecoParam()->GetRoad0y() + phi;
- cond[3] = fReconstructor->GetRecoParam()->GetRoad0z();
+ cond[2] = fkReconstructor->GetRecoParam()->GetRoad0y() + phi;
+ cond[3] = fkReconstructor->GetRecoParam()->GetRoad0z();
}
}
//_____________________________________________________________________________
-void AliTRDchamberTimeBin::GetClusters(Double_t *cond, Int_t *index, Int_t& ncl, Int_t BufferSize)
+void AliTRDchamberTimeBin::GetClusters(const Double_t * const cond, Int_t *index, Int_t& ncl, Int_t BufferSize)
{
// Finds all clusters situated in this layer inside a rectangle given by the center an ranges.
//
// successfull) by the help of the method FindNearestCluster
- Double_t maxroad = fReconstructor->GetRecoParam()->GetRoad2y();
- Double_t maxroadz = fReconstructor->GetRecoParam()->GetRoad2z();
+ Double_t maxroad = fkReconstructor->GetRecoParam()->GetRoad2y();
+ Double_t maxroadz = fkReconstructor->GetRecoParam()->GetRoad2z();
Int_t index = SearchNearestCluster(cond[0],cond[1],maxroad,maxroadz);
- AliTRDcluster *returnCluster = 0x0;
+ AliTRDcluster *returnCluster = NULL;
if(index != -1) returnCluster = (AliTRDcluster *) fClusters[index];
return returnCluster;
}
#include "TObject.h"
#endif
-#ifndef ALITRDCLUSTER_H
-#include "AliTRDcluster.h"
-#endif
-
+class AliTRDcluster;
class AliTRDReconstructor;
+
class AliTRDchamberTimeBin : public TObject
{
public:
AliTRDchamberTimeBin&
operator=(const AliTRDchamberTimeBin &myLayer);
AliTRDcluster* operator[](const Int_t i) const {
- return ((i < fN) && (i >= 0)) ? fClusters[i] : 0x0;
+ return ((i < fN) && (i >= 0)) ? fClusters[i] : NULL;
}
void Bootstrap(const AliTRDReconstructor *rec, Int_t det);
void BuildIndices(Int_t iter = 0);
- void BuildCond(AliTRDcluster *cl, Double_t *cond, UChar_t Layer, Double_t theta=0., Double_t phi=0.);
- void Clear(const Option_t *opt = 0x0);
- AliTRDcluster* GetCluster(Int_t index) const {return index < fN && index >= 0 ? fClusters[index] : 0x0;}
+ void BuildCond(AliTRDcluster * const cl, Double_t *cond, UChar_t Layer, Double_t theta=0., Double_t phi=0.);
+ void Clear(const Option_t *opt = NULL);
+ AliTRDcluster* GetCluster(Int_t index) const {return index < fN && index >= 0 ? fClusters[index] : NULL;}
Int_t GetGlobalIndex(Int_t index) const {return ((index < fN) && (index >= 0)) ? fIndex[index] : 0; }
- void GetClusters(Double_t *cond, Int_t *index, Int_t& ncl, Int_t BufferSize = kMaxClustersLayer);
+ void GetClusters(const Double_t * const cond, Int_t *index, Int_t& ncl, Int_t BufferSize = kMaxClustersLayer);
AliTRDcluster* GetNearestCluster(Double_t *cond);
Double_t GetX() const {
return fX; }
Bool_t IsT0() const {return TestBit(kT0);}
Bool_t IsOwner() const {return TestBit(kOwner);}
- void Print(Option_t *opt=0x0) const;
+ void Print(Option_t *opt=NULL) const;
Int_t SearchNearestCluster(Double_t y, Double_t z, Double_t Roady, Double_t Roadz) const;
void SetRange(Float_t z0, Float_t zLength);
void SetNRows(Int_t nRows){ fNRows = nRows; }
void SetPlane(Int_t plane){ fPlane = plane; }
- void SetReconstructor(const AliTRDReconstructor *rec) {fReconstructor = rec;}
+ void SetReconstructor(const AliTRDReconstructor *rec) {fkReconstructor = rec;}
void SetStack(Int_t stack){ fStack = stack; }
void SetSector(Int_t sector){ fSector = sector; }
void SetOwner(Bool_t copy=kTRUE);
Int_t FindNearestYCluster(Double_t y, UChar_t z) const;
private:
- const AliTRDReconstructor *fReconstructor; //!
+ const AliTRDReconstructor *fkReconstructor; //!
Char_t fPlane; //! Plane number
Char_t fStack; //! stack number in supermodule
Char_t fSector; //! Sector mumber
#include "TROOT.h"
#include "TClonesArray.h"
+#include "AliRun.h"
+#include "AliRunLoader.h"
+#include "AliLoader.h"
+#include "AliLog.h"
+#include "AliESDTrdTrack.h"
+
#include "AliTRDgtuSim.h"
#include "AliTRDgtuTMU.h"
#include "AliTRDtrackGTU.h"
#include "AliTRDtrackletMCM.h"
#include "AliESDEvent.h"
-#include "AliRun.h"
-#include "AliRunLoader.h"
-#include "AliLoader.h"
-#include "AliLog.h"
-
ClassImp(AliTRDgtuSim)
AliTRDgtuSim::AliTRDgtuSim(AliRunLoader *rl)
#include "AliTRDpidESD.h"
#include "AliTRDgeometry.h"
#include "AliTRDcalibDB.h"
-#include "AliTRDtrack.h"
+#include "Cal/AliTRDCalPID.h"
ClassImp(AliTRDpidESD)
//_____________________________________________________________________________
AliTRDpidESD::AliTRDpidESD()
:TObject()
- ,fTrack(0x0)
+ ,fTrack(NULL)
{
//
// Default constructor
//_____________________________________________________________________________
AliTRDpidESD::AliTRDpidESD(const AliTRDpidESD &p)
:TObject(p)
- ,fTrack(0x0)
+ ,fTrack(NULL)
{
//
// AliTRDpidESD copy constructor
((AliTRDpidESD &) p).fgCheckTrackStatus = fgCheckTrackStatus;
((AliTRDpidESD &) p).fgCheckKinkStatus = fgCheckKinkStatus;
((AliTRDpidESD &) p).fgMinPlane = fgMinPlane;
- ((AliTRDpidESD &) p).fTrack = 0x0;
+ ((AliTRDpidESD &) p).fTrack = NULL;
}
// Loop through all ESD tracks
Double_t p[10];
- AliESDtrack *t = 0x0;
- Float_t dedx[AliTRDtrack::kNslice], dEdx;
+ AliESDtrack *t = NULL;
+ Float_t dedx[AliTRDCalPID::kNSlicesLQ], dEdx;
Int_t timebin;
Float_t mom, length;
Int_t nPlanePID;
for (Int_t iLayer = 0; iLayer < AliTRDgeometry::kNlayer; iLayer++) {
// read data for track segment
- for(int iSlice=0; iSlice<AliTRDtrack::kNslice; iSlice++)
+ for(int iSlice=0; iSlice<AliTRDCalPID::kNSlicesLQ; iSlice++)
dedx[iSlice] = t->GetTRDslice(iLayer, iSlice);
dEdx = t->GetTRDslice(iLayer, -1);
timebin = t->GetTRDTimBin(iLayer);
return kFALSE;
}
- AliExternalTrackParam *param = 0x0;
+ AliExternalTrackParam *param = NULL;
if(!fTrack){
fTrack = new AliExternalTrackParam(*op);
param = fTrack;
+/***********************************************************************************************************
+ * *
+ * Helper class for TRD PID efficiency calculation Calculation of the hadron efficiency depenedent on *
+ * momentum and of the errors implemented in function CalculatePionEff. The pion efficiency is based on a *
+ * predefined electron efficiency. The default is 90%. To change the, one has to call the function *
+ * SetElectronEfficiency. *
+ * Other Helper functions decide based on 90% electron efficiency whether a certain track is accepted *
+ * as Electron Track. The reference data is stored in the TRD OCDB. *
+ * *
+ ***********************************************************************************************************/
#include "TObject.h"
#include "TObjArray.h"
#include "TMath.h"
ClassImp(AliTRDpidUtil)
-Float_t AliTRDpidUtil::fEleEffi = 0.9;
+Float_t AliTRDpidUtil::fgEleEffi = 0.9;
//________________________________________________________________________
AliTRDpidUtil::AliTRDpidUtil()
//
}
-
-
//________________________________________________________________________
Bool_t AliTRDpidUtil::CalculatePionEffi(TH1* histo1, TH1* histo2)
// Double_t AliTRDpidUtil::GetError()
Int_t abinE, bbinE, cbinE = -1;
Double_t aBinSumE, bBinSumE; // content of a single bin
Bool_t bFirst = 1; // checks if threshold is crossed for the first time
- Double_t SumElecsE[kBins+2], SumPionsE[kBins+2]; // array of the integrated sum in each bin
- memset(SumElecsE, 0, (kBins+2)*sizeof(Double_t));
- memset(SumPionsE, 0, (kBins+2)*sizeof(Double_t));
+ Double_t sumElecE[kBins+2], sumPionsE[kBins+2]; // array of the integrated sum in each bin
+ memset(sumElecE, 0, (kBins+2)*sizeof(Double_t));
+ memset(sumPionsE, 0, (kBins+2)*sizeof(Double_t));
// calculate electron efficiency of each bin
aBinSumE = 0;
aBinSumE = histo1 -> GetBinContent(abinE);
- SumElecsE[abinE] = SumElecsE[abinE+1] + aBinSumE;
+ sumElecE[abinE] = sumElecE[abinE+1] + aBinSumE;
- if((SumElecsE[abinE] >= fEleEffi) && (bFirst == 1)){
+ if((sumElecE[abinE] >= fgEleEffi) && (bFirst == 1)){
bFirst = 0;
cbinE = abinE;
- fCalcEleEffi = (SumElecsE[cbinE]);
+ fCalcEleEffi = (sumElecE[cbinE]);
}
}
bBinSumE = 0;
bBinSumE = histo2 -> GetBinContent(bbinE);
- SumPionsE[bbinE] = SumPionsE[bbinE+1] + bBinSumE;
+ sumPionsE[bbinE] = sumPionsE[bbinE+1] + bBinSumE;
if(bbinE == cbinE){
- fPionEffi = (SumPionsE[cbinE]);
+ fPionEffi = (sumPionsE[cbinE]);
}
}
// pion efficiency vs electron efficiency
- TGraph gEffis(kBins, SumElecsE, SumPionsE);
+ TGraph gEffis(kBins, sumElecE, sumPionsE);
// use fit function to get derivate of the TGraph for error calculation
- TF1 f1("f1","[0]*x*x+[1]*x+[2]", fEleEffi-.05, fEleEffi+.05);
- gEffis.Fit(&f1, "Q", "", fEleEffi-.05, fEleEffi+.05);
+ TF1 f1("f1","[0]*x*x+[1]*x+[2]", fgEleEffi-.05, fgEleEffi+.05);
+ gEffis.Fit(&f1, "Q", "", fgEleEffi-.05, fgEleEffi+.05);
// return the error of the pion efficiency
if(((1.-fPionEffi) < 0) || ((1.-fCalcEleEffi) < 0)){
AliWarning(" EleEffi or PioEffi > 1. Error can not be calculated. Please increase statistics or check your simulation!");
return kFALSE;
}
- fError = sqrt(((1/histo2 -> GetEntries())*fPionEffi*(1-fPionEffi))+((f1.Derivative(fEleEffi))*(f1.Derivative(fEleEffi))*(1/histo1 -> GetEntries())*fCalcEleEffi*(1-fCalcEleEffi)));
+ fError = sqrt(((1/histo2 -> GetEntries())*fPionEffi*(1-fPionEffi))+((f1.Derivative(fgEleEffi))*(f1.Derivative(fgEleEffi))*(1/histo1 -> GetEntries())*fCalcEleEffi*(1-fCalcEleEffi)));
// AliInfo(Form("Pion Effi at [%f] : [%f +/- %f], Threshold[%f]", fCalcEleEffi, fPionEffi, fError, fThreshold));
-// AliInfo(Form("Derivative at %4.2f : %f\n", fEleEffi, f1.Derivative(fEleEffi)));
+// AliInfo(Form("Derivative at %4.2f : %f\n", fgEleEffi, f1.Derivative(fgEleEffi)));
return kTRUE;
}
if(method == kESD) method = kNN;
TString histname[2] = {"fHistThreshLQ", "fHistThreshNN"};
AliCDBManager *cdb = AliCDBManager::Instance();
- AliCDBEntry *cdb_thresholds = cdb->Get("TRD/Calib/PIDThresholds");
- TObjArray *histos = dynamic_cast<TObjArray *>(cdb_thresholds->GetObject());
- TH1 * threshold_hist = dynamic_cast<TH1F *>(histos->FindObject(histname[method].Data()));
- Double_t threshold = threshold_hist->GetBinContent(GetMomentumBin(track->P()) + 1);
+ AliCDBEntry *cdbThresholds = cdb->Get("TRD/Calib/PIDThresholds");
+ TObjArray *histos = dynamic_cast<TObjArray *>(cdbThresholds->GetObject());
+ TH1 * thresholdHist = dynamic_cast<TH1F *>(histos->FindObject(histname[method].Data()));
+ Double_t threshold = thresholdHist->GetBinContent(GetMomentumBin(track->P()) + 1);
// Do Decision
Double_t pid_probs[5];
if(method == kESD) method = kNN;
TString histname[2] = {"fHistPionEffLQ", "fHistPionEffNN"};
AliCDBManager *cdb = AliCDBManager::Instance();
- AliCDBEntry *cdb_thresholds = cdb->Get("TRD/Calib/PIDThresholds");
- TObjArray *histos = dynamic_cast<TObjArray *>(cdb_thresholds->GetObject());
- TH1 * threshold_hist = dynamic_cast<TH1F *>(histos->FindObject(histname[method].Data()));
- return threshold_hist->GetBinContent(GetMomentumBin(track->P()) + 1);
+ AliCDBEntry *cdbThresholds = cdb->Get("TRD/Calib/PIDThresholds");
+ TObjArray *histos = dynamic_cast<TObjArray *>(cdbThresholds->GetObject());
+ TH1 * thresholdHist = dynamic_cast<TH1F *>(histos->FindObject(histname[method].Data()));
+ return thresholdHist->GetBinContent(GetMomentumBin(track->P()) + 1);
}
//________________________________________________________________________
Bool_t CalculatePionEffi(TH1* histo1, TH1* histo2);
- static Float_t ElectronEfficiency() { return fEleEffi;};
+ static Float_t ElectronEfficiency() { return fgEleEffi;};
static Bool_t IsElectron(const AliESDtrack *track, ETRDPIDMethod method = kNN);
static Double_t GetSystematicError(const AliESDtrack *track, ETRDPIDMethod method = kNN);
static Int_t GetMomentumBin(Double_t p);
static Int_t Pdg2Pid(Int_t pdg);
- static void SetElectronEfficiency(Float_t eleeffi) {fEleEffi = eleeffi;};
+ static void SetElectronEfficiency(Float_t eleeffi) {fgEleEffi = eleeffi;};
private:
AliTRDpidUtil(const AliTRDpidUtil&); // not implemented
AliTRDpidUtil& operator=(const AliTRDpidUtil&); // not implemented
- static Float_t fEleEffi; // electron efficiency
+ static Float_t fgEleEffi; // electron efficiency
Double_t fCalcEleEffi; // electron efficiency after calculation
Double_t fPionEffi; // pion efficiency
:TObject((TObject&)p)
,fN(p.fN)
,fSec(p.fSec)
- ,fClusters(0x0)
- ,fIndex(0x0)
+ ,fClusters(NULL)
+ ,fIndex(NULL)
,fX(p.fX)
,fdX(p.fdX)
,fRho(p.fRho)
}
//_____________________________________________________________________________
-void AliTRDpropagationLayer::SetZ(Double_t *center, Double_t *w, Double_t *wsensitive )
+void AliTRDpropagationLayer::SetZ(Double_t * const center, Double_t * const w, Double_t * const wsensitive )
{
//
// Set centers and the width of sectors
}
//_____________________________________________________________________________
-void AliTRDpropagationLayer::SetHoles(Bool_t *holes)
+void AliTRDpropagationLayer::SetHoles(Bool_t * const holes)
{
//
// Set centers and the width of sectors
void SetYmax(Double_t w, Double_t wsensitive) { fYmax = w;
fYmaxSensitive = wsensitive; }
- void SetZ(Double_t* center, Double_t *w, Double_t *wsensitive);
- void SetHoles(Bool_t* holes);
+ void SetZ(Double_t * const center, Double_t * const w, Double_t * const wsensitive);
+ void SetHoles(Bool_t * const holes);
//void SetHole(Double_t Zmax, Double_t Ymax
// , Double_t rho = 1.29e-3, Double_t x0 = 36.66
// , Double_t Yc = 0.0, Double_t Zc = 0.0);
Bool_t IsSensitive() const { return (fTimeBinIndex >= 0) ? kTRUE : kFALSE;}
Bool_t IsT0() const {return TestBit(1);}
- void Clear(const Option_t * /*o*/) { ; }
+ void Clear(const Option_t * /*o*/) const { ; }
void Clear() { for (Int_t i = 0; i < fN; i++)
fClusters[i] = NULL;
fN = 0; }
Double_t fkTrackLikelihood; // Track likelihood for tracklets Rieman fit
Double_t fSysCovMatrix[5]; // Systematic uncertainty from calibration and alignment for each tracklet
- Double_t fPIDThreshold[AliTRDCalPID::kNMom];
+ Double_t fPIDThreshold[AliTRDCalPID::kNMom]; // PID Thresholds for Electron candidate decision
// Clusterization parameter
Double_t fMinMaxCutSigma; // Threshold sigma noise pad middle
#include "AliMathBase.h"
#include "AliTRDseed.h"
-#include "AliTRDcalibDB.h"
#include "AliTRDcluster.h"
#include "AliTRDtracker.h"
#include "AliTRDtrackerV1.h"
fY[i] = 0; // y position
fZ[i] = 0; // z position
fIndexes[i] = 0; // Indexes
- fClusters[i] = 0x0; // Clusters
+ fClusters[i] = NULL; // Clusters
fUsable[i] = 0; // Indication - usable cluster
}
fY[i] = 0; // Y position
fZ[i] = 0; // Z position
fIndexes[i] = 0; // Indexes
- fClusters[i] = 0x0; // Clusters
+ fClusters[i] = NULL; // Clusters
fUsable[i] = kFALSE;
}
fUsable[i] = kFALSE;
if (!fClusters[i]) continue;
if (!fClusters[i]->IsInChamber()) continue;
- if (TMath::Abs(fZ[i] - allowedz[i]) > 2){fClusters[i] = 0x0; continue;}
- if (TMath::Abs(yres[i] - mean) > 4.0 * sigma){fClusters[i] = 0x0; continue;}
+ if (TMath::Abs(fZ[i] - allowedz[i]) > 2){fClusters[i] = NULL; continue;}
+ if (TMath::Abs(yres[i] - mean) > 4.0 * sigma){fClusters[i] = NULL; continue;}
fUsable[i] = kTRUE;
fN2++;
fMPads += fClusters[i]->GetNPads();
Float_t GetMeanz() const { return fMeanz; }
Float_t GetZProb() const { return fZProb; }
Int_t GetLabels(Int_t i) const { return fLabels[i]; }
- Float_t GetMPads() const { return fMPads; }
- Int_t GetNbClusters() const { return fN; }
+ Float_t GetMPads() const { return fMPads; }
+ Int_t GetNbClusters() const { return fN; }
Int_t GetN2() const { return fN2; }
Int_t GetNChange() const { return fNChange; }
Int_t GetNUsed() const { return fNUsed; }
void SetY(Int_t i, Float_t y) { fY[i] = y; }
void SetZ(Int_t i, Float_t z) { fZ[i] = z; }
void SetIndexes(Int_t i, Int_t idx) { fIndexes[i] = idx; }
- void SetClusters(Int_t i, AliTRDcluster *c) { fClusters[i] = c; }
+ void SetClusters(Int_t i, AliTRDcluster * const c) { fClusters[i] = c; }
void SetUsable(Int_t i, Bool_t usable) { fUsable[i] = usable; }
void SetYref(Int_t i, Float_t yref) { fYref[i] = yref; }
void SetZref(Int_t i, Float_t zref) { fZref[i] = zref; }
ClassImp(AliTRDseedV1)
-TLinearFitter *AliTRDseedV1::fgFitterY = 0x0;
-TLinearFitter *AliTRDseedV1::fgFitterZ = 0x0;
+TLinearFitter *AliTRDseedV1::fgFitterY = NULL;
+TLinearFitter *AliTRDseedV1::fgFitterZ = NULL;
//____________________________________________________________________
AliTRDseedV1::AliTRDseedV1(Int_t det)
:AliTRDtrackletBase()
- ,fReconstructor(0x0)
- ,fClusterIter(0x0)
+ ,fkReconstructor(NULL)
+ ,fClusterIter(NULL)
,fExB(0.)
,fVD(0.)
,fT0(0.)
//____________________________________________________________________
AliTRDseedV1::AliTRDseedV1(const AliTRDseedV1 &ref)
:AliTRDtrackletBase((AliTRDtrackletBase&)ref)
- ,fReconstructor(0x0)
- ,fClusterIter(0x0)
+ ,fkReconstructor(NULL)
+ ,fClusterIter(NULL)
,fExB(0.)
,fVD(0.)
,fT0(0.)
if(!fClusters[itb]) continue;
//AliInfo(Form("deleting c %p @ %d", fClusters[itb], itb));
delete fClusters[itb];
- fClusters[itb] = 0x0;
+ fClusters[itb] = NULL;
}
}
}
//AliInfo("");
AliTRDseedV1 &target = (AliTRDseedV1 &)ref;
- target.fReconstructor = fReconstructor;
- target.fClusterIter = 0x0;
+ target.fkReconstructor = fkReconstructor;
+ target.fClusterIter = NULL;
target.fExB = fExB;
target.fVD = fVD;
target.fT0 = fT0;
if((*c)->IsShared() || (*c)->IsUsed()){
if((*c)->IsShared()) SetNShared(GetNShared()-1);
else SetNUsed(GetNUsed()-1);
- (*c) = 0x0;
+ (*c) = NULL;
fIndexes[ic] = -1;
SetN(GetN()-1);
continue;
const Double_t kDriftLength = (.5 * AliTRDgeometry::AmThick() + AliTRDgeometry::DrThick());
- AliTRDcluster *c = 0x0;
+ AliTRDcluster *c = NULL;
for(int ic=0; ic<AliTRDtrackerV1::GetNTimeBins(); ic++){
if(!(c = fClusters[ic]) && !(c = fClusters[ic+kNtb])) continue;
Float_t dx = TMath::Abs(fX0 - c->GetX());
nclusters[slice]++;
} // End of loop over clusters
- //if(fReconstructor->GetPIDMethod() == AliTRDReconstructor::kLQPID){
+ //if(fkReconstructor->GetPIDMethod() == AliTRDReconstructor::kLQPID){
if(nslices == AliTRDpidUtil::kLQslices){
// calculate mean charge per slice (only LQ PID)
for(int is=0; is<nslices; is++){
Float_t* AliTRDseedV1::GetProbability(Bool_t force)
{
if(!force) return &fProb[0];
- if(!CookPID()) return 0x0;
+ if(!CookPID()) return NULL;
return &fProb[0];
}
// Parameters
//
// Output
-// returns pointer to the probability array and 0x0 if missing DB access
+// returns pointer to the probability array and NULL if missing DB access
//
// Retrieve PID probabilities for e+-, mu+-, K+-, pi+- and p+- from the DB according to tracklet information:
// - estimated momentum at tracklet reference point
return kFALSE;
}
- if (!fReconstructor) {
+ if (!fkReconstructor) {
AliError("Reconstructor not set.");
return kFALSE;
}
// Retrieve the CDB container class with the parametric detector response
- const AliTRDCalPID *pd = calibration->GetPIDObject(fReconstructor->GetPIDMethod());
+ const AliTRDCalPID *pd = calibration->GetPIDObject(fkReconstructor->GetPIDMethod());
if (!pd) {
AliError("No access to AliTRDCalPID object");
return kFALSE;
}
- //AliInfo(Form("Method[%d] : %s", fReconstructor->GetRecoParam() ->GetPIDMethod(), pd->IsA()->GetName()));
+ //AliInfo(Form("Method[%d] : %s", fkReconstructor->GetRecoParam() ->GetPIDMethod(), pd->IsA()->GetName()));
// calculate tracklet length TO DO
Float_t length = (AliTRDgeometry::AmThick() + AliTRDgeometry::DrThick());
/// TMath::Sqrt((1.0 - fSnp[iPlane]*fSnp[iPlane]) / (1.0 + fTgl[iPlane]*fTgl[iPlane]));
//calculate dE/dx
- CookdEdx(fReconstructor->GetNdEdxSlices());
+ CookdEdx(fkReconstructor->GetNdEdxSlices());
// Sets the a priori probabilities
for(int ispec=0; ispec<AliPID::kSPECIES; ispec++)
//GetPadLength()*GetPadLength()/12.;
// insert systematic uncertainties
- if(fReconstructor){
+ if(fkReconstructor){
Double_t sys[15]; memset(sys, 0, 15*sizeof(Double_t));
- fReconstructor->GetRecoParam()->GetSysCovMatrix(sys);
+ fkReconstructor->GetRecoParam()->GetSysCovMatrix(sys);
sy2 += sys[0];
sz2 += sys[1];
}
}
//____________________________________________________________
-Double_t AliTRDseedV1::GetCovSqrt(Double_t *c, Double_t *d)
+Double_t AliTRDseedV1::GetCovSqrt(const Double_t * const c, Double_t *d)
{
// Helper function to calculate the square root of the covariance matrix.
// The input matrix is stored in the vector c and the result in the vector d.
// Author A.Bercuci <A.Bercuci@gsi.de>
// Date Mar 19 2009
- Double_t L[2], // eigenvalues
- V[3]; // eigenvectors
+ Double_t l[2], // eigenvalues
+ v[3]; // eigenvectors
// the secular equation and its solution :
// (c[0]-L)(c[2]-L)-c[1]^2 = 0
// L^2 - L*Tr(c)+DET(c) = 0
// L12 = [Tr(c) +- sqrt(Tr(c)^2-4*DET(c))]/2
- Double_t Tr = c[0]+c[2], // trace
- DET = c[0]*c[2]-c[1]*c[1]; // determinant
- if(TMath::Abs(DET)<1.e-20) return -1.;
- Double_t DD = TMath::Sqrt(Tr*Tr - 4*DET);
- L[0] = .5*(Tr + DD);
- L[1] = .5*(Tr - DD);
- if(L[0]<0. || L[1]<0.) return -1.;
+ Double_t tr = c[0]+c[2], // trace
+ det = c[0]*c[2]-c[1]*c[1]; // determinant
+ if(TMath::Abs(det)<1.e-20) return -1.;
+ Double_t dd = TMath::Sqrt(tr*tr - 4*det);
+ l[0] = .5*(tr + dd);
+ l[1] = .5*(tr - dd);
+ if(l[0]<0. || l[1]<0.) return -1.;
// the sym V matrix
// | v00 v10|
// | v10 v11|
- Double_t tmp = (L[0]-c[0])/c[1];
- V[0] = TMath::Sqrt(1./(tmp*tmp+1));
- V[1] = tmp*V[0];
- V[2] = V[1]*c[1]/(L[1]-c[2]);
+ Double_t tmp = (l[0]-c[0])/c[1];
+ v[0] = TMath::Sqrt(1./(tmp*tmp+1));
+ v[1] = tmp*v[0];
+ v[2] = v[1]*c[1]/(l[1]-c[2]);
// the VD^{1/2}V is:
- L[0] = TMath::Sqrt(L[0]); L[1] = TMath::Sqrt(L[1]);
- d[0] = V[0]*V[0]*L[0]+V[1]*V[1]*L[1];
- d[1] = V[0]*V[1]*L[0]+V[1]*V[2]*L[1];
- d[2] = V[1]*V[1]*L[0]+V[2]*V[2]*L[1];
+ l[0] = TMath::Sqrt(l[0]); l[1] = TMath::Sqrt(l[1]);
+ d[0] = v[0]*v[0]*l[0]+v[1]*v[1]*l[1];
+ d[1] = v[0]*v[1]*l[0]+v[1]*v[2]*l[1];
+ d[2] = v[1]*v[1]*l[0]+v[2]*v[2]*l[1];
return 1.;
}
//____________________________________________________________
-Double_t AliTRDseedV1::GetCovInv(Double_t *c, Double_t *d)
+Double_t AliTRDseedV1::GetCovInv(const Double_t * const c, Double_t *d)
{
// Helper function to calculate the inverse of the covariance matrix.
// The input matrix is stored in the vector c and the result in the vector d.
// Author A.Bercuci <A.Bercuci@gsi.de>
// Date Mar 19 2009
- Double_t Det = c[0]*c[2] - c[1]*c[1];
- if(TMath::Abs(Det)<1.e-20) return 0.;
- Double_t InvDet = 1./Det;
- d[0] = c[2]*InvDet;
- d[1] =-c[1]*InvDet;
- d[2] = c[0]*InvDet;
- return Det;
+ Double_t det = c[0]*c[2] - c[1]*c[1];
+ if(TMath::Abs(det)<1.e-20) return 0.;
+ Double_t invDet = 1./det;
+ d[0] = c[2]*invDet;
+ d[1] =-c[1]*invDet;
+ d[2] = c[0]*invDet;
+ return det;
}
//____________________________________________________________________
//____________________________________________________________________
-Bool_t AliTRDseedV1::AttachClusters(AliTRDtrackingChamber *chamber, Bool_t tilt)
+Bool_t AliTRDseedV1::AttachClusters(AliTRDtrackingChamber *const chamber, Bool_t tilt)
{
//
// Projective algorithm to attach clusters to seeding tracklets. The following steps are performed :
// Debug : level >3
Bool_t kPRINT = kFALSE;
- if(!fReconstructor->GetRecoParam() ){
+ if(!fkReconstructor->GetRecoParam() ){
AliError("Seed can not be used without a valid RecoParam.");
return kFALSE;
}
// Initialize reco params for this tracklet
// 1. first time bin in the drift region
Int_t t0 = 14;
- Int_t kClmin = Int_t(fReconstructor->GetRecoParam() ->GetFindableClusters()*AliTRDtrackerV1::GetNTimeBins());
+ Int_t kClmin = Int_t(fkReconstructor->GetRecoParam() ->GetFindableClusters()*AliTRDtrackerV1::GetNTimeBins());
- Double_t sysCov[5]; fReconstructor->GetRecoParam()->GetSysCovMatrix(sysCov);
+ Double_t sysCov[5]; fkReconstructor->GetRecoParam()->GetSysCovMatrix(sysCov);
Double_t s2yTrk= fRefCov[0],
s2yCl = 0.,
s2zCl = GetPadLength()*GetPadLength()/12.,
syRef = TMath::Sqrt(s2yTrk),
t2 = GetTilt()*GetTilt();
//define roads
- Double_t kroady = 1., //fReconstructor->GetRecoParam() ->GetRoad1y();
+ Double_t kroady = 1., //fkReconstructor->GetRecoParam() ->GetRoad1y();
kroadz = GetPadLength() * 1.5 + 1.;
// define probing cluster (the perfect cluster) and default calibration
Short_t sig[] = {0, 0, 10, 30, 10, 0,0};
AliTRDcluster cp(fDet, 6, 75, 0, sig, 0);
- if(fReconstructor->IsHLT())cp.SetRPhiMethod(AliTRDcluster::kCOG);
+ if(fkReconstructor->IsHLT())cp.SetRPhiMethod(AliTRDcluster::kCOG);
Calibrate();
if(kPRINT) printf("AttachClusters() sy[%f] road[%f]\n", syRef, kroady);
memset(clst, 0, kNrows*kNcls*sizeof(AliTRDcluster*));
// Do cluster projection
- AliTRDcluster *c = 0x0;
- AliTRDchamberTimeBin *layer = 0x0;
+ AliTRDcluster *c = NULL;
+ AliTRDchamberTimeBin *layer = NULL;
Bool_t kBUFFER = kFALSE;
for (Int_t it = 0; it < kNtb; it++) {
if(!(layer = chamber->GetTB(it))) continue;
continue;
}
- if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 3){
- TTreeSRedirector &cstreamer = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+ if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 3){
+ TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
TVectorD vdy(ncl[ir], yres[ir]);
UChar_t stat(0);
if(IsKink()) SETBIT(stat, 0);
Bool_t kFOUND = kFALSE;
for(Int_t ic = ncl[ir]; ic--;){
if(yres[ir][ic] - mean > 3. * syDis){
- clst[ir][ic] = 0x0; continue;
+ clst[ir][ic] = NULL; continue;
}
nrow[nr]++; kFOUND = kTRUE;
}
//
// A.Bercuci <A.Bercuci@gsi.de> Oct 30th 2008
//
- fReconstructor = rec;
+ fkReconstructor = rec;
AliTRDgeometry g;
AliTRDpadPlane *pp = g.GetPadPlane(fDet);
fPad[0] = pp->GetLengthIPad();
Double_t qc[kNclusters], xc[kNclusters], yc[kNclusters], zc[kNclusters], sy[kNclusters];
Int_t n = 0;
- AliTRDcluster *c=0x0, **jc = &fClusters[0];
+ AliTRDcluster *c=NULL, **jc = &fClusters[0];
for (Int_t ic=0; ic<kNtb; ic++, ++jc) {
xc[ic] = -1.;
yc[ic] = 999.;
c->SetSigmaY2(fS2PRF, fDiffT, fExB, xc[n], zcorr?zt:-1., dydx);
sy[n] = TMath::Sqrt(c->GetSigmaY2());
- yc[n] = fReconstructor->UseGAUS() ?
+ yc[n] = fkReconstructor->UseGAUS() ?
c->GetYloc(y0, sy[n], GetPadWidth()): c->GetY();
zc[n] = c->GetZ();
//optional tilt correction
AliTRDseedV1(const AliTRDseedV1 &ref);
AliTRDseedV1& operator=(const AliTRDseedV1 &ref);
- Bool_t AttachClusters(AliTRDtrackingChamber *chamber, Bool_t tilt = kFALSE);
+ Bool_t AttachClusters(AliTRDtrackingChamber *const chamber, Bool_t tilt = kFALSE);
void Bootstrap(const AliTRDReconstructor *rec);
void Calibrate();
void CookdEdx(Int_t nslices);
void GetCovAt(Double_t x, Double_t *cov) const;
void GetCovXY(Double_t *cov) const { memcpy(cov, &fCov[0], 3*sizeof(Double_t));}
void GetCovRef(Double_t *cov) const { memcpy(cov, &fRefCov, 7*sizeof(Double_t));}
- static Double_t GetCovSqrt(Double_t *c, Double_t *d);
- static Double_t GetCovInv(Double_t *c, Double_t *d);
+ static Double_t GetCovSqrt(const Double_t * const c, Double_t *d);
+ static Double_t GetCovInv(const Double_t * const c, Double_t *d);
Float_t GetdX() const { return fdX;}
- Float_t* GetdEdx() { return &fdEdx[0];}
- Float_t GetdQdl(Int_t ic, Float_t *dx=0x0) const;
+ const Float_t* GetdEdx() const { return &fdEdx[0];}
+ Float_t GetdQdl(Int_t ic, Float_t *dx=NULL) const;
Float_t GetdYdX() const { return fYfit[1]; }
Float_t GetdZdX() const { return fZref[1]; }
Int_t GetdY() const { return Int_t(GetY()/0.014);}
Int_t GetDetector() const { return fDet;}
void GetCalibParam(Float_t &exb, Float_t &vd, Float_t &t0, Float_t &s2, Float_t &dl, Float_t &dt) const {
exb = fExB; vd = fVD; t0 = fT0; s2 = fS2PRF; dl = fDiffL; dt = fDiffT;}
- AliTRDcluster* GetClusters(Int_t i) const { return i<0 || i>=kNclusters ? 0x0 : fClusters[i];}
+ AliTRDcluster* GetClusters(Int_t i) const { return i<0 || i>=kNclusters ? NULL: fClusters[i];}
static TLinearFitter* GetFitterY();
static TLinearFitter* GetFitterZ();
Int_t GetIndexes(Int_t i) const{ return i<0 || i>=kNclusters ? -1 : fIndexes[i];}
Int_t GetLabels(Int_t i) const { return fLabels[i];}
- Float_t GetMomentum(Float_t *err = 0x0) const;
+ Float_t GetMomentum(Float_t *err = NULL) const;
Int_t GetN() const { return (Int_t)fN&0x1f;}
Int_t GetN2() const { return GetN();}
Int_t GetNUsed() const { return Int_t((fN>>5)&0x1f);}
void SetTilt(Float_t tilt) { fPad[2] = tilt; }
void SetDetector(Int_t d) { fDet = d; }
void SetDX(Float_t inDX) { fdX = inDX;}
- void SetReconstructor(const AliTRDReconstructor *rec) {fReconstructor = rec;}
+ void SetReconstructor(const AliTRDReconstructor *rec) {fkReconstructor = rec;}
void SetX0(Float_t x0) { fX0 = x0; }
void SetYref(Int_t i, Float_t y) { fYref[i] = y;}
void SetZref(Int_t i, Float_t z) { fZref[i] = z;}
inline void SetNUsed(Int_t n);
inline void SetNShared(Int_t n);
- const AliTRDReconstructor *fReconstructor;//! local reconstructor
+ const AliTRDReconstructor *fkReconstructor;//! local reconstructor
AliTRDcluster **fClusterIter; //! clusters iterator
Int_t fIndexes[kNclusters]; //! Indexes
Float_t fExB; //! tg(a_L) @ tracklet location
Int_t fLabels[3]; // most frequent MC labels and total number of different labels
Double_t fRefCov[7]; // covariance matrix of the track in the yz plane + the rest of the diagonal elements
Double_t fCov[3]; // covariance matrix of the tracklet in the xy plane
- static TLinearFitter *fgFitterY;
- static TLinearFitter *fgFitterZ;
+ static TLinearFitter *fgFitterY; // Linear Fitter for tracklet fit in xy-plane
+ static TLinearFitter *fgFitterZ; // Linear Fitter for tracklet fit in xz-plane
ClassDef(AliTRDseedV1, 7) // The offline TRD tracklet
};
fZref[1] = rieman->GetDZat(fX0);
fYref[0] = rieman->GetYat(fX0);
fYref[1] = rieman->GetDYat(fX0);
- if(fReconstructor && fReconstructor->IsHLT()){
+ if(fkReconstructor && fkReconstructor->IsHLT()){
fRefCov[0] = 1;
fRefCov[2] = 10;
}else{
}
return *fClusterIter;
}
- return 0x0;
+ return NULL;
}
//____________________________________________________________
}
return *fClusterIter;
}
- return 0x0;
+ return NULL;
}
//____________________________________________________________
#include "AliTRDgeometry.h"
#include "AliTRDcluster.h"
#include "AliTRDtrack.h"
+#include "AliTRDtracklet.h"
#include "AliTRDcalibDB.h"
-#include "Cal/AliTRDCalPID.h"
ClassImp(AliTRDtrack)
// //
// Represents a reconstructed TRD track //
// Local TRD Kalman track //
+// Part of the old TRD tracking code //
// //
///////////////////////////////////////////////////////////////////////////////
//
for (Int_t i = 0; i < kNplane; i++) {
- for (Int_t j = 0; j < kNslice; j++) {
+ for (Int_t j = 0; j < AliTRDCalPID::kNSlicesLQ; j++) {
fdEdxPlane[i][j] = 0.0;
}
fTimBinPlane[i] = -1;
fClusters[0] = c;
for (Int_t i = 0; i < kNplane; i++) {
- for (Int_t j = 0; j < kNslice; j++) {
+ for (Int_t j = 0; j < AliTRDCalPID::kNSlicesLQ; j++) {
fdEdxPlane[i][j] = 0.0;
}
fTimBinPlane[i] = -1;
//
for (Int_t i = 0; i < kNplane; i++) {
- for (Int_t j = 0; j < kNslice; j++) {
+ for (Int_t j = 0; j < AliTRDCalPID::kNSlicesLQ; j++) {
fdEdxPlane[i][j] = t.fdEdxPlane[i][j];
}
fTimBinPlane[i] = t.fTimBinPlane[i];
SetNumberOfClusters(0);
for (Int_t i = 0; i < kNplane; i++) {
- for (Int_t j = 0; j < kNslice; j++) {
+ for (Int_t j = 0; j < AliTRDCalPID::kNSlicesLQ; j++) {
fdEdxPlane[i][j] = 0.0;
}
fTimBinPlane[i] = -1;
}
for (Int_t i = 0; i < kNplane; i++) {
- for (Int_t j = 0; j < kNslice; j++) {
+ for (Int_t j = 0; j < AliTRDCalPID::kNSlicesLQ; j++) {
fdEdxPlane[i][j] = t.GetTRDslice(i,j);
}
fTimBinPlane[i] = t.GetTRDTimBin(i);
// Max charge in chamber
Double_t maxcharge[kNplane];
// Number of clusters attached to track per chamber and slice
- Int_t nCluster[kNplane][kNslice];
+ Int_t nCluster[kNplane][AliTRDCalPID::kNSlicesLQ];
// Number of time bins in chamber
Int_t ntb = AliTRDcalibDB::Instance()->GetNumberOfTimeBins();
Int_t plane; // Plane of current cluster
for (Int_t iPlane = 0; iPlane < kNplane; iPlane++) {
fTimBinPlane[iPlane] = -1;
maxcharge[iPlane] = 0.0;
- for (Int_t iSlice = 0; iSlice < kNslice; iSlice++) {
+ for (Int_t iSlice = 0; iSlice < AliTRDCalPID::kNSlicesLQ; iSlice++) {
fdEdxPlane[iPlane][iSlice] = 0.0;
nCluster[iPlane][iSlice] = 0;
}
continue;
}
- slice = tb * kNslice / ntb;
+ slice = tb * AliTRDCalPID::kNSlicesLQ / ntb;
fdEdxPlane[plane][slice] += fdQdl[iClus];
if (fdQdl[iClus] > maxcharge[plane]) {
// Normalize fdEdxPlane to number of clusters and set track segments
for (Int_t iPlane = 0; iPlane < kNplane; iPlane++) {
- for (Int_t iSlice = 0; iSlice < kNslice; iSlice++) {
+ for (Int_t iSlice = 0; iSlice < AliTRDCalPID::kNSlicesLQ; iSlice++) {
if (nCluster[iPlane][iSlice]) {
fdEdxPlane[iPlane][iSlice] /= nCluster[iPlane][iSlice];
}
// Reset class and local contors/variables
for (Int_t iPlane = 0; iPlane < kNplane; iPlane++){
- for (Int_t iSlice = 0; iSlice < kNMLPslice; iSlice++) {
- *(dedx + (kNMLPslice * iPlane) + iSlice) = 0.0;
+ for (Int_t iSlice = 0; iSlice < AliTRDCalPID::kNSlicesNN; iSlice++) {
+ *(dedx + (AliTRDCalPID::kNSlicesNN * iPlane) + iSlice) = 0.0;
}
}
continue;
}
- slice = tb * kNMLPslice / ntb;
+ slice = tb * AliTRDCalPID::kNSlicesNN / ntb;
- *(dedx+(kNMLPslice * plane) + slice) += fdQdl[iClus]/kMLPscale;
+ *(dedx+(AliTRDCalPID::kNSlicesNN * plane) + slice) += fdQdl[iClus]/kMLPscale;
} // End of loop over cluster
}
// Calculate the input for the NN if fPIDmethod is kNN
- Float_t ldEdxNN[AliTRDgeometry::kNlayer * kNMLPslice], *dedx = 0x0;
+ Float_t ldEdxNN[AliTRDgeometry::kNlayer * AliTRDCalPID::kNSlicesNN], *dedx = 0x0;
if(fPIDmethod == kNN) {
CookdEdxNN(&ldEdxNN[0]);
}
dedx = fdEdxPlane[iPlane];
break;
case kNN:
- dedx = &ldEdxNN[iPlane*kNMLPslice];
+ dedx = &ldEdxNN[iPlane*AliTRDCalPID::kNSlicesNN];
break;
}
fPID[iSpecies] *= pd->GetProbability(iSpecies, fMom[iPlane], dedx, length, iPlane);
//_____________________________________________________________________________
Bool_t AliTRDtrack::Update(const AliTRDcluster *c, Double_t chisq
- , Int_t index, Double_t h01)
+ , Int_t index, Double_t h01)
{
//
// Assignes the found cluster <c> to the track and updates
// //
///////////////////////////////////////////////////////////////////////////////
+#ifndef ALIESDTRACK_H
#include "AliESDtrack.h"
+#endif
+
+#ifndef ALIKALMANTRACK_H
#include "AliKalmanTrack.h"
+#endif
-#include "AliTRDtracklet.h"
-#ifndef ALITRDSEEDV1_H
-#include "AliTRDseedV1.h"
+#ifndef ALITRDCALPID_H
+#include "Cal/AliTRDCalPID.h"
+#endif
+
+#ifndef ALITRDTRACKLET
+#include "AliTRDtracklet.h"
#endif
class AliTrackReference;
, kNstacks = 90
, kNplane = AliESDtrack::kTRDnPlanes
, kNcham = 5
- , kNsect = 18
- , kNslice = 3
- , kNMLPslice = 8 };
+ , kNsect = 18 };
enum AliTRDPIDMethod {
kNN = 0
Int_t GetPIDTimBin(Int_t i) const { return fTimBinPlane[i]; }
Double_t GetLikelihoodElectron() const { return fLhElectron; }
Int_t GetSeedLabel() const { return fSeedLab; }
- Int_t *GetBackupIndexes() { return fIndexBackup; }
- Int_t *GetIndexes() { return fIndex; }
+ const Int_t *GetBackupIndexes() const { return fIndexBackup; }
+ const Int_t *GetIndexes() const { return fIndex; }
Int_t GetProlongation(Double_t xk
, Double_t &y
, Double_t &z);
AliTRDtracklet GetTracklets(Int_t i) const { return fTracklets[i]; }
Float_t GetBudget(Int_t i) const { return fBudget[i]; }
Float_t GetChi2Last() const { return fChi2Last; }
- AliTRDtrack *GetBackupTrack() { return fBackupTrack; }
+ AliTRDtrack *GetBackupTrack() const { return fBackupTrack; }
// dummy to bridge the function in AliTRDtrackV1
//Int_t GetNumberOfClusters() const { printf("AliTRDtrack::GetNumberOfClusters()\n");
// return AliKalmanTrack::GetNumberOfClusters(); }
void SetNExpectedLast(Int_t nexp) { fNExpectedLast = nexp; }
void SetChi2Last(Float_t chi2) { fChi2Last = chi2; }
void SetTracklets(Int_t i, AliTRDtracklet t) { fTracklets[i] = t; }
- void SetBudget(Int_t i, Float_t budget) { fBudget[i] = budget; }
+ void SetBudget(Int_t i, Float_t budget) { fBudget[i] = budget; }
void SetPIDMethod(AliTRDPIDMethod method) { fPIDmethod = method; }
- void SetTrackSegmentDirMom(const Int_t plane);
+ void SetTrackSegmentDirMom(const Int_t plane);
void CookdEdx(Double_t low = 0.05, Double_t up = 0.7);
void CookdEdxTimBin(const Int_t tid);
Bool_t CookPID(Int_t &pidQuality);
- void SetCluster(AliTRDcluster* cl
+ void SetCluster(AliTRDcluster * const cl
, Int_t index = -1) { fClusters[(index == -1)
? GetNumberOfClusters()-1
: index] = cl; }
protected:
- AliTRDtrack &operator=(const AliTRDtrack &t);
+ AliTRDtrack &operator=(const AliTRDtrack &t);
- void CookdEdxNN(Float_t *dedx);
+ void CookdEdxNN(Float_t *dedx);
Double_t GetBz() const;
Bool_t Update(const AliCluster */*c*/, Double_t /*chi2*/, Int_t /*idx*/) { return 0; }
Double_t GetPredictedChi2(const AliCluster* /*c*/) const { return 0.0; }
Int_t fSeedLab; // Track label taken from seeding
Float_t fdEdx; // dE/dx (truncated mean)
Float_t fDE; // Integrated delta energy
- Float_t fdEdxPlane[kNplane][kNslice]; // dE/dx from all 6 planes in 3 slices each
+ Float_t fdEdxPlane[kNplane][AliTRDCalPID::kNSlicesLQ]; // dE/dx from all 6 planes in 3 slices each
Int_t fTimBinPlane[kNplane]; // Time bin of Max cluster from all 6 planes
UChar_t fPIDquality; // No of planes used for PID calculation
Double_t fPID[AliPID::kSPECIES]; // PID probabilities
- Float_t fMom[kNplane]; // Track momentum at chamber entrance
- Float_t fSnp[kNplane]; // Track direction
- Float_t fTgl[kNplane]; // Track direction
- AliTRDcluster *fClusters[kMAXCLUSTERSPERTRACK]; // List of assigned clusters
+ Float_t fMom[kNplane]; // Track momentum at chamber entrance
+ Float_t fSnp[kNplane]; // Track direction
+ Float_t fTgl[kNplane]; // Track direction
+ AliTRDcluster *fClusters[kMAXCLUSTERSPERTRACK]; // List of assigned clusters
Bool_t fClusterOwner; // Indicates the track is owner of cluster
- AliTRDPIDMethod fPIDmethod; // Switch between different PID methods
+ AliTRDPIDMethod fPIDmethod; // Switch between different PID methods
Bool_t fStopped; // Track stop indication
Int_t fIndex[kMAXCLUSTERSPERTRACK]; // Global indexes of clusters
Int_t fIndexBackup[kMAXCLUSTERSPERTRACK]; // Backup indexes of clusters - used in iterations
Float_t fdQdl[kMAXCLUSTERSPERTRACK]; // Cluster amplitudes corrected for track angles
- Float_t fLhElectron; // Likelihood to be an electron
+ Float_t fLhElectron; // Likelihood to be an electron
Int_t fNWrong; // Number of wrong clusters
Int_t fNRotate; // Number of rotation
Int_t fNCross; // Number of the cross materials
Int_t fNExpectedLast; // Number of expected clusters on last 2 layers
Int_t fNdedx; // Number of clusters for dEdx measurment
Float_t fChi2Last; // Chi2 in the last 2 layers
- AliTRDtracklet fTracklets[6]; // Tracklets
+ AliTRDtracklet fTracklets[6]; // Tracklets
Float_t fBudget[3]; // Integrated material budget
- AliTRDtrack *fBackupTrack; //! Backup track
+ AliTRDtrack *fBackupTrack; //! Backup track
- Int_t fTrackletIndex[6]; // Tracklets index in the tracker list
- AliTRDseedV1 fTracklet[6]; // Tracklets array defining the track
+ Int_t fTrackletIndex[6]; // Tracklets index in the tracker list
ClassDef(AliTRDtrack,9) // TRD reconstructed tracks
#include "TClass.h"
#include "TH1F.h"
+#include "AliESDTrdTrack.h"
#include "AliLog.h"
#include "AliTRDgtuParam.h"
#include "AliTRDtrackGTU.h"
delete fTracklets;
}
-void AliTRDtrackGTU::AddTracklet(AliTRDtrackletGTU *tracklet, Int_t layer)
+void AliTRDtrackGTU::AddTracklet(const AliTRDtrackletGTU * const tracklet, Int_t layer)
{
// add a tracklet to this track
#include "TClonesArray.h"
#include "AliTRDtrackletGTU.h"
-#include "AliESDTrdTrack.h"
+class AliESDTrdTrack;
class AliTRDtrackGTU : public TObject {
public:
Int_t GetYapprox();
- void AddTracklet(AliTRDtrackletGTU *tracklet, Int_t layer);
+ void AddTracklet(const AliTRDtrackletGTU * const tracklet, Int_t layer);
void SetStack(Int_t stack) { fStack = stack; }
void SetSector(Int_t sector) { fSector = sector; }
AliTRDtrackV1::AliTRDtrackV1() : AliKalmanTrack()
,fStatus(0)
,fDE(0.)
- ,fReconstructor(0x0)
- ,fBackupTrack(0x0)
- ,fTrackLow(0x0)
- ,fTrackHigh(0x0)
+ ,fkReconstructor(NULL)
+ ,fBackupTrack(NULL)
+ ,fTrackLow(NULL)
+ ,fTrackHigh(NULL)
{
//
// Default constructor
for(int ip=0; ip<kNplane; ip++){
fTrackletIndex[ip] = 0xffff;
- fTracklet[ip] = 0x0;
+ fTracklet[ip] = NULL;
}
}
AliTRDtrackV1::AliTRDtrackV1(const AliTRDtrackV1 &ref) : AliKalmanTrack(ref)
,fStatus(ref.fStatus)
,fDE(ref.fDE)
- ,fReconstructor(ref.fReconstructor)
- ,fBackupTrack(0x0)
- ,fTrackLow(0x0)
- ,fTrackHigh(0x0)
+ ,fkReconstructor(ref.fkReconstructor)
+ ,fBackupTrack(NULL)
+ ,fTrackLow(NULL)
+ ,fTrackHigh(NULL)
{
//
// Copy constructor
AliTRDtrackV1::AliTRDtrackV1(const AliESDtrack &t) : AliKalmanTrack()
,fStatus(0)
,fDE(0.)
- ,fReconstructor(0x0)
- ,fBackupTrack(0x0)
- ,fTrackLow(0x0)
- ,fTrackHigh(0x0)
+ ,fkReconstructor(NULL)
+ ,fBackupTrack(NULL)
+ ,fTrackLow(NULL)
+ ,fTrackHigh(NULL)
{
//
// Constructor from AliESDtrack
Int_t ti[kNplane]; t.GetTRDtracklets(&ti[0]);
for(int ip=0; ip<kNplane; ip++){
fTrackletIndex[ip] = ti[ip] < 0 ? 0xffff : ti[ip];
- fTracklet[ip] = 0x0;
+ fTracklet[ip] = NULL;
}
for(int i =0; i<3; i++) fBudget[i] = 0.;
}
//_______________________________________________________________
-AliTRDtrackV1::AliTRDtrackV1(AliTRDseedV1 *trklts, const Double_t p[5], const Double_t cov[15]
+AliTRDtrackV1::AliTRDtrackV1(const AliTRDseedV1 * const trklts, const Double_t p[5], const Double_t cov[15]
, Double_t x, Double_t alpha) : AliKalmanTrack()
,fStatus(0)
,fDE(0.)
- ,fReconstructor(0x0)
- ,fBackupTrack(0x0)
- ,fTrackLow(0x0)
- ,fTrackHigh(0x0)
+ ,fkReconstructor(NULL)
+ ,fBackupTrack(NULL)
+ ,fTrackLow(NULL)
+ ,fTrackHigh(NULL)
{
//
// The stand alone tracking constructor
Int_t ncls = 0;
for(int iplane=0; iplane<kNplane; iplane++){
fTrackletIndex[iplane] = 0xffff;
- if(!trklts[iplane].IsOK()) fTracklet[iplane] = 0x0;
+ if(!trklts[iplane].IsOK()) fTracklet[iplane] = NULL;
else{
- fTracklet[iplane] = &trklts[iplane];
+ fTracklet[iplane] = const_cast<AliTRDseedV1 *>(&trklts[iplane]);
ncls += fTracklet[iplane]->GetN();
}
}
//AliInfo("");
//printf("I-AliTRDtrackV1::~AliTRDtrackV1() : Owner[%s]\n", TestBit(kOwner)?"YES":"NO");
- if(fBackupTrack) delete fBackupTrack; fBackupTrack = 0x0;
+ if(fBackupTrack) delete fBackupTrack; fBackupTrack = NULL;
- if(fTrackLow) delete fTrackLow; fTrackLow = 0x0;
- if(fTrackHigh) delete fTrackHigh; fTrackHigh = 0x0;
+ if(fTrackLow) delete fTrackLow; fTrackLow = NULL;
+ if(fTrackHigh) delete fTrackHigh; fTrackHigh = NULL;
for(Int_t ip=0; ip<kNplane; ip++){
if(TestBit(kOwner) && fTracklet[ip]) delete fTracklet[ip];
- fTracklet[ip] = 0x0;
+ fTracklet[ip] = NULL;
fTrackletIndex[ip] = 0xffff;
}
}
Bool_t labelAdded;
Int_t label;
- AliTRDcluster *c = 0x0;
+ AliTRDcluster *c = NULL;
for (Int_t ip = 0; ip < kNplane; ip++) {
if(fTrackletIndex[ip] == 0xffff) continue;
for (Int_t ic = 0; ic < AliTRDseedV1::kNclusters; ic++) {
// Retrieve number of tracklets used for PID calculation.
UChar_t nPID = 0;
- Float_t *prob = 0x0;
+ Float_t *prob = NULL;
for(int ip=0; ip<kNplane; ip++){
if(fTrackletIndex[ip] == 0xffff) continue;
if(!fTracklet[ip]->IsOK()) continue;
UChar_t fPIDquality = 0;
// steer PID calculation @ tracklet level
- Float_t *prob = 0x0;
+ Float_t *prob = NULL;
for(int ip=0; ip<kNplane; ip++){
if(fTrackletIndex[ip] == 0xffff) continue;
if(!fTracklet[ip]->IsOK()) continue;
//_______________________________________________________________
AliTRDcluster* AliTRDtrackV1::GetCluster(Int_t id)
{
+ // Get the cluster at a certain position in the track
Int_t n = 0;
for(Int_t ip=0; ip<kNplane; ip++){
if(!fTracklet[ip]) continue;
n+=fTracklet[ip]->GetN();
continue;
}
- AliTRDcluster *c = 0x0;
+ AliTRDcluster *c = NULL;
for(Int_t ic=AliTRDseedV1::kNclusters; ic--;){
if(!(c = fTracklet[ip]->GetClusters(ic))) continue;
return c;
}
}
- return 0x0;
+ return NULL;
}
//_______________________________________________________________
Int_t AliTRDtrackV1::GetClusterIndex(Int_t id) const
{
+ // Get the cluster index at a certain position in the track
Int_t n = 0;
for(Int_t ip=0; ip<kNplane; ip++){
if(!fTracklet[ip]) continue;
n+=fTracklet[ip]->GetN();
continue;
}
- AliTRDcluster *c = 0x0;
+ AliTRDcluster *c = NULL;
for(Int_t ic=AliTRDseedV1::kNclusters; ic--;){
if(!(c = fTracklet[ip]->GetClusters(ic))) continue;
//_______________________________________________________________
Bool_t AliTRDtrackV1::IsEqual(const TObject *o) const
{
+ // Checks whether two tracks are equal
if (!o) return kFALSE;
const AliTRDtrackV1 *inTrack = dynamic_cast<const AliTRDtrackV1*>(o);
if (!inTrack) return kFALSE;
//_______________________________________________________________
Bool_t AliTRDtrackV1::IsElectron() const
{
- if(GetPID(0) > fReconstructor->GetRecoParam()->GetPIDThreshold(GetP())) return kTRUE;
+ if(GetPID(0) > fkReconstructor->GetRecoParam()->GetPIDThreshold(GetP())) return kTRUE;
return kFALSE;
}
//_____________________________________________________________________________
void AliTRDtrackV1::Print(Option_t *o) const
{
+ // Print track status
AliInfo(Form("PID [%4.1f %4.1f %4.1f %4.1f %4.1f]", 1.E2*fPID[0], 1.E2*fPID[1], 1.E2*fPID[2], 1.E2*fPID[3], 1.E2*fPID[4]));
AliInfo(Form("Material[%5.2f %5.2f %5.2f]", fBudget[0], fBudget[1], fBudget[2]));
}
//_______________________________________________________________
-void AliTRDtrackV1::SetTracklet(AliTRDseedV1 *trklt, Int_t index)
+void AliTRDtrackV1::SetTracklet(AliTRDseedV1 *const trklt, Int_t index)
{
//
// Set the tracklets
{
if(plane<0 && plane >= kNplane) return;
fTrackletIndex[plane] = 0xffff;
- fTracklet[plane] = 0x0;
+ fTracklet[plane] = NULL;
}
// Update the TRD PID information in the ESD track
//
- Int_t nslices = fReconstructor->IsEightSlices() ? (Int_t)AliTRDpidUtil::kNNslices : (Int_t)AliTRDpidUtil::kLQslices;
+ Int_t nslices = fkReconstructor->IsEightSlices() ? (Int_t)AliTRDpidUtil::kNNslices : (Int_t)AliTRDpidUtil::kLQslices;
// number of tracklets used for PID calculation
UChar_t nPID = GetNumberOfTrackletsPID();
// number of tracklets attached to the track
for (Int_t ip = 0; ip < kNplane; ip++) {
if(fTrackletIndex[ip] == 0xffff) continue;
if(!fTracklet[ip]->HasPID()) continue;
- Float_t *dedx = fTracklet[ip]->GetdEdx();
+ const Float_t *dedx = fTracklet[ip]->GetdEdx();
for (Int_t js = 0; js < nslices; js++, dedx++) track->SetTRDslice(*dedx, ip, js);
p = fTracklet[ip]->GetMomentum(&sp); spd = sp;
track->SetTRDmomentum(p, ip, &spd);
// //
///////////////////////////////////////////////////////////////////////////////
-#ifndef ALIKALMANTRACK_H
+//#ifndef ALIKALMANTRACK_H
#include "AliKalmanTrack.h"
-#endif
-
-#ifndef ALIESDTRACK_H
-#include "AliESDtrack.h"
-#endif
+//#endif
-#ifndef ALITRDSEEDV1_H
+//#ifndef ALITRDSEEDV1_H
#include "AliTRDseedV1.h"
-#endif
+//#endif
class AliTRDcluster;
class AliESDtrack;
};
AliTRDtrackV1();
- AliTRDtrackV1(AliTRDseedV1 *trklts, const Double_t p[5], const Double_t cov[15], Double_t x, Double_t alpha);
+ AliTRDtrackV1(const AliTRDseedV1 * const trklts, const Double_t p[5], const Double_t cov[15], Double_t x, Double_t alpha);
AliTRDtrackV1(const AliESDtrack &ref);
AliTRDtrackV1(const AliTRDtrackV1 &ref);
virtual ~AliTRDtrackV1();
Int_t GetProlongation(Double_t xk, Double_t &y, Double_t &z);
inline UChar_t GetStatusTRD(Int_t ly=-1) const;
Int_t GetSector() const;
- AliTRDseedV1* GetTracklet(Int_t plane) const {return plane >=0 && plane <kNplane ? fTracklet[plane] : 0x0;}
+ AliTRDseedV1* GetTracklet(Int_t plane) const {return plane >=0 && plane <kNplane ? fTracklet[plane] : NULL;}
Int_t GetTrackletIndex(Int_t plane) const { return (plane>=0 && plane<kNplane) ? fTrackletIndex[plane] : -1;}
AliExternalTrackParam*
GetTrackLow() const { return fTrackLow;}
AliExternalTrackParam*
GetTrackHigh() const { return fTrackHigh;}
- UShort_t* GetTrackletIndexes() { return &fTrackletIndex[0];}
+ const UShort_t* GetTrackletIndexes() const { return &fTrackletIndex[0];}
Bool_t IsEqual(const TObject *inTrack) const;
Bool_t IsKink() const { return TestBit(kKink);}
UChar_t SetNumberOfTrackletsPID(Bool_t recalc);
void SetOwner();
void SetPID(Short_t is, Double_t inPID){if (is >=0 && is < AliPID::kSPECIES) fPID[is]=inPID;};
- void SetPIDquality(UChar_t /*inPIDquality*/){/*fPIDquality = inPIDquality*/;};
+ void SetPIDquality(UChar_t /*inPIDquality*/) const {/*fPIDquality = inPIDquality*/;};
inline void SetStatus(UChar_t stat, Int_t ly=-1);
void SetStopped(Bool_t stop) {SetBit(kStopped, stop);}
- void SetTracklet(AliTRDseedV1 *trklt, Int_t index);
+ void SetTracklet(AliTRDseedV1 *const trklt, Int_t index);
void SetTrackLow();
- void SetTrackHigh(const AliExternalTrackParam *op=0x0);
+ void SetTrackHigh(const AliExternalTrackParam *op=NULL);
inline void SetReconstructor(const AliTRDReconstructor *rec);
inline Float_t StatusForTOF();
void UnsetTracklet(Int_t plane);
Bool_t Update(Double_t *p, Double_t *cov, Double_t chi2);
- Bool_t Update(const AliCluster *, Double_t, Int_t) { return kFALSE; };
+ Bool_t Update(const AliCluster *, Double_t, Int_t) { return kFALSE; };
void UpdateESDtrack(AliESDtrack *t);
private:
Double32_t fPID[AliPID::kSPECIES]; // PID probabilities
Double32_t fBudget[3]; // Integrated material budget
Double32_t fDE; // Integrated delta energy
- const AliTRDReconstructor *fReconstructor;//! reconstructor link
+ const AliTRDReconstructor *fkReconstructor;//! reconstructor link
AliTRDtrackV1 *fBackupTrack; //! Backup track
AliTRDseedV1 *fTracklet[kNplane]; // Tracklets array defining the track
AliExternalTrackParam *fTrackLow; // parameters of the track which enter TRD from below (TPC)
if(!fTracklet[ip]) continue;
fTracklet[ip]->SetReconstructor(rec);
}
- fReconstructor = rec;
+ fkReconstructor = rec;
}
//____________________________________________________
#include "AliESDEvent.h"
#include "AliESDtrack.h"
-#include "AliAlignObj.h"
+//#include "AliAlignObj.h"
+#include "AliGeomManager.h"
#include "AliRieman.h"
#include "AliTrackPointArray.h"
,fTimeBinsPerPlane(0)
,fAddTRDseeds(kFALSE)
,fNoTilt(kFALSE)
- ,fHBackfit(0x0)
- ,fHClSearch(0x0)
- ,fHRefit(0x0)
- ,fHX(0x0)
- ,fHNCl(0x0)
- ,fHNClTrack(0x0)
- ,fHMinYPos(0x0)
- ,fHMinYNeg(0x0)
- ,fHMinZ(0x0)
- ,fHMinD(0x0)
- ,fHDeltaX(0x0)
- ,fHXCl(0x0)
+ ,fHBackfit(NULL)
+ ,fHClSearch(NULL)
+ ,fHRefit(NULL)
+ ,fHX(NULL)
+ ,fHNCl(NULL)
+ ,fHNClTrack(NULL)
+ ,fHMinYPos(NULL)
+ ,fHMinYNeg(NULL)
+ ,fHMinZ(NULL)
+ ,fHMinD(NULL)
+ ,fHDeltaX(NULL)
+ ,fHXCl(NULL)
,fDebugStreamer(0)
{
//
,fTimeBinsPerPlane(0)
,fAddTRDseeds(kFALSE)
,fNoTilt(kFALSE)
- ,fHBackfit(0x0)
- ,fHClSearch(0x0)
- ,fHRefit(0x0)
- ,fHX(0x0)
- ,fHNCl(0x0)
- ,fHNClTrack(0x0)
- ,fHMinYPos(0x0)
- ,fHMinYNeg(0x0)
- ,fHMinZ(0x0)
- ,fHMinD(0x0)
- ,fHDeltaX(0x0)
- ,fHXCl(0x0)
+ ,fHBackfit(NULL)
+ ,fHClSearch(NULL)
+ ,fHRefit(NULL)
+ ,fHX(NULL)
+ ,fHNCl(NULL)
+ ,fHNClTrack(NULL)
+ ,fHMinYPos(NULL)
+ ,fHMinYNeg(NULL)
+ ,fHMinZ(NULL)
+ ,fHMinD(NULL)
+ ,fHDeltaX(NULL)
+ ,fHXCl(NULL)
,fDebugStreamer(0)
{
//
,fTimeBinsPerPlane(0)
,fAddTRDseeds(kFALSE)
,fNoTilt(kFALSE)
- ,fHBackfit(0x0)
- ,fHClSearch(0x0)
- ,fHRefit(0x0)
- ,fHX(0x0)
- ,fHNCl(0x0)
- ,fHNClTrack(0x0)
- ,fHMinYPos(0x0)
- ,fHMinYNeg(0x0)
- ,fHMinZ(0x0)
- ,fHMinD(0x0)
- ,fHDeltaX(0x0)
- ,fHXCl(0x0)
+ ,fHBackfit(NULL)
+ ,fHClSearch(NULL)
+ ,fHRefit(NULL)
+ ,fHX(NULL)
+ ,fHNCl(NULL)
+ ,fHNClTrack(NULL)
+ ,fHMinYPos(NULL)
+ ,fHMinYNeg(NULL)
+ ,fHMinZ(NULL)
+ ,fHMinD(NULL)
+ ,fHDeltaX(NULL)
+ ,fHXCl(NULL)
,fDebugStreamer(0)
{
//
}
//_____________________________________________________________________________
-Bool_t AliTRDtracker::AdjustSector(AliTRDtrack *track)
+Bool_t AliTRDtracker::AdjustSector(AliTRDtrack* const track) const
{
//
// Rotates the track when necessary
}
//_____________________________________________________________________________
-AliTRDcluster *AliTRDtracker::GetCluster(AliTRDtrack *track, Int_t plane
+AliTRDcluster *AliTRDtracker::GetCluster(AliTRDtrack * const track, Int_t plane
, Int_t timebin, UInt_t &index)
{
//
//
AliTRDcluster *cl =0;
- Int_t *indexes = track->GetBackupIndexes();
+ const Int_t *indexes = track->GetBackupIndexes();
for (UInt_t i = 0; i < kMaxTimeBinIndex; i++) {
if (indexes[i] == 0) {
}
//_____________________________________________________________________________
-Int_t AliTRDtracker::GetLastPlane(AliTRDtrack *track)
+Int_t AliTRDtracker::GetLastPlane(AliTRDtrack * const track)
{
//
// Return last updated plane
//
Int_t lastplane = 0;
- Int_t *indexes = track->GetBackupIndexes();
+ const Int_t *indexes = track->GetBackupIndexes();
for (UInt_t i = 0; i < kMaxTimeBinIndex; i++) {
AliTRDcluster *cli = (AliTRDcluster *) fClusters->UncheckedAt(indexes[i]);
seed->UpdateTrackParams(track,AliESDtrack::kTRDout);
fHBackfit->Fill(10);
- seed->SetNumberOfTRDslices(AliTRDtrack::kNslice);
+ seed->SetNumberOfTRDslices(AliTRDCalPID::kNSlicesLQ);
for (Int_t i = 0; i < AliTRDtrack::kNplane; i++) {
- for (Int_t j = 0; j < AliTRDtrack::kNslice; j++) {
+ for (Int_t j = 0; j < AliTRDCalPID::kNSlicesLQ; j++) {
seed->SetTRDslice(track->GetPIDsignals(i,j),i,j);
}
seed->SetTRDTimBin(track->GetPIDTimBin(i),i);
//seed->SetStatus(AliESDtrack::kTRDStop);
- seed->SetNumberOfTRDslices(AliTRDtrack::kNslice);
+ seed->SetNumberOfTRDslices(AliTRDCalPID::kNSlicesLQ);
for (Int_t i = 0; i < AliTRDtrack::kNplane; i++) {
- for (Int_t j = 0; j <AliTRDtrack::kNslice; j++) {
+ for (Int_t j = 0; j <AliTRDCalPID::kNSlicesLQ; j++) {
seed->SetTRDslice(track->GetPIDsignals(i,j),i,j);
}
seed->SetTRDTimBin(track->GetPIDTimBin(i),i);
seed2.ResetCovariance(50.0);
AliTRDtrack *pt = new AliTRDtrack(seed2,seed2.GetAlpha());
- Int_t *indexes2 = seed2.GetIndexes();
+ const Int_t *indexes2 = seed2.GetIndexes();
for (Int_t l = 0; l < AliTRDtrack::kNplane;++l) {
- for (Int_t j = 0; j < AliTRDtrack::kNslice;j++) {
+ for (Int_t j = 0; j < AliTRDCalPID::kNSlicesLQ;j++) {
pt->SetPIDsignals(seed2.GetPIDsignals(l,j),l,j);
}
pt->SetPIDTimBin(seed2.GetPIDTimBin(l),l);
}
- Int_t *indexes3 = pt->GetBackupIndexes();
+ Int_t *indexes3 = const_cast<Int_t *>(pt->GetBackupIndexes());
for (Int_t l = 0; l < 200;++l) {
if (indexes2[l] == 0) {
break;
fHRefit->Fill(5);
for (Int_t l = 0; l < AliTRDtrack::kNplane; ++l) {
- for (Int_t j = 0; j < AliTRDtrack::kNslice; j++) {
+ for (Int_t j = 0; j < AliTRDCalPID::kNSlicesLQ; j++) {
seed->SetTRDslice(pt->GetPIDsignals(l,j),l,j);
}
seed->SetTRDTimBin(pt->GetPIDTimBin(l),l);
fHRefit->Fill(6);
for (Int_t l = 0; l < AliTRDtrack::kNplane; ++l) {
- for (Int_t j = 0; j < AliTRDtrack::kNslice; j++) {
+ for (Int_t j = 0; j < AliTRDCalPID::kNSlicesLQ; j++) {
seed->SetTRDslice(pt2->GetPIDsignals(l,j),l,j);
}
seed->SetTRDTimBin(pt2->GetPIDTimBin(l),l);
// Loop through all entries in the tree
Int_t nEntries = (Int_t) clusterTree->GetEntries();
Int_t nbytes = 0;
- AliTRDcluster *c = 0x0;
+ AliTRDcluster *c = NULL;
for (Int_t iEntry = 0; iEntry < nEntries; iEntry++) {
// Import the tree
//Double_t xtop = x0 + dxAmp;
//temporary !! (A.Bercuci)
- Int_t T0 = (Int_t)fCalibration->GetT0Average(AliTRDgeometry::GetDetector(layer, 2, gs));
+ Int_t t0 = (Int_t)fCalibration->GetT0Average(AliTRDgeometry::GetDetector(layer, 2, gs));
Int_t nTimeBins = AliTRDcalibDB::Instance()->GetNumberOfTimeBins();
for (Int_t iTime = 0; iTime < nTimeBins; iTime++) {
ppl->SetYmax(ymax,ymaxsensitive);
ppl->SetZ(zc,zmax,zmaxsensitive);
ppl->SetHoles(holes);
- if(iTime == T0) ppl->SetT0();
+ if(iTime == t0) ppl->SetT0();
InsertLayer(ppl);
}
//_____________________________________________________________________________
-AliTRDtrack *AliTRDtracker::RegisterSeed(AliTRDseed *seeds, Double_t *params)
+AliTRDtrack *AliTRDtracker::RegisterSeed(AliTRDseed * const seeds, Double_t *params)
{
//
// Build a TRD track out of tracklet candidates
, kMaxTimeBinIndex = 216
, kTrackingSectors = 18 };
- AliTRDtracker(AliTRDReconstructor *rec = 0x0);
+ AliTRDtracker(AliTRDReconstructor *rec = NULL);
AliTRDtracker(const AliTRDtracker &t);
- AliTRDtracker(const TFile *in, AliTRDReconstructor *rec = 0x0);
+ AliTRDtracker(const TFile *in, AliTRDReconstructor *rec = NULL);
virtual ~AliTRDtracker();
AliTRDtracker &operator=(const AliTRDtracker &/*t*/) { return *this; }
- void SetReconstructor(AliTRDReconstructor *rec) {fReconstructor = rec;}
+ void SetReconstructor(AliTRDReconstructor * const rec) {fReconstructor = rec;}
void SetAddTRDseeds() { fAddTRDseeds = kTRUE; }
void SetNoTilt() { fNoTilt = kTRUE; }
Double_t GetMaxChi2() const { return fgkMaxChi2; }
Float_t GetLabelFraction() const { return fgkLabelFraction; }
Float_t GetMinClustersInTrack() const { return fgkMinClustersInTrack; }
- Int_t GetLastPlane(AliTRDtrack *track);
+ Int_t GetLastPlane(AliTRDtrack *const track);
Double_t GetTiltFactor(const AliTRDcluster *c);
virtual Bool_t GetTrackPoint(Int_t index, AliTrackPoint& p) const;
Double_t GetX(Int_t sec, Int_t plane, Int_t localTB) const;
void UnloadClusters();
virtual void UseClusters(const AliKalmanTrack *t, Int_t from = 0) const;
Int_t ReadClusters(TObjArray *array, TTree *in) const;
- AliTRDcluster *GetCluster(AliTRDtrack *track, Int_t plane, Int_t timebin, UInt_t &index);
+ AliTRDcluster *GetCluster(AliTRDtrack * const track, Int_t plane, Int_t timebin, UInt_t &index);
Int_t FindClusters(Int_t sector, Int_t t0, Int_t t1, AliTRDtrack *track
, Int_t *clusters, AliTRDtracklet &tracklet);
protected:
- Bool_t AdjustSector(AliTRDtrack *track);
- AliTRDtrack *RegisterSeed(AliTRDseed *seeds, Double_t *params);
+ Bool_t AdjustSector(AliTRDtrack *const track) const;
+ AliTRDtrack *RegisterSeed(AliTRDseed * const seeds, Double_t *params);
Int_t FollowBackProlongation(AliTRDtrack &t);
//void MakeSeedsMI(Int_t inner, Int_t outer, AliESDEvent *esd = 0);
Int_t GetOuterTimeBin() const;
Int_t GetLayerNumber(Int_t tb) const { return fTimeBinIndex[tb]; }
Double_t GetX(Int_t pl) const { return fLayers[pl]->GetX(); }
- AliTRDpropagationLayer* GetLayer(Int_t i) { return fLayers[i]; }
+ AliTRDpropagationLayer* GetLayer(Int_t i) const { return fLayers[i]; }
Int_t GetSector() const {return fGeomSector;}
void MapTimeBinLayers();
};
protected:
- AliTRDReconstructor *fReconstructor;
+ AliTRDReconstructor *fReconstructor; // TRD Reconstructor
AliTRDgeometry *fGeom; // Pointer to TRD geometry
AliTRDtrackingSector *fTrSec[kTrackingSectors]; // Array of tracking sectors;
Int_t fNclusters; // Number of clusters in TRD
// //
///////////////////////////////////////////////////////////////////////////////
-#include "AliTRDtrackerDebug.h"
-
#include "TFile.h"
#include "TTree.h"
#include "TTreeStream.h"
#include "TMath.h"
#include "AliLog.h"
+
#include "AliTRDgeometry.h"
#include "AliTRDtrackV1.h"
#include "AliTRDseedV1.h"
-#include "AliTRDseed.h"
#include "AliTRDcluster.h"
#include "AliTRDgeometry.h"
+#include "AliTRDtrackerDebug.h"
+
ClassImp(AliTRDtrackerDebug)
Int_t AliTRDtrackerDebug::fgEventNumber = 0;
//____________________________________________________
AliTRDtrackerDebug::AliTRDtrackerDebug() : AliTRDtrackerV1()
- ,fOutputStreamer(0x0)
- ,fTree(0x0)
- ,fTracklet(0x0)
- ,fTrack(0x0)
+ ,fOutputStreamer(NULL)
+ ,fTree(NULL)
+ ,fTracklet(NULL)
+ ,fTrack(NULL)
,fNClusters(0)
,fAlpha(0.)
{
//____________________________________________________
-void AliTRDtrackerDebug::Draw(Option_t *)
+void AliTRDtrackerDebug::Draw(Option_t *)
{
// steer draw function
}
//printf("Processing track %d [%d] ...\n", it, fNClusters);
ResidualsTrackletsTrack();
- const AliTRDseedV1 *tracklet = 0x0;
+ const AliTRDseedV1 *tracklet = NULL;
for(int ip = 5; ip>=0; ip--){
if(!(tracklet = fTrack->GetTracklet(ip))) continue;
if(!tracklet->GetN()) continue;
// Calculate averange distances from clusters to the TRD track
Double_t x[3];
- AliTRDcluster *c = 0x0;
+ AliTRDcluster *c = NULL;
for(int ic=0; ic<35/*AliTRDseed:knTimebins*/; ic++){
if(!(c = tracklet->GetClusters(ic))) continue;
Double_t xc = c->GetX(), yc = c->GetY(), zc = c->GetZ();
//z0 = tracklet->GetZfit(0),
//zs = tracklet->GetZfit(1);
- AliTRDcluster *c = 0x0;
+ AliTRDcluster *c = NULL;
for(int ic=0; ic<35/*AliTRDseed:knTimebins*/; ic++){
if(!(c = tracklet->GetClusters(ic))) continue;
Double_t xc = c->GetX(), yc = c->GetY()/*, zc = c->GetZ()*/;
// store cluster positions
Double_t x0 = tracklet->GetX0();
- AliTRDcluster *c = 0x0;
+ AliTRDcluster *c = NULL;
Double_t x[2]; Int_t ncl, mcl, jc;
TLinearFitter fitter(3, "hyp2");
// build a working copy of the tracklets attached to the track
// and initialize working variables fX, fY and fZ
- AliTRDseedV1 tracklet[6] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
- const AliTRDseedV1 *ctracklet = 0x0;
+ //AliTRDseedV1 tracklet[6] = {NULL, NULL, NULL, NULL, NULL, NULL};
+ AliTRDseedV1 tracklet[6];
+ const AliTRDseedV1 *ctracklet = NULL;
for(int ip = 0; ip<6; ip++){
if(!(ctracklet = fTrack->GetTracklet(ip))) continue;
tracklet[ip] = (*ctracklet);
tracklet[ip].SetX0(x0);
// fit Rieman with tilt correction
- AliTRDtrackerV1::FitRiemanTilt(0x0, &tracklet[0], kTRUE);
+ AliTRDtrackerV1::FitRiemanTilt(NULL, &tracklet[0], kTRUE);
// make a copy of the fit result
Double_t
AliTRDseedV1 *tracklets[kNPlanes];
for(Int_t iPlane = 0; iPlane < AliTRDtrackerV1::kNPlanes; iPlane++)
- tracklets[iPlane] = 0x0;
+ tracklets[iPlane] = NULL;
for(Int_t iPlane = 0; iPlane < kNPlanes; iPlane++)
fTree->SetBranchAddress(Form("S%d.", iPlane), &tracklets[iPlane]);
fTree->SetBranchAddress("EventNumber", &fgEventNumber);
fTree = (TTree *)(debfile->Get("MakeSeeds2"));
if(!fTree) return;
Int_t nEntries = fTree->GetEntries();
- TLinearFitter *tiltedRiemanFitter = 0x0;
+ TLinearFitter *tiltedRiemanFitter = NULL;
fTree->SetBranchAddress("FitterT.", &tiltedRiemanFitter);
fTree->SetBranchAddress("EventNumber", &fgEventNumber);
fTree->SetBranchAddress("CandidateNumber", &fgCandidateNumber);
//____________________________________________________
void AliTRDtrackerDebug::AnalyseMinMax()
{
-//
+ // Development function related to the old tracking code
TFile *debfile = TFile::Open("TRD.TrackerDebug.root");
if(!debfile){
AliError("File TRD.TrackerDebug.root not found!");
AliError("Tree MakeSeeds0 not found in File TRD.TrackerDebug.root.");
return;
}
- AliTRDseedV1 *cseed[4] = {0x0, 0x0, 0x0, 0x0};
- AliTRDcluster *c[4] = {0x0, 0x0, 0x0, 0x0};
+ AliTRDseedV1 *cseed[4] = {NULL, NULL, NULL, NULL};
+ AliTRDcluster *c[4] = {NULL, NULL, NULL, NULL};
for(Int_t il = 0; il < 4; il++){
fTree->SetBranchAddress(Form("Seed%d.", il), &cseed[il]);
fTree->SetBranchAddress(Form("c%d.",il), &c[il]);
if((strcmp(direction, "y") != 0) && (strcmp(direction, "z") != 0)){
AliError(Form("Direction %s does not exist. Abborting!", direction));
- return 0x0;
+ return NULL;
}
TFile *debfile = TFile::Open("TRD.TrackerDebug.root");
if(!debfile){
AliError("File TRD.TrackerDebug.root not found!");
- return 0x0;
+ return NULL;
}
fTree = (TTree *)(debfile->Get("MakeSeeds0"));
if(!fTree){
AliError("Tree MakeSeeds0 not found in File TRD.TrackerDebug.root.");
- return 0x0;
+ return NULL;
}
TGraph *seedcl = new TGraph(4);
seedcl->SetMarkerColor(kRed);
seedRef->SetMarkerStyle(2);
- AliTRDcluster *c[4] = {0x0, 0x0, 0x0, 0x0};
- AliRieman *rim = 0x0;
+ AliTRDcluster *c[4] = {NULL, NULL, NULL, NULL};
+ AliRieman *rim = NULL;
Bool_t found = kFALSE;
for(Int_t il = 0; il < 4; il++) fTree->SetBranchAddress(Form("c%d.",il), &c[il]);
fTree->SetBranchAddress("EventNumber", &fgEventNumber);
delete seedcl;
delete seedRef;
delete riemanFit;
- return 0x0;
+ return NULL;
}
}
if(strcmp(direction, "y") && strcmp(direction, "z")){
AliError(Form("Direction %s does not exist. Abborting!", direction));
- return 0x0;
+ return NULL;
}
TFile *debfile = TFile::Open("TRD.TrackerDebug.root");
if(!debfile){
AliError("File TRD.TrackerDebug.root not found.");
- return 0x0;
+ return NULL;
}
- TString *treename = 0x0;
+ TString *treename = NULL;
if(iteration > -1)
treename = new TString("ImproveSeedQuality");
else
if(!fTree){
AliError(Form("Tree %s not found in File TRD.TrackerDebug.root.", treename->Data()));
delete treename;
- return 0x0;
+ return NULL;
}
delete treename;
clp[AliTRDtrackerV1::kNPlanes * AliTRDtrackerV1::kNTimeBins];
Int_t nLayers = 0, ncls = 0;
- TLinearFitter *fitter = 0x0;
- AliTRDseedV1 *tracklet[6] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+ TLinearFitter *fitter = NULL;
+ AliTRDseedV1 *tracklet[6] = {NULL, NULL, NULL, NULL, NULL, NULL};
for(Int_t iLayer = 0; iLayer < 6; iLayer++)
fTree->SetBranchAddress(Form("S%d.", iLayer), &tracklet[iLayer]);
fTree->SetBranchAddress("FitterT.", &fitter);
else{
AliError(Form("Combination consisting of event %d and candidate %d not found", event, candidate));
delete fitfun;
- return 0x0;
+ return NULL;
}
}
// //
////////////////////////////////////////////////////////////////////////////
-#ifndef ALITRDTRACKERV1_H
#include "AliTRDtrackerV1.h"
-#endif
class TTree;
class TCanvas;
// //
///////////////////////////////////////////////////////////////////////////////
-// #include <Riostream.h>
-// #include <stdio.h>
-// #include <string.h>
-
#include <TBranch.h>
#include <TDirectory.h>
#include <TLinearFitter.h>
#include "AliTRDtrackingChamber.h"
#include "AliTRDchamberTimeBin.h"
-
-
ClassImp(AliTRDtrackerV1)
-
const Float_t AliTRDtrackerV1::fgkMinClustersInTrack = 0.5; //
const Float_t AliTRDtrackerV1::fgkLabelFraction = 0.8; //
const Double_t AliTRDtrackerV1::fgkMaxChi2 = 12.0; //
const Double_t AliTRDtrackerV1::fgkX0[kNPlanes] = {
300.2, 312.8, 325.4, 338.0, 350.6, 363.2};
Int_t AliTRDtrackerV1::fgNTimeBins = 0;
-AliRieman* AliTRDtrackerV1::fgRieman = 0x0;
-TLinearFitter* AliTRDtrackerV1::fgTiltedRieman = 0x0;
-TLinearFitter* AliTRDtrackerV1::fgTiltedRiemanConstrained = 0x0;
+AliRieman* AliTRDtrackerV1::fgRieman = NULL;
+TLinearFitter* AliTRDtrackerV1::fgTiltedRieman = NULL;
+TLinearFitter* AliTRDtrackerV1::fgTiltedRiemanConstrained = NULL;
//____________________________________________________________________
AliTRDtrackerV1::AliTRDtrackerV1(AliTRDReconstructor *rec)
:AliTracker()
- ,fReconstructor(0x0)
- ,fGeom(0x0)
- ,fClusters(0x0)
- ,fTracklets(0x0)
- ,fTracks(0x0)
+ ,fkReconstructor(NULL)
+ ,fGeom(NULL)
+ ,fClusters(NULL)
+ ,fTracklets(NULL)
+ ,fTracks(NULL)
,fSieveSeeding(0)
{
//
}
fGeom = new AliTRDgeometry();
fGeom->CreateClusterMatrixArray();
- TGeoHMatrix *matrix = 0x0;
+ TGeoHMatrix *matrix = NULL;
Double_t loc[] = {0., 0., 0.};
Double_t glb[] = {0., 0., 0.};
for(Int_t ily=kNPlanes; ily--;){
}
// initialize calibration values
- AliTRDcalibDB *trd = 0x0;
+ AliTRDcalibDB *trd = NULL;
if (!(trd = AliTRDcalibDB::Instance())) {
AliFatal("Could not get calibration.");
}
// Destructor
//
- if(fgRieman) delete fgRieman; fgRieman = 0x0;
- if(fgTiltedRieman) delete fgTiltedRieman; fgTiltedRieman = 0x0;
- if(fgTiltedRiemanConstrained) delete fgTiltedRiemanConstrained; fgTiltedRiemanConstrained = 0x0;
+ if(fgRieman) delete fgRieman; fgRieman = NULL;
+ if(fgTiltedRieman) delete fgTiltedRieman; fgTiltedRieman = NULL;
+ if(fgTiltedRiemanConstrained) delete fgTiltedRiemanConstrained; fgTiltedRiemanConstrained = NULL;
for(Int_t isl =0; isl<kNSeedPlanes; isl++) if(fSeedTB[isl]) delete fSeedTB[isl];
if(fTracks) {fTracks->Delete(); delete fTracks;}
if(fTracklets) {fTracklets->Delete(); delete fTracklets;}
// See AliTRDtrackerV1::Clusters2TracksSM() for details.
//
- if(!fReconstructor->GetRecoParam() ){
+ if(!fkReconstructor->GetRecoParam() ){
AliError("Reconstruction configuration not initialized. Call first AliTRDReconstructor::SetRecoParam().");
return 0;
}
nTPCseeds= 0; // number of TPC seeds
Float_t foundMin = 20.0;
- Float_t *quality = 0x0;
- Int_t *index = 0x0;
+ Float_t *quality = NULL;
+ Int_t *index = NULL;
nSeeds = event->GetNumberOfTracks();
// Sort tracks according to quality
// (covariance in the yz plane)
seed->UpdateTrackParams(&track, AliESDtrack::kTRDbackup);
// prepare track and do propagation in the TRD
- track.SetReconstructor(fReconstructor);
+ track.SetReconstructor(fkReconstructor);
track.SetKink(Bool_t(seed->GetKinkIndex(0)));
expectedClr = FollowBackProlongation(track);
// check if track entered the TRD fiducial volume
// update calibration references using this track
if(calibra->GetHisto2d()) calibra->UpdateHistogramsV1(&track);
// save calibration object
- if (fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 0){
+ if (fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 0){
AliTRDtrackV1 *calibTrack = new AliTRDtrackV1(track);
calibTrack->SetOwner();
seed->AddCalibObject(calibTrack);
//(with the help of Annalisa de Caro Mar-17-2009)
if(gGeoManager){
gGeoManager->cd(Form("/ALIC_1/B077_1/BSEGMO%d_1/BTOF%d_1", sm, sm));
- TGeoHMatrix *m = 0x0;
+ TGeoHMatrix *m = NULL;
Double_t loc[]={0., 0., -.5*29.05}, glob[3];
if((m=gGeoManager->GetCurrentMatrix())){
AliInfo(Form("Number of tracks: TRDout[%d]", nFound));
// run stand alone tracking
- if (fReconstructor->IsSeeding()) Clusters2Tracks(event);
+ if (fkReconstructor->IsSeeding()) Clusters2Tracks(event);
return 0;
}
}
// Update the friend track
- if (fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 0){
- TObject *o = 0x0; Int_t ic = 0;
- AliTRDtrackV1 *calibTrack = 0x0;
+ if (fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 0){
+ TObject *o = NULL; Int_t ic = 0;
+ AliTRDtrackV1 *calibTrack = NULL;
while((o = seed->GetCalibObject(ic++))){
if(!(calibTrack = dynamic_cast<AliTRDtrackV1*>(o))) continue;
calibTrack->SetTrackHigh(track.GetTrackHigh());
}
}
- if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1){
+ if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1){
Int_t index;
for(int iplane=0; iplane<AliTRDgeometry::kNlayer; iplane++){
AliTRDseedV1 *tracklet = GetTracklet(&t, iplane, index);
}
Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
- TTreeSRedirector &cstreamer = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+ TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
AliTRDtrackV1 track(t);
track.SetOwner();
cstreamer << "FollowProlongation"
Int_t n = 0;
Double_t driftLength = .5*AliTRDgeometry::AmThick() + AliTRDgeometry::DrThick();
- AliTRDtrackingChamber *chamber = 0x0;
+ AliTRDtrackingChamber *chamber = NULL;
- AliTRDseedV1 tracklet, *ptrTracklet = 0x0;
+ AliTRDseedV1 tracklet, *ptrTracklet = NULL;
// in case of stand alone tracking we store all the pointers to the tracklets in a temporary array
AliTRDseedV1 *tracklets[kNPlanes];
memset(tracklets, 0, sizeof(AliTRDseedV1 *) * kNPlanes);
Bool_t kStoreIn = kTRUE, kPropagateIn = kTRUE;
// Loop through the TRD layers
- TGeoHMatrix *matrix = 0x0;
+ TGeoHMatrix *matrix = NULL;
Double_t x, y, z;
for (Int_t ily=0, sm=-1, stk=-1, det=-1; ily < AliTRDgeometry::kNlayer; ily++) {
// rough estimate of the entry point
// TODO cross check with y value !
stk = fGeom->GetStack(z, ily);
det = stk>=0 ? AliTRDgeometry::GetDetector(ily, stk, sm) : -1;
- matrix = det>=0 ? fGeom->GetClusterMatrix(det) : 0x0;
+ matrix = det>=0 ? fGeom->GetClusterMatrix(det) : NULL;
// check if supermodule/chamber is installed
if( !fGeom->GetSMstatus(sm) ||
t.SetStatus(AliTRDtrackV1::kSnp);
break;
}
- Bool_t RECALCULATE = kFALSE;
+ Bool_t doRecalculate = kFALSE;
if(sm != t.GetSector()){
sm = t.GetSector();
- RECALCULATE = kTRUE;
+ doRecalculate = kTRUE;
}
if(stk != fGeom->GetStack(z, ily)){
stk = fGeom->GetStack(z, ily);
- RECALCULATE = kTRUE;
+ doRecalculate = kTRUE;
}
- if(RECALCULATE){
+ if(doRecalculate){
det = AliTRDgeometry::GetDetector(ily, stk, sm);
if(!(matrix = fGeom->GetClusterMatrix(det))){
t.SetStatus(AliTRDtrackV1::kGeometry, ily);
t.SetStatus(AliTRDtrackV1::kNoClusters, ily);
continue;
}
- if(chamber->GetNClusters() < fgNTimeBins*fReconstructor->GetRecoParam() ->GetFindableClusters()){
+ if(chamber->GetNClusters() < fgNTimeBins*fkReconstructor->GetRecoParam() ->GetFindableClusters()){
t.SetStatus(AliTRDtrackV1::kNoClusters, ily);
continue;
}
// build tracklet
ptrTracklet = new(&tracklet) AliTRDseedV1(det);
- ptrTracklet->SetReconstructor(fReconstructor);
+ ptrTracklet->SetReconstructor(fkReconstructor);
ptrTracklet->SetKink(t.IsKink());
ptrTracklet->SetPadPlane(fGeom->GetPadPlane(ily, stk));
ptrTracklet->SetX0(glb[0]+driftLength);
t.SetStatus(AliTRDtrackV1::kNoAttach, ily);
continue;
}
- if(tracklet.GetN() < fgNTimeBins*fReconstructor->GetRecoParam() ->GetFindableClusters()){
+ if(tracklet.GetN() < fgNTimeBins*fkReconstructor->GetRecoParam() ->GetFindableClusters()){
t.SetStatus(AliTRDtrackV1::kNoClustersTracklet, ily);
continue;
}
Double_t cov[3]; ptrTracklet->GetCovAt(x, cov);
Double_t p[2] = { ptrTracklet->GetY(), ptrTracklet->GetZ()};
Double_t chi2 = ((AliExternalTrackParam)t).GetPredictedChi2(p, cov);
- if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 2){
+ if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 2){
Double_t ytrack = ptrTracklet->GetYref(0);
Double_t ztrack = ptrTracklet->GetZref(0);
Double_t ytracklet = ptrTracklet->GetYfit(0);
Double_t thetatrack = ptrTracklet->GetZref(1);
Double_t thetatracklet = ptrTracklet->GetZfit(1);
- TTreeSRedirector &mystreamer = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+ TTreeSRedirector &mystreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
mystreamer << "FollowBackProlongation1"
<< "il=" << ily
<< "x=" << x
//printf("clusters[%d] chi2[%f] x[%f] status[%d ", n, t.GetChi2(), t.GetX(), t.GetStatusTRD());
//for(int i=0; i<6; i++) printf("%d ", t.GetStatusTRD(i)); printf("]\n");
- if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1){
- TTreeSRedirector &cstreamer = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+ if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1){
+ TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
AliTRDtrackV1 track(t);
track.SetOwner();
}
//_________________________________________________________________________
-Float_t AliTRDtrackerV1::FitRieman(AliTRDseedV1 *tracklets, Double_t *chi2, Int_t *planes){
+Float_t AliTRDtrackerV1::FitRieman(AliTRDseedV1 *tracklets, Double_t *chi2, Int_t *const planes){
//
// Fits a Riemann-circle to the given points without tilting pad correction.
// The fit is performed using an instance of the class AliRieman (equations
TLinearFitter *fitter = GetTiltedRiemanFitterConstraint();
fitter->StoreData(kTRUE);
fitter->ClearPoints();
- AliTRDcluster *cl = 0x0;
+ AliTRDcluster *cl = NULL;
Float_t x, y, z, w, t, error, tilt;
Double_t uvt[2];
for(Int_t ip = 0; ip < AliTRDtrackerV1::kNPlanes; ip++)
tracklets[ip].SetC(curvature);
-/* if(fReconstructor->GetStreamLevel() >= 5){
+/* if(fkReconstructor->GetStreamLevel() >= 5){
//Linear Model on z-direction
Double_t xref = CalculateReferenceX(tracklets); // Relative to the middle of the stack
Double_t slope = fitter->GetParameter(2);
Float_t chi2Z = CalculateChi2Z(tracklets, zref, slope, xref);
Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
- TTreeSRedirector &treeStreamer = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+ TTreeSRedirector &treeStreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
treeStreamer << "FitTiltedRiemanConstraint"
<< "EventNumber=" << eventNumber
<< "CandidateNumber=" << candidateNumber
fitter->StoreData(kTRUE);
fitter->ClearPoints();
AliTRDLeastSquare zfitter;
- AliTRDcluster *cl = 0x0;
+ AliTRDcluster *cl = NULL;
Double_t xref = CalculateReferenceX(tracklets);
Double_t x, y, z, t, tilt, dx, w, we, erry, errz;
tracklets[iLayer].SetChi2(chi2track);
}
-/* if(fReconstructor->GetStreamLevel() >=5){
- TTreeSRedirector &cstreamer = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+/* if(fkReconstructor->GetStreamLevel() >=5){
+ TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
Double_t chi2z = CalculateChi2Z(tracklets, offset, slope, xref);
//____________________________________________________________________
Double_t AliTRDtrackerV1::FitLine(const AliTRDtrackV1 *track, AliTRDseedV1 *tracklets, Bool_t err, Int_t np, AliTrackPoint *points)
{
+ //
+ // Fit track with a staight line
+ // Fills an AliTrackPoint array with np points
+ // Function should be used to refit tracks when no magnetic field was on
+ //
AliTRDLeastSquare yfitter, zfitter;
- AliTRDcluster *cl = 0x0;
+ AliTRDcluster *cl = NULL;
- AliTRDseedV1 work[kNPlanes], *tracklet = 0x0;
+ AliTRDseedV1 work[kNPlanes], *tracklet = NULL;
if(!tracklets){
for(Int_t ipl = 0; ipl < kNPlanes; ipl++){
if(!(tracklet = track->GetTracklet(ipl))) continue;
fitter->StoreData(kTRUE);
fitter->ClearPoints();
AliTRDLeastSquare zfitter;
- AliTRDcluster *cl = 0x0;
+ AliTRDcluster *cl = NULL;
- AliTRDseedV1 work[kNPlanes], *tracklet = 0x0;
+ AliTRDseedV1 work[kNPlanes], *tracklet = NULL;
if(!tracklets){
for(Int_t ipl = 0; ipl < kNPlanes; ipl++){
if(!(tracklet = track->GetTracklet(ipl))) continue;
Double_t x0 = -b * y0;
Double_t tmp = y0*y0 + x0*x0 - c*y0;
if(tmp<=0.) return 1.E10;
- Double_t R = TMath::Sqrt(tmp);
- Double_t C = 1.0 + b*b - c*a;
- if (C > 0.0) C = a / TMath::Sqrt(C);
+ Double_t radius = TMath::Sqrt(tmp);
+ Double_t curvature = 1.0 + b*b - c*a;
+ if (curvature > 0.0) curvature = a / TMath::Sqrt(curvature);
// Calculate chi2 of the fit
Double_t chi2 = fitter->GetChisquare()/Double_t(nPoints);
if(!track){
for(Int_t ip = 0; ip < kNPlanes; ip++) {
x = tracklets[ip].GetX0();
- tmp = R*R-(x-x0)*(x-x0);
+ tmp = radius*radius-(x-x0)*(x-x0);
if(tmp <= 0.) continue;
tmp = TMath::Sqrt(tmp);
tracklets[ip].SetYref(1, (x - x0) / tmp);
tracklets[ip].SetZref(0, z0 + dzdx * (x - xref));
tracklets[ip].SetZref(1, dzdx);
- tracklets[ip].SetC(C);
+ tracklets[ip].SetC(curvature);
tracklets[ip].SetChi2(chi2);
}
}
Float_t xyz[3];
for(int ip=0; ip<np; ip++){
points[ip].GetXYZ(xyz);
- xyz[1] = TMath::Abs(xyz[0] - x0) > R ? 100. : y0 - (y0>0.?1.:-1.)*TMath::Sqrt((R-(xyz[0]-x0))*(R+(xyz[0]-x0)));
+ xyz[1] = TMath::Abs(xyz[0] - x0) > radius ? 100. : y0 - (y0>0.?1.:-1.)*TMath::Sqrt((radius-(xyz[0]-x0))*(radius+(xyz[0]-x0)));
xyz[2] = z0 + dzdx * (xyz[0] - xref);
points[ip].SetXYZ(xyz);
}
//____________________________________________________________________
-Double_t AliTRDtrackerV1::FitKalman(AliTRDtrackV1 *track, AliTRDseedV1 *tracklets, Bool_t up, Int_t np, AliTrackPoint *points)
+Double_t AliTRDtrackerV1::FitKalman(AliTRDtrackV1 *track, const AliTRDseedV1 * const tracklets, Bool_t up, Int_t np, AliTrackPoint *points)
{
// Kalman filter implementation for the TRD.
// It returns the positions of the fit in the array "points"
//if(points) printf("First marker point @ x[%d] = %f\n", ip, points[ip].GetX());
- AliTRDseedV1 tracklet, *ptrTracklet = 0x0;
+ AliTRDseedV1 tracklet, *ptrTracklet = NULL;
//Loop through the TRD planes
for (Int_t jplane = 0; jplane < kNPlanes; jplane++) {
// GET TRACKLET OR BUILT IT
Int_t iplane = up ? jplane : kNPlanes - 1 - jplane;
if(tracklets){
- if(!(ptrTracklet = &tracklets[iplane])) continue;
+ if(!(ptrTracklet = const_cast<AliTRDseedV1 *>(&tracklets[iplane]))) continue;
}else{
if(!(ptrTracklet = track->GetTracklet(iplane))){
- /*AliTRDtrackerV1 *tracker = 0x0;
+ /*AliTRDtrackerV1 *tracker = NULL;
if(!(tracker = dynamic_cast<AliTRDtrackerV1*>( AliTRDReconstructor::Tracker()))) continue;
ptrTracklet = new(&tracklet) AliTRDseedV1(iplane);
if(!tracker->MakeTracklet(ptrTracklet, track)) */
branch->SetAddress(&clusterArray);
if(!fClusters){
- Float_t nclusters = fReconstructor->GetRecoParam()->GetNClusters();
- if(fReconstructor->IsHLT()) nclusters /= AliTRDgeometry::kNsector;
+ Float_t nclusters = fkReconstructor->GetRecoParam()->GetNClusters();
+ if(fkReconstructor->IsHLT()) nclusters /= AliTRDgeometry::kNsector;
array = new TClonesArray("AliTRDcluster", Int_t(nclusters));
array->SetOwner(kTRUE);
}
Int_t nEntries = (Int_t) clusterTree->GetEntries();
Int_t nbytes = 0;
Int_t ncl = 0;
- AliTRDcluster *c = 0x0;
+ AliTRDcluster *c = NULL;
for (Int_t iEntry = 0; iEntry < nEntries; iEntry++) {
// Import the tree
nbytes += clusterTree->GetEvent(iEntry);
// Fills clusters into TRD tracking sectors
//
- if(!fReconstructor->IsWritingClusters()){
+ if(!fkReconstructor->IsWritingClusters()){
fClusters = AliTRDReconstructor::GetClusters();
} else {
if (ReadClusters(fClusters, cTree)) {
}
//_____________________________________________________________________________
-Int_t AliTRDtrackerV1::LoadClusters(TClonesArray *clusters)
+Int_t AliTRDtrackerV1::LoadClusters(TClonesArray * const clusters)
{
//
// Fills clusters into TRD tracking sectors
const AliTRDCalDet *cal = AliTRDcalibDB::Instance()->GetT0Det();
for(int isector =0; isector<AliTRDgeometry::kNsector; isector++){
if(!fTrSec[isector].GetNChambers()) continue;
- fTrSec[isector].Init(fReconstructor, cal);
+ fTrSec[isector].Init(fkReconstructor, cal);
}
return nin;
if(fTracks){
fTracks->Delete();
- if(HasRemoveContainers()){delete fTracks; fTracks = 0x0;}
+ if(HasRemoveContainers()){delete fTracks; fTracks = NULL;}
}
if(fTracklets){
fTracklets->Delete();
- if(HasRemoveContainers()){delete fTracklets; fTracklets = 0x0;}
+ if(HasRemoveContainers()){delete fTracklets; fTracklets = NULL;}
}
if(fClusters){
if(IsClustersOwner()) fClusters->Delete();
// save clusters array in the reconstructor for further use.
- if(!fReconstructor->IsWritingClusters()){
+ if(!fkReconstructor->IsWritingClusters()){
AliTRDReconstructor::SetClusters(fClusters);
SetClustersOwner(kFALSE);
- } else AliTRDReconstructor::SetClusters(0x0);
+ } else AliTRDReconstructor::SetClusters(NULL);
}
for (int i = 0; i < AliTRDgeometry::kNsector; i++) fTrSec[i].Clear();
// const AliTRDtrackV1 *track = dynamic_cast<const AliTRDtrackV1*>(t);
// if(!track) return;
//
-// AliTRDseedV1 *tracklet = 0x0;
+// AliTRDseedV1 *tracklet = NULL;
// for(Int_t ily=AliTRDgeometry::kNlayer; ily--;){
// if(!(tracklet = track->GetTracklet(ily))) continue;
-// AliTRDcluster *c = 0x0;
+// AliTRDcluster *c = NULL;
// for(Int_t ic=AliTRDseed::kNclusters; ic--;){
// if(!(c=tracklet->GetClusters(ic))) continue;
// c->Use();
//
//_____________________________________________________________________________
-Bool_t AliTRDtrackerV1::AdjustSector(AliTRDtrackV1 *track)
+Bool_t AliTRDtrackerV1::AdjustSector(AliTRDtrackV1 *const track)
{
//
// Rotates the track when necessary
//____________________________________________________________________
-AliTRDseedV1* AliTRDtrackerV1::GetTracklet(AliTRDtrackV1 *track, Int_t p, Int_t &idx)
+AliTRDseedV1* AliTRDtrackerV1::GetTracklet(AliTRDtrackV1 *const track, Int_t p, Int_t &idx)
{
// Find tracklet for TRD track <track>
// Parameters
// Detailed description
//
idx = track->GetTrackletIndex(p);
- AliTRDseedV1 *tracklet = (idx==0xffff) ? 0x0 : (AliTRDseedV1*)fTracklets->UncheckedAt(idx);
+ AliTRDseedV1 *tracklet = (idx==0xffff) ? NULL : (AliTRDseedV1*)fTracklets->UncheckedAt(idx);
return tracklet;
}
//____________________________________________________________________
-AliTRDseedV1* AliTRDtrackerV1::SetTracklet(AliTRDseedV1 *tracklet)
+AliTRDseedV1* AliTRDtrackerV1::SetTracklet(const AliTRDseedV1 * const tracklet)
{
// Add this tracklet to the list of tracklets stored in the tracker
//
}
//____________________________________________________________________
-AliTRDtrackV1* AliTRDtrackerV1::SetTrack(AliTRDtrackV1 *track)
+AliTRDtrackV1* AliTRDtrackerV1::SetTrack(const AliTRDtrackV1 * const track)
{
// Add this track to the list of tracks stored in the tracker
//
Int_t nTracks = 0;
Int_t nChambers = 0;
- AliTRDtrackingChamber **stack = 0x0, *chamber = 0x0;
+ AliTRDtrackingChamber **stack = NULL, *chamber = NULL;
for(int istack = 0; istack<AliTRDgeometry::kNstack; istack++){
if(!(stack = fTrSec[sector].GetStack(istack))) continue;
nChambers = 0;
for(int ilayer=0; ilayer<AliTRDgeometry::kNlayer; ilayer++){
if(!(chamber = stack[ilayer])) continue;
- if(chamber->GetNClusters() < fgNTimeBins * fReconstructor->GetRecoParam() ->GetFindableClusters()) continue;
+ if(chamber->GetNClusters() < fgNTimeBins * fkReconstructor->GetRecoParam() ->GetFindableClusters()) continue;
nChambers++;
//AliInfo(Form("sector %d stack %d layer %d clusters %d", sector, istack, ilayer, chamber->GetNClusters()));
}
}
//____________________________________________________________________
-Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClonesArray *esdTrackList)
+Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClonesArray * const esdTrackList)
{
//
// Make tracks in one TRD stack.
//
const AliTRDCalDet *cal = AliTRDcalibDB::Instance()->GetT0Det();
- AliTRDtrackingChamber *chamber = 0x0;
- AliTRDtrackingChamber **ci = 0x0;
+ AliTRDtrackingChamber *chamber = NULL;
+ AliTRDtrackingChamber **ci = NULL;
AliTRDseedV1 sseed[kMaxTracksStack*6]; // to be initialized
Int_t pars[4]; // MakeSeeds parameters
// Build initial seeding configurations
Double_t quality = BuildSeedingConfigs(stack, configs);
- if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 10){
+ if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 10){
AliInfo(Form("Plane config %d %d %d Quality %f"
, configs[0], configs[1], configs[2], quality));
}
//AliInfo(Form("Number of Tracks after iteration step %d: %d\n", iconf, ntracks));
if(ntracks == kMaxTracksStack) break;
}
- if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1) AliInfo(Form("Candidate TRD tracks %d in iteration %d.", ntracks, fSieveSeeding));
+ if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1) AliInfo(Form("Candidate TRD tracks %d in iteration %d.", ntracks, fSieveSeeding));
if(!ntracks) break;
// Sieve clusters in decreasing order of track quality
Double_t trackParams[7];
- // AliTRDseedV1 *lseed = 0x0;
+ // AliTRDseedV1 *lseed = NULL;
Int_t jSieve = 0, candidates;
do{
//AliInfo(Form("\t\tITER = %i ", jSieve));
Int_t ich = 0; while(!(chamber = stack[ich])) ich++;
trackParams[6] = fGeom->GetSector(chamber->GetDetector());/* *alpha+shift; // Supermodule*/
- if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1){
+ if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1){
//AliInfo(Form("Track %d [%d] nlayers %d trackQuality = %e nused %d, yref = %3.3f", itrack, trackIndex, nlayers, fTrackQuality[trackIndex], nused, trackParams[1]));
AliTRDseedV1 *dseed[6];
Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
Int_t trackNumber = AliTRDtrackerDebug::GetTrackNumber();
Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
- TTreeSRedirector &cstreamer = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+ TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
cstreamer << "Clusters2TracksStack"
<< "EventNumber=" << eventNumber
<< "TrackNumber=" << trackNumber
esdTrack->SetLabel(track->GetLabel());
track->UpdateESDtrack(esdTrack);
// write ESD-friends if neccessary
- if (fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 0){
+ if (fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 0){
AliTRDtrackV1 *calibTrack = new AliTRDtrackV1(*track);
calibTrack->SetOwner();
esdTrack->AddCalibObject(calibTrack);
// increment counters
ntracks2 += ntracks1;
- if(fReconstructor->IsHLT()) break;
+ if(fkReconstructor->IsHLT()) break;
fSieveSeeding++;
// Rebuild plane configurations and indices taking only unused clusters into account
quality = BuildSeedingConfigs(stack, configs);
- if(quality < 1.E-7) break; //fReconstructor->GetRecoParam() ->GetPlaneQualityThreshold()) break;
+ if(quality < 1.E-7) break; //fkReconstructor->GetRecoParam() ->GetPlaneQualityThreshold()) break;
for(Int_t ip = 0; ip < kNPlanes; ip++){
if(!(chamber = stack[ip])) continue;
chamber->Build(fGeom, cal);//Indices(fSieveSeeding);
}
- if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 10){
+ if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 10){
AliInfo(Form("Sieve level %d Plane config %d %d %d Quality %f", fSieveSeeding, configs[0], configs[1], configs[2], quality));
}
} while(fSieveSeeding<10); // end stack clusters sieve
//
Double_t chamberQ[kNPlanes];memset(chamberQ, 0, kNPlanes*sizeof(Double_t));
- AliTRDtrackingChamber *chamber = 0x0;
+ AliTRDtrackingChamber *chamber = NULL;
for(int iplane=0; iplane<kNPlanes; iplane++){
if(!(chamber = stack[iplane])) continue;
chamberQ[iplane] = (chamber = stack[iplane]) ? chamber->GetQuality() : 0.;
}
//____________________________________________________________________
-Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *sseed, Int_t *ipar)
+Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, const AliTRDseedV1 * const sseed, const Int_t * const ipar)
{
//
// Seed tracklets and build candidate TRD tracks. The procedure is used during barrel tracking to account for tracks which are
// Alexandru Bercuci <A.Bercuci@gsi.de>
// Markus Fasel <M.Fasel@gsi.de>
- AliTRDtrackingChamber *chamber = 0x0;
- AliTRDcluster *c[kNSeedPlanes] = {0x0, 0x0, 0x0, 0x0}; // initilize seeding clusters
- AliTRDseedV1 *cseed = &sseed[0]; // initialize tracklets for first track
+ AliTRDtrackingChamber *chamber = NULL;
+ AliTRDcluster *c[kNSeedPlanes] = {NULL, NULL, NULL, NULL}; // initilize seeding clusters
+ AliTRDseedV1 *cseed = const_cast<AliTRDseedV1 *>(&sseed[0]); // initialize tracklets for first track
Int_t ncl, mcl; // working variable for looping over clusters
Int_t index[AliTRDchamberTimeBin::kMaxClustersLayer], jndex[AliTRDchamberTimeBin::kMaxClustersLayer];
// chi2 storage
Double_t hL[kNPlanes]; // Tilting angle
Float_t padlength[kNPlanes]; // pad lenghts
Float_t padwidth[kNPlanes]; // pad widths
- AliTRDpadPlane *pp = 0x0;
+ AliTRDpadPlane *pp = NULL;
for(int iplane=0; iplane<kNPlanes; iplane++){
pp = fGeom->GetPadPlane(iplane, istack);
hL[iplane] = TMath::Tan(TMath::DegToRad()*pp->GetTiltingAngle());
// Init anode wire position for chambers
Double_t x0[kNPlanes], // anode wire position
driftLength = .5*AliTRDgeometry::AmThick() - AliTRDgeometry::DrThick(); // drift length
- TGeoHMatrix *matrix = 0x0;
+ TGeoHMatrix *matrix = NULL;
Double_t loc[] = {AliTRDgeometry::AnodePos(), 0., 0.};
Double_t glb[] = {0., 0., 0.};
AliTRDtrackingChamber **cIter = &stack[0];
x0[iLayer] = glb[0];
}
- if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 2){
+ if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 2){
AliInfo(Form("Making seeds Stack[%d] Config[%d] Tracks[%d]...", istack, config, ntracks));
}
Int_t nlayers = 0;
for(int isl=0; isl<kNSeedPlanes; isl++){
if(!(chamber = stack[planes[isl]])) continue;
- if(!chamber->GetSeedingLayer(fSeedTB[isl], fGeom, fReconstructor)) continue;
+ if(!chamber->GetSeedingLayer(fSeedTB[isl], fGeom, fkReconstructor)) continue;
nlayers++;
}
if(nlayers < kNSeedPlanes) return ntracks;
tseed->SetTilt(hL[iLayer]);
tseed->SetPadLength(padlength[iLayer]);
tseed->SetPadWidth(padwidth[iLayer]);
- tseed->SetReconstructor(fReconstructor);
+ tseed->SetReconstructor(fkReconstructor);
tseed->SetX0(det<0 ? fR[iLayer]+driftLength : x0[iLayer]);
tseed->Init(GetRiemanFitter());
tseed->SetStandAlone(kTRUE);
}
Bool_t isFake = kFALSE;
- if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
+ if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
if (c[0]->GetLabel(0) != c[3]->GetLabel(0)) isFake = kTRUE;
if (c[1]->GetLabel(0) != c[3]->GetLabel(0)) isFake = kTRUE;
if (c[2]->GetLabel(0) != c[3]->GetLabel(0)) isFake = kTRUE;
Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
AliRieman *rim = GetRiemanFitter();
- TTreeSRedirector &cs0 = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+ TTreeSRedirector &cs0 = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
cs0 << "MakeSeeds0"
<<"EventNumber=" << eventNumber
<<"CandidateNumber=" << candidateNumber
<<"RiemanFitter.=" << rim
<<"\n";
}
- if(chi2[0] > fReconstructor->GetRecoParam() ->GetChi2Z()/*7./(3. - sLayer)*//*iter*/){
+ if(chi2[0] > fkReconstructor->GetRecoParam() ->GetChi2Z()/*7./(3. - sLayer)*//*iter*/){
//AliInfo(Form("Failed chi2 filter on chi2Z [%f].", chi2[0]));
AliTRDtrackerDebug::SetCandidateNumber(AliTRDtrackerDebug::GetCandidateNumber() + 1);
continue;
}
- if(chi2[1] > fReconstructor->GetRecoParam() ->GetChi2Y()/*1./(3. - sLayer)*//*iter*/){
+ if(chi2[1] > fkReconstructor->GetRecoParam() ->GetChi2Y()/*1./(3. - sLayer)*//*iter*/){
//AliInfo(Form("Failed chi2 filter on chi2Y [%f].", chi2[1]));
AliTRDtrackerDebug::SetCandidateNumber(AliTRDtrackerDebug::GetCandidateNumber() + 1);
continue;
}
// temporary exit door for the HLT
- if(fReconstructor->IsHLT()){
+ if(fkReconstructor->IsHLT()){
// attach clusters to extrapolation chambers
for(int iLayer=0; iLayer<kNPlanes-kNSeedPlanes; iLayer++){
Int_t jLayer = planesExt[iLayer];
}
Double_t like = CookLikelihood(&cseed[0], planes); // to be checked
- if (TMath::Log(1.E-9 + like) < fReconstructor->GetRecoParam() ->GetTrackLikelihood()){
+ if (TMath::Log(1.E-9 + like) < fkReconstructor->GetRecoParam() ->GetTrackLikelihood()){
//AliInfo(Form("Failed likelihood %f[%e].", TMath::Log(1.E-9 + like), like));
AliTRDtrackerDebug::SetCandidateNumber(AliTRDtrackerDebug::GetCandidateNumber() + 1);
continue;
// AliInfo("Extrapolation done.");
// Debug Stream containing all the 6 tracklets
- if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
- TTreeSRedirector &cstreamer = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+ if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
+ TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
TLinearFitter *tiltedRieman = GetTiltedRiemanFitter();
Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
<< "\n";
}
- if(fReconstructor->HasImproveTracklets() && ImproveSeedQuality(stack, cseed) < 4){
+ if(fkReconstructor->HasImproveTracklets() && ImproveSeedQuality(stack, cseed) < 4){
AliTRDtrackerDebug::SetCandidateNumber(AliTRDtrackerDebug::GetCandidateNumber() + 1);
continue;
}
// do the final track fitting (Once with vertex constraint and once without vertex constraint)
Double_t chi2Vals[3];
chi2Vals[0] = FitTiltedRieman(&cseed[0], kTRUE);
- if(fReconstructor->HasVertexConstrained())
+ if(fkReconstructor->HasVertexConstrained())
chi2Vals[1] = FitTiltedRiemanConstraint(&cseed[0], GetZ()); // Do Vertex Constrained fit if desired
else
chi2Vals[1] = 1.;
fTrackQuality[ntracks] = CalculateTrackLikelihood(&cseed[0], &chi2Vals[0]);
//AliInfo("Hyperplane fit done\n");
- if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
- TTreeSRedirector &cstreamer = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+ if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
+ TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
TLinearFitter *fitterTC = GetTiltedRiemanFitterConstraint();
}
//_____________________________________________________________________________
-AliTRDtrackV1* AliTRDtrackerV1::MakeTrack(AliTRDseedV1 *seeds, Double_t *params)
+AliTRDtrackV1* AliTRDtrackerV1::MakeTrack(const AliTRDseedV1 * const seeds, Double_t *params)
{
//
// Build a TRD track out of tracklet candidates
AliTRDtrackV1 track(seeds, ¶ms[1], c, params[0], params[6]*alpha+shift);
track.PropagateTo(params[0]-5.0);
- AliTRDseedV1 *ptrTracklet = 0x0;
+ AliTRDseedV1 *ptrTracklet = NULL;
// skip Kalman filter for HLT
- if(fReconstructor->IsHLT()){
+ if(fkReconstructor->IsHLT()){
for (Int_t jLayer = 0; jLayer < AliTRDgeometry::kNlayer; jLayer++) {
track.UnsetTracklet(jLayer);
- ptrTracklet = &seeds[jLayer];
+ ptrTracklet = const_cast<AliTRDseedV1 *>(&seeds[jLayer]);
if(!ptrTracklet->IsOK()) continue;
if(TMath::Abs(ptrTracklet->GetYref(1) - ptrTracklet->GetYfit(1)) >= .2) continue; // check this condition with Marian
ptrTracklet = SetTracklet(ptrTracklet);
}
AliTRDtrackV1 *ptrTrack = SetTrack(&track);
ptrTrack->CookPID();
- ptrTrack->SetReconstructor(fReconstructor);
+ ptrTrack->SetReconstructor(fkReconstructor);
return ptrTrack;
}
track.ResetCovariance(1);
Int_t nc = TMath::Abs(FollowBackProlongation(track));
- if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 5){
+ if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 5){
Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
Double_t p[5]; // Track Params for the Debug Stream
track.GetExternalParameters(params[0], p);
- TTreeSRedirector &cs = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+ TTreeSRedirector &cs = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
cs << "MakeTrack"
<< "EventNumber=" << eventNumber
<< "CandidateNumber=" << candidateNumber
<< "track.=" << &track
<< "\n";
}
- if (nc < 30) return 0x0;
+ if (nc < 30) return NULL;
AliTRDtrackV1 *ptrTrack = SetTrack(&track);
- ptrTrack->SetReconstructor(fReconstructor);
+ ptrTrack->SetReconstructor(fkReconstructor);
ptrTrack->CookLabel(.9);
// computes PID for track
//
// make a local working copy
- AliTRDtrackingChamber *chamber = 0x0;
+ AliTRDtrackingChamber *chamber = NULL;
AliTRDseedV1 bseed[6];
Int_t nLayers = 0;
for (Int_t jLayer = 0; jLayer < 6; jLayer++) bseed[jLayer] = cseed[jLayer];
}
chi2 = FitTiltedRieman(bseed, kTRUE);
- if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 7){
+ if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 7){
Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
TLinearFitter *tiltedRieman = GetTiltedRiemanFitter();
- TTreeSRedirector &cstreamer = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+ TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
cstreamer << "ImproveSeedQuality"
<< "EventNumber=" << eventNumber
<< "CandidateNumber=" << candidateNumber
}
//_________________________________________________________________________
-Double_t AliTRDtrackerV1::CalculateTrackLikelihood(AliTRDseedV1 *tracklets, Double_t *chi2){
+Double_t AliTRDtrackerV1::CalculateTrackLikelihood(const AliTRDseedV1 *const tracklets, Double_t *chi2){
//
// Calculates the Track Likelihood value. This parameter serves as main quality criterion for
// the track selection
chi2phi /= Float_t (nLayers - 2.0);
Double_t likeChi2Z = TMath::Exp(-chi2[2] * 0.14); // Chi2Z
- Double_t likeChi2TC = (fReconstructor->HasVertexConstrained()) ?
+ Double_t likeChi2TC = (fkReconstructor->HasVertexConstrained()) ?
TMath::Exp(-chi2[1] * 0.677) : 1; // Constrained Tilted Riemann
Double_t likeChi2TR = TMath::Exp(-chi2[0] * 0.0078); // Non-constrained Tilted Riemann
Double_t likeChi2Phi= TMath::Exp(-chi2phi * 3.23);//3.23
Double_t trackLikelihood = likeChi2Z * likeChi2TR * likeChi2Phi;
- if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
+ if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
- TTreeSRedirector &cstreamer = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+ TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
cstreamer << "CalculateTrackLikelihood0"
<< "EventNumber=" << eventNumber
<< "CandidateNumber=" << candidateNumber
//
// ratio of the total number of clusters/track which are expected to be found by the tracker.
- const AliTRDrecoParam *fRecoPars = fReconstructor->GetRecoParam();
+ const AliTRDrecoParam *fRecoPars = fkReconstructor->GetRecoParam();
Double_t chi2y = GetChi2Y(&cseed[0]);
Double_t chi2z = GetChi2Z(&cseed[0]);
Double_t likea = TMath::Exp(-sumda * fRecoPars->GetPhiSlope());
Double_t likechi2y = 0.0000000001;
- if (fReconstructor->IsCosmic() || chi2y < fRecoPars->GetChi2YCut()) likechi2y += TMath::Exp(-TMath::Sqrt(chi2y) * fRecoPars->GetChi2YSlope());
+ if (fkReconstructor->IsCosmic() || chi2y < fRecoPars->GetChi2YCut()) likechi2y += TMath::Exp(-TMath::Sqrt(chi2y) * fRecoPars->GetChi2YSlope());
Double_t likechi2z = TMath::Exp(-chi2z * fRecoPars->GetChi2ZSlope());
Double_t likeN = TMath::Exp(-(fRecoPars->GetNMeanClusters() - nclusters) / fRecoPars->GetNSigmaClusters());
Double_t like = likea * likechi2y * likechi2z * likeN;
- if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
+ if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
- Int_t nTracklets = 0; Float_t mean_ncls = 0;
+ Int_t nTracklets = 0; Float_t meanNcls = 0;
for(Int_t iseed=0; iseed < kNPlanes; iseed++){
if(!cseed[iseed].IsOK()) continue;
nTracklets++;
- mean_ncls += cseed[iseed].GetN2();
+ meanNcls += cseed[iseed].GetN2();
}
- if(nTracklets) mean_ncls /= nTracklets;
+ if(nTracklets) meanNcls /= nTracklets;
// The Debug Stream contains the seed
- TTreeSRedirector &cstreamer = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+ TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
cstreamer << "CookLikelihood"
<< "EventNumber=" << eventNumber
<< "CandidateNumber=" << candidateNumber
<< "nclusters=" << nclusters
<< "likeN=" << likeN
<< "like=" << like
- << "meanncls=" << mean_ncls
+ << "meanncls=" << meanNcls
<< "\n";
}
AliCluster* AliTRDtrackerV1::GetCluster(Int_t idx) const
{
Int_t ncls = fClusters->GetEntriesFast();
- return idx >= 0 && idx < ncls ? (AliCluster*)fClusters->UncheckedAt(idx) : 0x0;
+ return idx >= 0 && idx < ncls ? (AliCluster*)fClusters->UncheckedAt(idx) : NULL;
}
//____________________________________________________________________
AliTRDseedV1* AliTRDtrackerV1::GetTracklet(Int_t idx) const
{
Int_t ntrklt = fTracklets->GetEntriesFast();
- return idx >= 0 && idx < ntrklt ? (AliTRDseedV1*)fTracklets->UncheckedAt(idx) : 0x0;
+ return idx >= 0 && idx < ntrklt ? (AliTRDseedV1*)fTracklets->UncheckedAt(idx) : NULL;
}
//____________________________________________________________________
AliKalmanTrack* AliTRDtrackerV1::GetTrack(Int_t idx) const
{
Int_t ntrk = fTracks->GetEntriesFast();
- return idx >= 0 && idx < ntrk ? (AliKalmanTrack*)fTracks->UncheckedAt(idx) : 0x0;
+ return idx >= 0 && idx < ntrk ? (AliKalmanTrack*)fTracks->UncheckedAt(idx) : NULL;
}
//_____________________________________________________________________________
-Float_t AliTRDtrackerV1::GetChi2Y(AliTRDseedV1 *tracklets) const
+Float_t AliTRDtrackerV1::GetChi2Y(const AliTRDseedV1 * const tracklets) const
{
// Calculates normalized chi2 in y-direction
// chi2 = Sum chi2 / n_tracklets
}
//_____________________________________________________________________________
-Float_t AliTRDtrackerV1::GetChi2Z(AliTRDseedV1 *tracklets) const
+Float_t AliTRDtrackerV1::GetChi2Z(const AliTRDseedV1 *const tracklets) const
{
// Calculates normalized chi2 in z-direction
// chi2 = Sum chi2 / n_tracklets
}
//____________________________________________________________________
-Float_t AliTRDtrackerV1::CalculateReferenceX(AliTRDseedV1 *tracklets){
+Float_t AliTRDtrackerV1::CalculateReferenceX(const AliTRDseedV1 *const tracklets){
//
// Calculates the reference x-position for the tilted Rieman fit defined as middle
// of the stack (middle between layers 2 and 3). For the calculation all the tracklets
}
//_____________________________________________________________________________
-Double_t AliTRDtrackerV1::FitTiltedRiemanV1(AliTRDseedV1 *tracklets){
+Double_t AliTRDtrackerV1::FitTiltedRiemanV1(AliTRDseedV1 *const tracklets){
//
// Track Fitter Function using the new class implementation of
// the Rieman fit
}
//_____________________________________________________________________________
-void AliTRDtrackerV1::AliTRDLeastSquare::AddPoint(Double_t *x, Double_t y, Double_t sigmaY){
+void AliTRDtrackerV1::AliTRDLeastSquare::AddPoint(const Double_t *const x, Double_t y, Double_t sigmaY){
//
// Adding Point to the fitter
//
Double_t weight = 1/(sigmaY > 1e-9 ? sigmaY : 1e-9);
weight *= weight;
- Double_t &xpt = *x;
+ const Double_t &xpt = *x;
// printf("Adding point x = %f, y = %f, sigma = %f\n", xpt, y, sigmaY);
fSums[0] += weight;
fSums[1] += weight * xpt;
}
//_____________________________________________________________________________
-void AliTRDtrackerV1::AliTRDLeastSquare::RemovePoint(Double_t *x, Double_t y, Double_t sigmaY){
+void AliTRDtrackerV1::AliTRDLeastSquare::RemovePoint(const Double_t *const x, Double_t y, Double_t sigmaY){
//
// Remove Point from the sample
//
Double_t weight = 1/(sigmaY > 1e-9 ? sigmaY : 1e-9);
weight *= weight;
- Double_t &xpt = *x;
+ const Double_t &xpt = *x;
fSums[0] -= weight;
fSums[1] -= weight * xpt;
fSums[2] -= weight * y;
}
//_____________________________________________________________________________
-Double_t AliTRDtrackerV1::AliTRDLeastSquare::GetFunctionValue(Double_t *xpos) const {
+Double_t AliTRDtrackerV1::AliTRDLeastSquare::GetFunctionValue(const Double_t *const xpos) const {
//
// Returns the Function value of the fitted function at a given x-position
//
}
//_____________________________________________________________________________
-void AliTRDtrackerV1::AliTRDtrackFitterRieman::UpdateFitters(AliTRDseedV1 *tracklet){
+void AliTRDtrackerV1::AliTRDtrackFitterRieman::UpdateFitters(AliTRDseedV1 * const tracklet){
//
// Does the transformations and updates the fitters
// The following transformation is applied
// //
////////////////////////////////////////////////////////////////////////////
-#ifndef ALITRACKER_H
+//#ifndef ALITRACKER_H
#include "AliTracker.h"
-#endif
+//#endif
-#ifndef ALITRDTRACKINGSECTOR_H
+//#ifndef ALITRDTRACKINGSECTOR_H
#include "AliTRDtrackingSector.h"
-#endif
+//#endif
-#ifndef ROOT_TMatrixDfwd
+//#ifndef ROOT_TMatrixDfwd
#include <TMatrixDfwd.h>
-#endif
+//#endif
/**************************************************************************
* Class Status see source file *
class AliTRDtrackerFitter;
class AliTRDtrackV1;
class AliTRDReconstructor;
+
class AliTRDtrackerV1 : public AliTracker
{
public:
, kMaxTracksStack = 100
, kNConfigs = 15
};
- AliTRDtrackerV1(AliTRDReconstructor *rec = 0x0);
+ AliTRDtrackerV1(AliTRDReconstructor *rec = NULL);
virtual ~AliTRDtrackerV1();
//temporary
static TLinearFitter* GetTiltedRiemanFitterConstraint();
static AliRieman* GetRiemanFitter();
static void FitRieman(AliTRDcluster **clusters, Double_t chi2[2]);
- static Float_t FitRieman(AliTRDseedV1 *tracklets, Double_t *chi2, Int_t *planes = 0x0);
+ static Float_t FitRieman(AliTRDseedV1 *tracklets, Double_t *chi2, Int_t *const planes = NULL);
static Float_t FitTiltedRiemanConstraint(AliTRDseedV1 *tracklets, Double_t zVertex);
static Float_t FitTiltedRieman(AliTRDseedV1 *tracklets, Bool_t sigError);
static Double_t FitTiltedRiemanV1(AliTRDseedV1 *tracklets);
- static Double_t FitRiemanTilt(const AliTRDtrackV1 *trk, AliTRDseedV1 *tracklets = 0x0, Bool_t err=0, Int_t np = 0, AliTrackPoint *points = 0x0);
- static Double_t FitLine(const AliTRDtrackV1 *trk, AliTRDseedV1 *tracklets = 0x0, Bool_t err=0, Int_t np = 0, AliTrackPoint *points = 0x0);
- static Double_t FitKalman(AliTRDtrackV1 *trk, AliTRDseedV1 *tracklets = 0x0, Bool_t up=0, Int_t np = 0, AliTrackPoint *points = 0x0);
+ static Double_t FitRiemanTilt(const AliTRDtrackV1 *trk, AliTRDseedV1 *tracklets = NULL, Bool_t err=0, Int_t np = 0, AliTrackPoint *points = NULL);
+ static Double_t FitLine(const AliTRDtrackV1 *trk, AliTRDseedV1 *tracklets = NULL, Bool_t err=0, Int_t np = 0, AliTrackPoint *points = NULL);
+ static Double_t FitKalman(AliTRDtrackV1 *trk, const AliTRDseedV1 * const tracklets = NULL, Bool_t up=0, Int_t np = 0, AliTrackPoint *points = NULL);
Bool_t IsClustersOwner() const { return TestBit(kOwner);}
Bool_t HasRemoveContainers() const { return TestBit(kRemoveContainers);}
- void SetClustersOwner(Bool_t own=kTRUE) {SetBit(kOwner, own); if(!own) fClusters = 0x0;}
+ void SetClustersOwner(Bool_t own=kTRUE) {SetBit(kOwner, own); if(!own) fClusters = NULL;}
void SetRemoveContainers(Bool_t rm=kTRUE) {SetBit(kRemoveContainers, rm);}
Int_t FollowBackProlongation(AliTRDtrackV1 &t);
Int_t FollowProlongation(AliTRDtrackV1 &t);
Int_t LoadClusters(TTree *cTree);
- Int_t LoadClusters(TClonesArray *clusters);
+ Int_t LoadClusters(TClonesArray *const clusters);
Int_t PropagateBack(AliESDEvent *event);
static Int_t PropagateToX(AliTRDtrackV1 &t, Double_t xToGo, Double_t maxStep);
Int_t ReadClusters(TClonesArray* &array, TTree *in) const;
Int_t RefitInward(AliESDEvent *event);
static void SetNTimeBins(Int_t nTimeBins){fgNTimeBins = nTimeBins; }
- void SetReconstructor(const AliTRDReconstructor *rec){ fReconstructor = rec; }
+ void SetReconstructor(const AliTRDReconstructor *rec){ fkReconstructor = rec; }
void UnloadClusters();
class AliTRDLeastSquare{
AliTRDLeastSquare();
~AliTRDLeastSquare(){};
- void AddPoint(Double_t *x, Double_t y, Double_t sigmaY);
- void RemovePoint(Double_t *x, Double_t y, Double_t sigmaY);
+ void AddPoint(const Double_t * const x, Double_t y, Double_t sigmaY);
+ void RemovePoint(const Double_t * const x, Double_t y, Double_t sigmaY);
void Eval();
void Reset();
Double_t GetFunctionParameter(Int_t ParNumber) const {return fParams[ParNumber];}
- Double_t GetFunctionValue(Double_t *xpos) const;
+ Double_t GetFunctionValue(const Double_t * const xpos) const;
void GetCovarianceMatrix(Double_t *storage) const;
private:
AliTRDLeastSquare(const AliTRDLeastSquare &);
Double_t GetCurvature() const;
void GetCovAt(Double_t x, Double_t *cov) const;
- void SetRiemanFitter(TLinearFitter *fitter) { fTrackFitter = fitter; }
- void SetTracklet(Int_t il, AliTRDseedV1 *tracklet);
+ void SetRiemanFitter(TLinearFitter *const fitter) { fTrackFitter = fitter; }
+ void SetTracklet(Int_t il, AliTRDseedV1 * const tracklet);
void SetSysClusterError(Double_t err) { fSysClusterError = err; };
private:
AliTRDtrackFitterRieman(const AliTRDtrackFitterRieman &);
AliTRDtrackFitterRieman &operator=(const AliTRDtrackFitterRieman &);
- void UpdateFitters(AliTRDseedV1 *tracklet);
+ void UpdateFitters(AliTRDseedV1 * const tracklet);
Bool_t CheckAcceptable(Double_t offset, Double_t slope);
Double_t CalculateReferenceX();
};
protected:
- static Bool_t AdjustSector(AliTRDtrackV1 *track);
+ static Bool_t AdjustSector(AliTRDtrackV1 *const track);
Double_t BuildSeedingConfigs(AliTRDtrackingChamber **stack, Int_t *configs);
Int_t BuildTrackingContainers();
static Float_t CalculateChi2Z(AliTRDseedV1 *tracklets, Double_t offset, Double_t slope, Double_t xref);
Int_t Clusters2TracksSM(Int_t sector, AliESDEvent *esd);
- Int_t Clusters2TracksStack(AliTRDtrackingChamber **stack, TClonesArray *esdTrackList);
- AliTRDseedV1* GetTracklet(AliTRDtrackV1 *trk, Int_t plane, Int_t &idx);
+ Int_t Clusters2TracksStack(AliTRDtrackingChamber **stack, TClonesArray * const esdTrackList);
+ AliTRDseedV1* GetTracklet(AliTRDtrackV1 *const trk, Int_t plane, Int_t &idx);
Bool_t GetTrackPoint(Int_t index, AliTrackPoint &p) const;
Float_t GetR4Layer(Int_t ly) const { return fR[ly];}
- Int_t MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *sseed, Int_t *ipar);
- AliTRDtrackV1* MakeTrack(AliTRDseedV1 *seeds, Double_t *params);
- AliTRDtrackV1* SetTrack(AliTRDtrackV1 *track);
- AliTRDseedV1* SetTracklet(AliTRDseedV1 *tracklet);
+ Int_t MakeSeeds(AliTRDtrackingChamber **stack, const AliTRDseedV1 * const sseed, const Int_t * const ipar);
+ AliTRDtrackV1* MakeTrack(const AliTRDseedV1 * const seeds, Double_t *params);
+ AliTRDtrackV1* SetTrack(const AliTRDtrackV1 * const track);
+ AliTRDseedV1* SetTracklet(const AliTRDseedV1 * const tracklet);
private:
AliTRDtrackerV1(const AliTRDtrackerV1 &tracker);
AliTRDtrackerV1 &operator=(const AliTRDtrackerV1 &tracker);
Double_t CookLikelihood(AliTRDseedV1 *cseed, Int_t planes[4]);
- Double_t CalculateTrackLikelihood(AliTRDseedV1 *tracklets, Double_t *chi2);
+ Double_t CalculateTrackLikelihood(const AliTRDseedV1 *const tracklets, Double_t *chi2);
Int_t ImproveSeedQuality(AliTRDtrackingChamber **stack, AliTRDseedV1 *tracklet);
- static Float_t CalculateReferenceX(AliTRDseedV1 *tracklets);
+ static Float_t CalculateReferenceX(const AliTRDseedV1 *const tracklets);
void ResetSeedTB();
- Float_t GetChi2Y(AliTRDseedV1 *tracklets) const;
- Float_t GetChi2Z(AliTRDseedV1 *tracklets) const;
+ Float_t GetChi2Y(const AliTRDseedV1 *const tracklets) const;
+ Float_t GetChi2Z(const AliTRDseedV1 *const tracklets) const;
private:
- const AliTRDReconstructor *fReconstructor; // reconstructor manager
+ const AliTRDReconstructor *fkReconstructor; // reconstructor manager
AliTRDgeometry *fGeom; // Pointer to TRD geometry
AliTRDtrackingSector fTrSec[kTrackingSectors]; // Array of tracking sectors;
TClonesArray *fClusters; // List of clusters
}
//_______________________________________________________
-Bool_t AliTRDtrackingChamber::Build(AliTRDgeometry *geo, const AliTRDCalDet *cal, Bool_t hlt)
+Bool_t AliTRDtrackingChamber::Build(AliTRDgeometry *const geo, const AliTRDCalDet *cal, Bool_t hlt)
{
// Init chamber and all time bins (AliTRDchamberTimeBin)
// Calculates radial position of the chamber based on
//_______________________________________________________
-Bool_t AliTRDtrackingChamber::GetSeedingLayer(AliTRDchamberTimeBin *&fakeLayer, AliTRDgeometry *geo, const AliTRDReconstructor *rec)
+Bool_t AliTRDtrackingChamber::GetSeedingLayer(AliTRDchamberTimeBin *&fakeLayer, AliTRDgeometry * const geo, const AliTRDReconstructor *rec)
{
//
// Creates a seeding layer
Int_t hvals[kMaxPads + 1]; memset(hvals, 0, sizeof(Int_t)*kMaxPads); // one entry in addition for termination flag
Float_t *sigmas[kMaxRows];
Float_t svals[kMaxPads]; memset(svals, 0, sizeof(Float_t)*kMaxPads);
- AliTRDcluster *c = 0x0;
+ AliTRDcluster *c = NULL;
for(Int_t irs = 0; irs < kMaxRows; irs++){
histogram[irs] = &hvals[irs*kMaxCols];
sigmas[irs] = &svals[irs*kMaxCols];
pos[2] = z/n;
sig[0] = .02;
sig[1] = sigcands[ican];
- fakeLayer->InsertCluster(new AliTRDcluster(fDetector, 0., pos, sig, 0x0, 3, signal, col, row, 0, 0, 0., 0), fakeIndex++);
+ fakeLayer->InsertCluster(new AliTRDcluster(fDetector, 0., pos, sig, NULL, 3, signal, col, row, 0, 0, 0., 0), fakeIndex++);
}
}
fakeLayer->BuildIndices();
//_______________________________________________________
void AliTRDtrackingChamber::Print(Option_t *opt) const
{
+ // Print the chamber status
if(!GetNClusters()) return;
AliInfo(Form("fDetector = %d", fDetector));
AliInfo(Form("fX0 = %7.3f", fX0));
virtual ~AliTRDtrackingChamber(){}
void Bootstrap(const AliTRDReconstructor *rec);
- Bool_t Build(AliTRDgeometry *geo, const AliTRDCalDet *cal, Bool_t hlt = kFALSE);
- void Clear(const Option_t *opt = 0x0);
+ Bool_t Build(AliTRDgeometry *const geo, const AliTRDCalDet *cal, Bool_t hlt = kFALSE);
+ void Clear(const Option_t *opt = NULL);
Int_t GetDetector() const {return fDetector;}
Int_t GetNClusters() const;
Double_t GetQuality();
- Bool_t GetSeedingLayer(AliTRDchamberTimeBin *&layer, AliTRDgeometry *geo, const AliTRDReconstructor *rec);
+ Bool_t GetSeedingLayer(AliTRDchamberTimeBin *&layer, AliTRDgeometry * const geo, const AliTRDReconstructor *rec);
Float_t GetX() const {return fX0;}
- AliTRDchamberTimeBin* GetTB(int tb) {return tb >= 0 && tb < AliTRDseedV1::kNtb ? &fTB[tb] : 0x0;}
+ AliTRDchamberTimeBin* GetTB(int tb) {return tb >= 0 && tb < AliTRDseedV1::kNtb ? &fTB[tb] : NULL;}
void InsertCluster(AliTRDcluster *c, Int_t index);
- void Print(Option_t *opt = 0x0) const;
+ void Print(Option_t *opt = NULL) const;
void SetDetector(Int_t det) { fDetector = det;}
void SetOwner();
// //\r
///////////////////////////////////////////////////////////////////////////////\r
\r
-#include "AliTRDcalibDB.h"\r
-#include "AliTRDCommonParam.h"\r
-#include "AliTRDReconstructor.h"\r
-#include "AliTRDpadPlane.h"\r
#include "AliTRDtrackingSector.h"\r
#include "AliTRDtrackingChamber.h"\r
\r
AliTRDtrackingSector::AliTRDtrackingSector()\r
:fSector(-1)\r
,fN(0)\r
- ,fGeom(0x0)\r
+ ,fGeom(NULL)\r
{\r
// Default constructor\r
\r
// Propagate radial position information (calibration/alignment aware) from chambers to sector level\r
//\r
\r
- AliTRDchamberTimeBin *tb = 0x0;\r
+ AliTRDchamberTimeBin *tb = NULL;\r
AliTRDtrackingChamber **tc = &fChamber[0];\r
for(Int_t ic = 0; (ic<AliTRDgeometry::kNdets) && (*tc); ic++, tc++){\r
for(Int_t itb=0; itb<AliTRDseedV1::kNtb; itb++){\r
AliTRDtrackingChamber **tc = &fChamber[0];\r
for(Int_t ich=0; ich<fN; ich++, tc++){ \r
(*tc)->Clear(opt);\r
- delete (*tc); (*tc) = 0x0; // I would avoid\r
+ delete (*tc); (*tc) = NULL; // I would avoid\r
} \r
memset(fIndex, -1, AliTRDgeometry::kNdets*sizeof(Char_t));\r
fN = 0;\r
\r
Int_t ch = stack*AliTRDgeometry::kNlayer + layer;\r
if(fIndex[ch] >= 0) return fChamber[Int_t(fIndex[ch])];\r
- else if(!build) return 0x0;\r
+ else if(!build) return NULL;\r
\r
// CHAMBER HAS TO BE BUILD\r
Int_t rch = ch;do rch--; while(rch>=0 && fIndex[rch]<0);\r
// Return chamber at position (stack, plane) in current \r
// sector or build a new one if it is not already created\r
\r
- if(stack<0 || stack>=AliTRDgeometry::kNstack) return 0x0;\r
+ if(stack<0 || stack>=AliTRDgeometry::kNstack) return NULL;\r
\r
Int_t ich, n = 0;\r
for(int il=0; il<AliTRDgeometry::kNlayer; il++){\r
ich = stack*AliTRDgeometry::kNlayer + il;\r
- if(fIndex[ich] < 0) fStack[il] = 0x0; \r
+ if(fIndex[ich] < 0) fStack[il] = NULL; \r
else{\r
fStack[il] = fChamber[Int_t(fIndex[ich])];\r
n++;\r
}\r
}\r
\r
- return n ? &fStack[0] : 0x0;\r
+ return n ? &fStack[0] : NULL;\r
}\r
\r
//_____________________________________________________________________________\r
AliTRDtrackingSector(AliTRDgeometry* geo, Int_t gs);
virtual ~AliTRDtrackingSector(){;}
- void Clear(const Option_t *opt = 0x0);
+ void Clear(const Option_t *opt = NULL);
Int_t GetNChambers() const { return fN; }
Double_t GetX(Int_t pl) const { return pl >=0 && pl < AliTRDgeometry::kNlayer ? fX0[pl] : 0.; }
- AliTRDtrackingChamber* GetChamber(Int_t i) const { return i>=0 && i < fN ? fChamber[i] : 0x0; }
+ AliTRDtrackingChamber* GetChamber(Int_t i) const { return i>=0 && i < fN ? fChamber[i] : NULL; }
AliTRDtrackingChamber* GetChamber(Int_t stack, Int_t plane, Bool_t build = kFALSE);
AliTRDtrackingChamber** GetStack(Int_t stack);
Int_t GetSector() const {return fSector;}
void Init(const AliTRDReconstructor *rec, const AliTRDCalDet *cal);
- void Print(Option_t *opt = 0x0) const;
+ void Print(Option_t *opt = NULL) const;
- void SetGeometry(AliTRDgeometry *geo) {fGeom = geo;}
+ void SetGeometry(AliTRDgeometry *const geo) {fGeom = geo;}
private:
AliTRDtrackingSector(const AliTRDtrackingSector &/*t*/);
public:
enum {
- kNMom = 11
+ kNMom = 11,
+ kNSlicesLQ = 3,
+ kNSlicesNN = 8
};
AliTRDCalPID();
#include <TMultiLayerPerceptron.h>
#include "AliPID.h"
-#include "AliTRDtrack.h"
+#include "AliLog.h"
#include "AliTRDgeometry.h"
#include "AliTRDCalPIDNN.h"
return 0.;
}
- Double_t ddedx[AliTRDtrack::kNMLPslice];
+ Double_t ddedx[AliTRDCalPID::kNSlicesNN];
- for (int inode=0; inode<AliTRDtrack::kNMLPslice; inode++) {
+ for (int inode=0; inode<AliTRDCalPID::kNSlicesNN; inode++) {
ddedx[inode] = (((Double_t) dedx[inode]/kMLPscale)*3) // Bug fix! Needs new reference data or different calculation of dedx!!!!
- / (AliTRDcalibDB::Instance()->GetNumberOfTimeBins()/AliTRDtrack::kNMLPslice);
+ / (AliTRDcalibDB::Instance()->GetNumberOfTimeBins()/AliTRDCalPID::kNSlicesNN);
}
lNN1 = nn->Evaluate(spec, ddedx);
#include "AliTRDCalPID.h"
#include "AliTRDcalibDB.h"
#include "AliTRDgeometry.h"
-#include "AliTRDtrack.h"
ClassImp(AliTRDCalPIDRefMaker)
Float_t mom;
//Float_t length;
- Double_t dedx[AliTRDtrack::kNslice], dEdx;
+ Double_t dedx[AliTRDCalPID::kNSlicesLQ], dEdx;
Int_t timebin;
for (Int_t iLayer=0; iLayer<AliTRDgeometry::kNlayer; iLayer++){
// read data for track segment
- for(int iSlice=0; iSlice<AliTRDtrack::kNslice; iSlice++)
+ for(int iSlice=0; iSlice<AliTRDCalPID::kNSlicesLQ; iSlice++)
dedx[iSlice] = esdTrack->GetTRDslice(iLayer, iSlice);
dEdx = esdTrack->GetTRDslice(iLayer, -1);
timebin = esdTrack->GetTRDTimBin(iLayer);
tracklet = cTrack.GetTracklet(iChamb);
if(!tracklet) continue;
tracklet -> CookdEdx(AliTRDpidUtil::kLQslices);
- fdEdx = tracklet->GetdEdx();
+ fdEdx = const_cast<Float_t *>(tracklet->GetdEdx());
for(Int_t iSlice = 0; iSlice < AliTRDpidUtil::kLQslices; iSlice++){
hdEdxSlice -> Fill(species * fMomentumAxis->GetNbins() * AliTRDpidUtil::kLQslices + (iMomBin-1) * AliTRDpidUtil::kLQslices + iSlice, fdEdx[iSlice]);
}
for(Int_t ily = 0; ily < AliTRDgeometry::kNlayer; ily++){
if(!(TRDtracklet = TRDtrack -> GetTracklet(ily))) continue;
TRDtracklet->CookdEdx(AliTRDpidUtil::kNNslices);
- dedx = TRDtracklet->GetdEdx();
+ dedx = const_cast<Float_t *>(TRDtracklet->GetdEdx());
for(Int_t iSlice = 0; iSlice < AliTRDpidUtil::kNNslices; iSlice++)
dedx[iSlice] = dedx[iSlice]/AliTRDCalPIDNN::kMLPscale;
memcpy(fdEdx, dedx, AliTRDpidUtil::kNNslices*sizeof(Float_t));
for(Int_t ily = 0; ily < AliTRDgeometry::kNlayer; ily++){
if(!(TRDtracklet = TRDtrack -> GetTracklet(ily))) continue;
TRDtracklet->CookdEdx(AliTRDpidUtil::kLQslices);
- dedx = TRDtracklet->GetdEdx();
+ dedx = const_cast<Float_t *>(TRDtracklet->GetdEdx());
memcpy(fdEdx, dedx, AliTRDpidUtil::kLQslices*sizeof(Float_t));
if(fDebugLevel>=2) Printf("LayerLQ : %d", ily);
fLayer = ily;
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff