From 4d6aee34d332e5190cfe20c3f1abcacada5a780d Mon Sep 17 00:00:00 2001 From: cblume Date: Fri, 7 Aug 2009 11:28:51 +0000 Subject: [PATCH] Coding rules --- TRD/AliTRDchamberTimeBin.cxx | 43 +++-- TRD/AliTRDchamberTimeBin.h | 22 +-- TRD/AliTRDgtuSim.cxx | 11 +- TRD/AliTRDpidESD.cxx | 16 +- TRD/AliTRDpidUtil.cxx | 56 +++--- TRD/AliTRDpidUtil.h | 6 +- TRD/AliTRDpropagationLayer.cxx | 8 +- TRD/AliTRDpropagationLayer.h | 6 +- TRD/AliTRDrecoParam.h | 2 +- TRD/AliTRDseed.cxx | 9 +- TRD/AliTRDseed.h | 6 +- TRD/AliTRDseedV1.cxx | 120 ++++++------ TRD/AliTRDseedV1.h | 28 +-- TRD/AliTRDtrack.cxx | 35 ++-- TRD/AliTRDtrack.h | 55 +++--- TRD/AliTRDtrackGTU.cxx | 3 +- TRD/AliTRDtrackGTU.h | 4 +- TRD/AliTRDtrackV1.cxx | 76 ++++---- TRD/AliTRDtrackV1.h | 30 ++- TRD/AliTRDtracker.cxx | 111 +++++------ TRD/AliTRDtracker.h | 18 +- TRD/AliTRDtrackerDebug.cxx | 67 +++---- TRD/AliTRDtrackerDebug.h | 2 - TRD/AliTRDtrackerV1.cxx | 314 +++++++++++++++---------------- TRD/AliTRDtrackerV1.h | 65 +++---- TRD/AliTRDtrackingChamber.cxx | 9 +- TRD/AliTRDtrackingChamber.h | 10 +- TRD/AliTRDtrackingSector.cxx | 18 +- TRD/AliTRDtrackingSector.h | 8 +- TRD/Cal/AliTRDCalPID.h | 4 +- TRD/Cal/AliTRDCalPIDNN.cxx | 8 +- TRD/Cal/AliTRDCalPIDRefMaker.cxx | 5 +- TRD/qaRec/AliTRDcheckPID.cxx | 2 +- TRD/qaRec/AliTRDpidRefMaker.cxx | 4 +- 34 files changed, 595 insertions(+), 586 deletions(-) diff --git a/TRD/AliTRDchamberTimeBin.cxx b/TRD/AliTRDchamberTimeBin.cxx index 2d9057bc99e..cdf92d67797 100644 --- a/TRD/AliTRDchamberTimeBin.cxx +++ b/TRD/AliTRDchamberTimeBin.cxx @@ -31,13 +31,11 @@ /////////////////////////////////////////////////////////////////////////////// #include -#include #include -#include #include #include "AliLog.h" - +#include "AliTRDcluster.h" #include "AliTRDgeometry.h" #include "AliTRDpadPlane.h" #include "AliTRDchamberTimeBin.h" @@ -49,7 +47,7 @@ ClassImp(AliTRDchamberTimeBin) //_____________________________________________________________________________ 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) @@ -73,7 +71,7 @@ AliTRDchamberTimeBin::AliTRDchamberTimeBin(Int_t plane, Int_t stack, Int_t secto //_____________________________________________________________________________ AliTRDchamberTimeBin::AliTRDchamberTimeBin(const AliTRDchamberTimeBin &layer): TObject() - ,fReconstructor(layer.fReconstructor) + ,fkReconstructor(layer.fkReconstructor) ,fPlane(layer.fPlane) ,fStack(layer.fStack) ,fSector(layer.fSector) @@ -107,6 +105,7 @@ AliTRDchamberTimeBin &AliTRDchamberTimeBin::operator=(const AliTRDchamberTimeBin //_____________________________________________________________________________ void AliTRDchamberTimeBin::Clear(const Option_t *) { + // Reset the Chamber Timebin if(IsOwner()) for(Int_t it = 0; itIsUsed() || fClusters[i]->IsShared()){ - fClusters[i] = 0x0; + fClusters[i] = NULL; fIndex[i] = 0xffff; } else nClStack++; } @@ -268,7 +267,7 @@ void AliTRDchamberTimeBin::BuildIndices(Int_t iter) 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++; @@ -276,7 +275,7 @@ void AliTRDchamberTimeBin::BuildIndices(Int_t iter) } *(hcliter++) = tmpcl; *(hinditer++) = *finditer; - tmpcl = 0x0; + tmpcl = NULL; *(finditer++) = 0xffff; nClStack++; } @@ -317,9 +316,9 @@ void AliTRDchamberTimeBin::BuildIndices(Int_t iter) 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 @@ -513,7 +512,7 @@ Int_t AliTRDchamberTimeBin::SearchNearestCluster(Double_t y, Double_t z, Double_ } //_____________________________________________________________________________ -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. @@ -537,7 +536,7 @@ void AliTRDchamberTimeBin::BuildCond(AliTRDcluster *cl, Double_t *cond, UChar_t //End_Html // - if(!fReconstructor){ + if(!fkReconstructor){ AliError("Reconstructor not set."); return; } @@ -545,18 +544,18 @@ void AliTRDchamberTimeBin::BuildCond(AliTRDcluster *cl, Double_t *cond, UChar_t 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. // @@ -631,11 +630,11 @@ AliTRDcluster *AliTRDchamberTimeBin::GetNearestCluster(Double_t *cond) // 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; } diff --git a/TRD/AliTRDchamberTimeBin.h b/TRD/AliTRDchamberTimeBin.h index c7b96fb9fb5..7c495430163 100644 --- a/TRD/AliTRDchamberTimeBin.h +++ b/TRD/AliTRDchamberTimeBin.h @@ -16,11 +16,9 @@ #include "TObject.h" #endif -#ifndef ALITRDCLUSTER_H -#include "AliTRDcluster.h" -#endif - +class AliTRDcluster; class AliTRDReconstructor; + class AliTRDchamberTimeBin : public TObject { public: @@ -42,16 +40,16 @@ 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; } @@ -66,12 +64,12 @@ public: 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); @@ -84,7 +82,7 @@ private: 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 diff --git a/TRD/AliTRDgtuSim.cxx b/TRD/AliTRDgtuSim.cxx index 6eba70dd2d6..832f170114a 100644 --- a/TRD/AliTRDgtuSim.cxx +++ b/TRD/AliTRDgtuSim.cxx @@ -31,6 +31,12 @@ #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" @@ -38,11 +44,6 @@ #include "AliTRDtrackletMCM.h" #include "AliESDEvent.h" -#include "AliRun.h" -#include "AliRunLoader.h" -#include "AliLoader.h" -#include "AliLog.h" - ClassImp(AliTRDgtuSim) AliTRDgtuSim::AliTRDgtuSim(AliRunLoader *rl) diff --git a/TRD/AliTRDpidESD.cxx b/TRD/AliTRDpidESD.cxx index 4a6fb2ae29c..1087b0e0bfb 100644 --- a/TRD/AliTRDpidESD.cxx +++ b/TRD/AliTRDpidESD.cxx @@ -38,7 +38,7 @@ #include "AliTRDpidESD.h" #include "AliTRDgeometry.h" #include "AliTRDcalibDB.h" -#include "AliTRDtrack.h" +#include "Cal/AliTRDCalPID.h" ClassImp(AliTRDpidESD) @@ -49,7 +49,7 @@ Int_t AliTRDpidESD::fgMinPlane = 0; //_____________________________________________________________________________ AliTRDpidESD::AliTRDpidESD() :TObject() - ,fTrack(0x0) + ,fTrack(NULL) { // // Default constructor @@ -60,7 +60,7 @@ AliTRDpidESD::AliTRDpidESD() //_____________________________________________________________________________ AliTRDpidESD::AliTRDpidESD(const AliTRDpidESD &p) :TObject(p) - ,fTrack(0x0) + ,fTrack(NULL) { // // AliTRDpidESD copy constructor @@ -103,7 +103,7 @@ void AliTRDpidESD::Copy(TObject &p) const ((AliTRDpidESD &) p).fgCheckTrackStatus = fgCheckTrackStatus; ((AliTRDpidESD &) p).fgCheckKinkStatus = fgCheckKinkStatus; ((AliTRDpidESD &) p).fgMinPlane = fgMinPlane; - ((AliTRDpidESD &) p).fTrack = 0x0; + ((AliTRDpidESD &) p).fTrack = NULL; } @@ -146,8 +146,8 @@ Int_t AliTRDpidESD::MakePID(AliESDEvent * const event) // 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; @@ -170,7 +170,7 @@ Int_t AliTRDpidESD::MakePID(AliESDEvent * const event) for (Int_t iLayer = 0; iLayer < AliTRDgeometry::kNlayer; iLayer++) { // read data for track segment - for(int iSlice=0; iSliceGetTRDslice(iLayer, iSlice); dEdx = t->GetTRDslice(iLayer, -1); timebin = t->GetTRDTimBin(iLayer); @@ -264,7 +264,7 @@ Bool_t AliTRDpidESD::RecalculateTrackSegmentKine(AliESDtrack * const esd return kFALSE; } - AliExternalTrackParam *param = 0x0; + AliExternalTrackParam *param = NULL; if(!fTrack){ fTrack = new AliExternalTrackParam(*op); param = fTrack; diff --git a/TRD/AliTRDpidUtil.cxx b/TRD/AliTRDpidUtil.cxx index fa2668fcc90..277b9a492b5 100644 --- a/TRD/AliTRDpidUtil.cxx +++ b/TRD/AliTRDpidUtil.cxx @@ -1,3 +1,13 @@ +/*********************************************************************************************************** + * * + * 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" @@ -18,7 +28,7 @@ ClassImp(AliTRDpidUtil) -Float_t AliTRDpidUtil::fEleEffi = 0.9; +Float_t AliTRDpidUtil::fgEleEffi = 0.9; //________________________________________________________________________ AliTRDpidUtil::AliTRDpidUtil() @@ -33,8 +43,6 @@ AliTRDpidUtil::AliTRDpidUtil() // } - - //________________________________________________________________________ Bool_t AliTRDpidUtil::CalculatePionEffi(TH1* histo1, TH1* histo2) // Double_t AliTRDpidUtil::GetError() @@ -55,9 +63,9 @@ Bool_t AliTRDpidUtil::CalculatePionEffi(TH1* histo1, TH1* histo2) 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 @@ -65,12 +73,12 @@ Bool_t AliTRDpidUtil::CalculatePionEffi(TH1* histo1, TH1* histo2) 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]); } } @@ -81,29 +89,29 @@ Bool_t AliTRDpidUtil::CalculatePionEffi(TH1* histo1, TH1* histo2) 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; } @@ -154,10 +162,10 @@ Bool_t AliTRDpidUtil::IsElectron(const AliESDtrack *track, ETRDPIDMethod method) 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(cdb_thresholds->GetObject()); - TH1 * threshold_hist = dynamic_cast(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(cdbThresholds->GetObject()); + TH1 * thresholdHist = dynamic_cast(histos->FindObject(histname[method].Data())); + Double_t threshold = thresholdHist->GetBinContent(GetMomentumBin(track->P()) + 1); // Do Decision Double_t pid_probs[5]; @@ -176,10 +184,10 @@ Double_t AliTRDpidUtil::GetSystematicError(const AliESDtrack *track, ETRDPIDMeth 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(cdb_thresholds->GetObject()); - TH1 * threshold_hist = dynamic_cast(histos->FindObject(histname[method].Data())); - return threshold_hist->GetBinContent(GetMomentumBin(track->P()) + 1); + AliCDBEntry *cdbThresholds = cdb->Get("TRD/Calib/PIDThresholds"); + TObjArray *histos = dynamic_cast(cdbThresholds->GetObject()); + TH1 * thresholdHist = dynamic_cast(histos->FindObject(histname[method].Data())); + return thresholdHist->GetBinContent(GetMomentumBin(track->P()) + 1); } //________________________________________________________________________ diff --git a/TRD/AliTRDpidUtil.h b/TRD/AliTRDpidUtil.h index 3353d5b3823..c5d320ea99e 100644 --- a/TRD/AliTRDpidUtil.h +++ b/TRD/AliTRDpidUtil.h @@ -31,7 +31,7 @@ public: 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); @@ -43,13 +43,13 @@ public: 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 diff --git a/TRD/AliTRDpropagationLayer.cxx b/TRD/AliTRDpropagationLayer.cxx index cd229cfd2fd..b8df200e1e7 100644 --- a/TRD/AliTRDpropagationLayer.cxx +++ b/TRD/AliTRDpropagationLayer.cxx @@ -113,8 +113,8 @@ AliTRDpropagationLayer::AliTRDpropagationLayer(const AliTRDpropagationLayer &p) :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) @@ -220,7 +220,7 @@ void AliTRDpropagationLayer::Copy(TObject &o) const } //_____________________________________________________________________________ -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 @@ -235,7 +235,7 @@ void AliTRDpropagationLayer::SetZ(Double_t *center, Double_t *w, Double_t *wsens } //_____________________________________________________________________________ -void AliTRDpropagationLayer::SetHoles(Bool_t *holes) +void AliTRDpropagationLayer::SetHoles(Bool_t * const holes) { // // Set centers and the width of sectors diff --git a/TRD/AliTRDpropagationLayer.h b/TRD/AliTRDpropagationLayer.h index ddcc28609c4..9bdd0b9739f 100644 --- a/TRD/AliTRDpropagationLayer.h +++ b/TRD/AliTRDpropagationLayer.h @@ -42,8 +42,8 @@ class AliTRDpropagationLayer : public TObject 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); @@ -65,7 +65,7 @@ class AliTRDpropagationLayer : public TObject 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; } diff --git a/TRD/AliTRDrecoParam.h b/TRD/AliTRDrecoParam.h index b3cc9e567bd..1be90bbcaa8 100644 --- a/TRD/AliTRDrecoParam.h +++ b/TRD/AliTRDrecoParam.h @@ -111,7 +111,7 @@ private: 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 diff --git a/TRD/AliTRDseed.cxx b/TRD/AliTRDseed.cxx index 6a77664081e..0b4feec503b 100644 --- a/TRD/AliTRDseed.cxx +++ b/TRD/AliTRDseed.cxx @@ -27,7 +27,6 @@ #include "AliMathBase.h" #include "AliTRDseed.h" -#include "AliTRDcalibDB.h" #include "AliTRDcluster.h" #include "AliTRDtracker.h" #include "AliTRDtrackerV1.h" @@ -64,7 +63,7 @@ AliTRDseed::AliTRDseed() 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 } @@ -185,7 +184,7 @@ void AliTRDseed::Reset() 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; } @@ -447,8 +446,8 @@ void AliTRDseed::Update() 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(); diff --git a/TRD/AliTRDseed.h b/TRD/AliTRDseed.h index 31e9ed052b9..822c16c42f4 100644 --- a/TRD/AliTRDseed.h +++ b/TRD/AliTRDseed.h @@ -60,8 +60,8 @@ public: 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; } @@ -79,7 +79,7 @@ public: 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; } diff --git a/TRD/AliTRDseedV1.cxx b/TRD/AliTRDseedV1.cxx index 1cd77b3c700..91e50ca6917 100644 --- a/TRD/AliTRDseedV1.cxx +++ b/TRD/AliTRDseedV1.cxx @@ -62,14 +62,14 @@ 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.) @@ -114,8 +114,8 @@ AliTRDseedV1::AliTRDseedV1(Int_t det) //____________________________________________________________________ AliTRDseedV1::AliTRDseedV1(const AliTRDseedV1 &ref) :AliTRDtrackletBase((AliTRDtrackletBase&)ref) - ,fReconstructor(0x0) - ,fClusterIter(0x0) + ,fkReconstructor(NULL) + ,fClusterIter(NULL) ,fExB(0.) ,fVD(0.) ,fT0(0.) @@ -176,7 +176,7 @@ AliTRDseedV1::~AliTRDseedV1() if(!fClusters[itb]) continue; //AliInfo(Form("deleting c %p @ %d", fClusters[itb], itb)); delete fClusters[itb]; - fClusters[itb] = 0x0; + fClusters[itb] = NULL; } } } @@ -191,8 +191,8 @@ void AliTRDseedV1::Copy(TObject &ref) const //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; @@ -347,7 +347,7 @@ void AliTRDseedV1::UseClusters() 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; @@ -392,7 +392,7 @@ void AliTRDseedV1::CookdEdx(Int_t nslices) const Double_t kDriftLength = (.5 * AliTRDgeometry::AmThick() + AliTRDgeometry::DrThick()); - AliTRDcluster *c = 0x0; + AliTRDcluster *c = NULL; for(int ic=0; icGetX()); @@ -417,7 +417,7 @@ void AliTRDseedV1::CookdEdx(Int_t nslices) 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; isGetPIDObject(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; ispecGetRecoParam()->GetSysCovMatrix(sys); + fkReconstructor->GetRecoParam()->GetSysCovMatrix(sys); sy2 += sys[0]; sz2 += sys[1]; } @@ -688,7 +688,7 @@ void AliTRDseedV1::GetCovAt(Double_t x, Double_t *cov) const } //____________________________________________________________ -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. @@ -707,38 +707,38 @@ Double_t AliTRDseedV1::GetCovSqrt(Double_t *c, Double_t *d) // Author A.Bercuci // 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. @@ -748,13 +748,13 @@ Double_t AliTRDseedV1::GetCovInv(Double_t *c, Double_t *d) // Author A.Bercuci // 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; } //____________________________________________________________________ @@ -859,7 +859,7 @@ void AliTRDseedV1::SetPadPlane(AliTRDpadPlane *p) //____________________________________________________________________ -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 : @@ -889,28 +889,28 @@ Bool_t AliTRDseedV1::AttachClusters(AliTRDtrackingChamber *chamber, Bool_t tilt) // 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); @@ -926,8 +926,8 @@ Bool_t AliTRDseedV1::AttachClusters(AliTRDtrackingChamber *chamber, Bool_t tilt) 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; @@ -993,8 +993,8 @@ Bool_t AliTRDseedV1::AttachClusters(AliTRDtrackingChamber *chamber, Bool_t tilt) 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); @@ -1016,7 +1016,7 @@ Bool_t AliTRDseedV1::AttachClusters(AliTRDtrackingChamber *chamber, Bool_t tilt) 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; } @@ -1107,7 +1107,7 @@ void AliTRDseedV1::Bootstrap(const AliTRDReconstructor *rec) // // A.Bercuci Oct 30th 2008 // - fReconstructor = rec; + fkReconstructor = rec; AliTRDgeometry g; AliTRDpadPlane *pp = g.GetPadPlane(fDet); fPad[0] = pp->GetLengthIPad(); @@ -1244,7 +1244,7 @@ Bool_t AliTRDseedV1::Fit(Bool_t tilt, Bool_t zcorr) 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; icSetSigmaY2(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 diff --git a/TRD/AliTRDseedV1.h b/TRD/AliTRDseedV1.h index 159b11b881d..9e51e52d99b 100644 --- a/TRD/AliTRDseedV1.h +++ b/TRD/AliTRDseedV1.h @@ -69,7 +69,7 @@ public: 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); @@ -96,23 +96,23 @@ public: 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);} @@ -168,7 +168,7 @@ public: 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;} @@ -185,7 +185,7 @@ private: 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 @@ -218,8 +218,8 @@ private: 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 }; @@ -268,7 +268,7 @@ inline void AliTRDseedV1::Init(const AliRieman *rieman) 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{ @@ -294,7 +294,7 @@ inline AliTRDcluster* AliTRDseedV1::NextCluster() } return *fClusterIter; } - return 0x0; + return NULL; } //____________________________________________________________ @@ -312,7 +312,7 @@ inline AliTRDcluster* AliTRDseedV1::PrevCluster() } return *fClusterIter; } - return 0x0; + return NULL; } //____________________________________________________________ diff --git a/TRD/AliTRDtrack.cxx b/TRD/AliTRDtrack.cxx index d40b5996fa0..d1e9b1e313c 100644 --- a/TRD/AliTRDtrack.cxx +++ b/TRD/AliTRDtrack.cxx @@ -22,8 +22,8 @@ #include "AliTRDgeometry.h" #include "AliTRDcluster.h" #include "AliTRDtrack.h" +#include "AliTRDtracklet.h" #include "AliTRDcalibDB.h" -#include "Cal/AliTRDCalPID.h" ClassImp(AliTRDtrack) @@ -31,6 +31,7 @@ ClassImp(AliTRDtrack) // // // Represents a reconstructed TRD track // // Local TRD Kalman track // +// Part of the old TRD tracking code // // // /////////////////////////////////////////////////////////////////////////////// @@ -60,7 +61,7 @@ AliTRDtrack::AliTRDtrack() // 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; @@ -139,7 +140,7 @@ AliTRDtrack::AliTRDtrack(AliTRDcluster *c, Int_t index 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; @@ -199,7 +200,7 @@ AliTRDtrack::AliTRDtrack(const AliTRDtrack &t/*, const Bool_t owner*/) // 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]; @@ -270,7 +271,7 @@ AliTRDtrack::AliTRDtrack(const AliKalmanTrack &t, Double_t /*alpha*/) 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; @@ -333,7 +334,7 @@ AliTRDtrack::AliTRDtrack(const AliESDtrack &t) } 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); @@ -492,7 +493,7 @@ void AliTRDtrack::CookdEdxTimBin(const Int_t/* tid*/) // 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 @@ -504,7 +505,7 @@ void AliTRDtrack::CookdEdxTimBin(const Int_t/* tid*/) 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; } @@ -530,7 +531,7 @@ void AliTRDtrack::CookdEdxTimBin(const Int_t/* tid*/) continue; } - slice = tb * kNslice / ntb; + slice = tb * AliTRDCalPID::kNSlicesLQ / ntb; fdEdxPlane[plane][slice] += fdQdl[iClus]; if (fdQdl[iClus] > maxcharge[plane]) { @@ -544,7 +545,7 @@ void AliTRDtrack::CookdEdxTimBin(const Int_t/* tid*/) // 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]; } @@ -572,8 +573,8 @@ void AliTRDtrack::CookdEdxNN(Float_t *dedx) // 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; } } @@ -599,9 +600,9 @@ void AliTRDtrack::CookdEdxNN(Float_t *dedx) 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 @@ -676,7 +677,7 @@ Bool_t AliTRDtrack::CookPID(Int_t &pidQuality) } // 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]); } @@ -717,7 +718,7 @@ Bool_t AliTRDtrack::CookPID(Int_t &pidQuality) 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); @@ -840,7 +841,7 @@ Bool_t AliTRDtrack::PropagateTo(Double_t xk, Double_t xx0, Double_t xrho) //_____________________________________________________________________________ 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 to the track and updates diff --git a/TRD/AliTRDtrack.h b/TRD/AliTRDtrack.h index 3d47d63b72b..a14f0793a20 100644 --- a/TRD/AliTRDtrack.h +++ b/TRD/AliTRDtrack.h @@ -12,13 +12,21 @@ // // /////////////////////////////////////////////////////////////////////////////// +#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; @@ -33,9 +41,7 @@ class AliTRDtrack : public AliKalmanTrack { , kNstacks = 90 , kNplane = AliESDtrack::kTRDnPlanes , kNcham = 5 - , kNsect = 18 - , kNslice = 3 - , kNMLPslice = 8 }; + , kNsect = 18 }; enum AliTRDPIDMethod { kNN = 0 @@ -75,8 +81,8 @@ class AliTRDtrack : public AliKalmanTrack { 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); @@ -90,7 +96,7 @@ class AliTRDtrack : public AliKalmanTrack { 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(); } @@ -116,14 +122,14 @@ class AliTRDtrack : public AliKalmanTrack { 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; } @@ -160,9 +166,9 @@ class AliTRDtrack : public AliKalmanTrack { 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; } @@ -172,22 +178,22 @@ class AliTRDtrack : public AliKalmanTrack { 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 @@ -196,12 +202,11 @@ class AliTRDtrack : public AliKalmanTrack { 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 diff --git a/TRD/AliTRDtrackGTU.cxx b/TRD/AliTRDtrackGTU.cxx index 6a20c6f680e..ca5ee784279 100644 --- a/TRD/AliTRDtrackGTU.cxx +++ b/TRD/AliTRDtrackGTU.cxx @@ -28,6 +28,7 @@ #include "TClass.h" #include "TH1F.h" +#include "AliESDTrdTrack.h" #include "AliLog.h" #include "AliTRDgtuParam.h" #include "AliTRDtrackGTU.h" @@ -70,7 +71,7 @@ AliTRDtrackGTU::~AliTRDtrackGTU() 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 diff --git a/TRD/AliTRDtrackGTU.h b/TRD/AliTRDtrackGTU.h index d179b27ad8d..302aa7694c4 100644 --- a/TRD/AliTRDtrackGTU.h +++ b/TRD/AliTRDtrackGTU.h @@ -14,7 +14,7 @@ #include "TClonesArray.h" #include "AliTRDtrackletGTU.h" -#include "AliESDTrdTrack.h" +class AliESDTrdTrack; class AliTRDtrackGTU : public TObject { public: @@ -48,7 +48,7 @@ class AliTRDtrackGTU : public TObject { 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; } diff --git a/TRD/AliTRDtrackV1.cxx b/TRD/AliTRDtrackV1.cxx index 8e988a10b38..58dba391030 100644 --- a/TRD/AliTRDtrackV1.cxx +++ b/TRD/AliTRDtrackV1.cxx @@ -42,10 +42,10 @@ ClassImp(AliTRDtrackV1) 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 @@ -59,7 +59,7 @@ AliTRDtrackV1::AliTRDtrackV1() : AliKalmanTrack() for(int ip=0; ip(&trklts[iplane]); ncls += fTracklet[iplane]->GetN(); } } @@ -211,14 +211,14 @@ AliTRDtrackV1::~AliTRDtrackV1() //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; ipIsOK()) continue; @@ -349,7 +349,7 @@ UChar_t AliTRDtrackV1::SetNumberOfTrackletsPID(Bool_t recalc) UChar_t fPIDquality = 0; // steer PID calculation @ tracklet level - Float_t *prob = 0x0; + Float_t *prob = NULL; for(int ip=0; ipIsOK()) continue; @@ -371,6 +371,7 @@ UChar_t AliTRDtrackV1::SetNumberOfTrackletsPID(Bool_t recalc) //_______________________________________________________________ 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; ipGetN(); continue; } - AliTRDcluster *c = 0x0; + AliTRDcluster *c = NULL; for(Int_t ic=AliTRDseedV1::kNclusters; ic--;){ if(!(c = fTracklet[ip]->GetClusters(ic))) continue; @@ -386,12 +387,13 @@ AliTRDcluster* AliTRDtrackV1::GetCluster(Int_t id) 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; ipGetN(); continue; } - AliTRDcluster *c = 0x0; + AliTRDcluster *c = NULL; for(Int_t ic=AliTRDseedV1::kNclusters; ic--;){ if(!(c = fTracklet[ip]->GetClusters(ic))) continue; @@ -437,6 +439,7 @@ Int_t AliTRDtrackV1::GetSector() const //_______________________________________________________________ Bool_t AliTRDtrackV1::IsEqual(const TObject *o) const { + // Checks whether two tracks are equal if (!o) return kFALSE; const AliTRDtrackV1 *inTrack = dynamic_cast(o); if (!inTrack) return kFALSE; @@ -493,7 +496,7 @@ Bool_t AliTRDtrackV1::IsEqual(const TObject *o) const //_______________________________________________________________ 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; } @@ -675,6 +678,7 @@ Int_t AliTRDtrackV1::PropagateToR(Double_t r,Double_t step) //_____________________________________________________________________________ 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])); @@ -749,7 +753,7 @@ void AliTRDtrackV1::SetOwner() } //_______________________________________________________________ -void AliTRDtrackV1::SetTracklet(AliTRDseedV1 *trklt, Int_t index) +void AliTRDtrackV1::SetTracklet(AliTRDseedV1 *const trklt, Int_t index) { // // Set the tracklets @@ -779,7 +783,7 @@ void AliTRDtrackV1::UnsetTracklet(Int_t plane) { if(plane<0 && plane >= kNplane) return; fTrackletIndex[plane] = 0xffff; - fTracklet[plane] = 0x0; + fTracklet[plane] = NULL; } @@ -804,7 +808,7 @@ void AliTRDtrackV1::UpdateESDtrack(AliESDtrack *track) // 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 @@ -818,7 +822,7 @@ void AliTRDtrackV1::UpdateESDtrack(AliESDtrack *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); diff --git a/TRD/AliTRDtrackV1.h b/TRD/AliTRDtrackV1.h index eafe6fde34e..f50f7bb9fa1 100644 --- a/TRD/AliTRDtrackV1.h +++ b/TRD/AliTRDtrackV1.h @@ -11,17 +11,13 @@ // // /////////////////////////////////////////////////////////////////////////////// -#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; @@ -70,7 +66,7 @@ public: }; 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(); @@ -94,13 +90,13 @@ public: 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 =0 && plane =0 && plane=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: @@ -142,7 +138,7 @@ 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) @@ -206,7 +202,7 @@ inline void AliTRDtrackV1::SetReconstructor(const AliTRDReconstructor *rec) if(!fTracklet[ip]) continue; fTracklet[ip]->SetReconstructor(rec); } - fReconstructor = rec; + fkReconstructor = rec; } //____________________________________________________ diff --git a/TRD/AliTRDtracker.cxx b/TRD/AliTRDtracker.cxx index 918f316cfb0..7e82a90dca4 100644 --- a/TRD/AliTRDtracker.cxx +++ b/TRD/AliTRDtracker.cxx @@ -36,7 +36,8 @@ #include "AliESDEvent.h" #include "AliESDtrack.h" -#include "AliAlignObj.h" +//#include "AliAlignObj.h" +#include "AliGeomManager.h" #include "AliRieman.h" #include "AliTrackPointArray.h" @@ -75,18 +76,18 @@ AliTRDtracker::AliTRDtracker(AliTRDReconstructor *rec) ,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) { // @@ -115,18 +116,18 @@ AliTRDtracker::AliTRDtracker(const AliTRDtracker &t) ,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) { // @@ -149,18 +150,18 @@ AliTRDtracker::AliTRDtracker(const TFile */*geomfile*/, AliTRDReconstructor *rec ,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) { // @@ -319,7 +320,7 @@ Int_t AliTRDtracker::GlobalToLocalID(Int_t gid) } //_____________________________________________________________________________ -Bool_t AliTRDtracker::AdjustSector(AliTRDtrack *track) +Bool_t AliTRDtracker::AdjustSector(AliTRDtrack* const track) const { // // Rotates the track when necessary @@ -345,7 +346,7 @@ Bool_t AliTRDtracker::AdjustSector(AliTRDtrack *track) } //_____________________________________________________________________________ -AliTRDcluster *AliTRDtracker::GetCluster(AliTRDtrack *track, Int_t plane +AliTRDcluster *AliTRDtracker::GetCluster(AliTRDtrack * const track, Int_t plane , Int_t timebin, UInt_t &index) { // @@ -353,7 +354,7 @@ AliTRDcluster *AliTRDtracker::GetCluster(AliTRDtrack *track, Int_t plane // 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) { @@ -379,14 +380,14 @@ AliTRDcluster *AliTRDtracker::GetCluster(AliTRDtrack *track, Int_t plane } //_____________________________________________________________________________ -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]); @@ -601,9 +602,9 @@ Int_t AliTRDtracker::PropagateBack(AliESDEvent *event) 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); @@ -625,9 +626,9 @@ Int_t AliTRDtracker::PropagateBack(AliESDEvent *event) //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 SetTRDslice(track->GetPIDsignals(i,j),i,j); } seed->SetTRDTimBin(track->GetPIDTimBin(i),i); @@ -712,15 +713,15 @@ Int_t AliTRDtracker::RefitInward(AliESDEvent *event) 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(pt->GetBackupIndexes()); for (Int_t l = 0; l < 200;++l) { if (indexes2[l] == 0) { break; @@ -748,7 +749,7 @@ Int_t AliTRDtracker::RefitInward(AliESDEvent *event) 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); @@ -768,7 +769,7 @@ Int_t AliTRDtracker::RefitInward(AliESDEvent *event) 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); @@ -2491,7 +2492,7 @@ Int_t AliTRDtracker::ReadClusters(TObjArray *array, TTree *clusterTree) const // 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 @@ -2783,7 +2784,7 @@ AliTRDtracker::AliTRDtrackingSector //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++) { @@ -2797,7 +2798,7 @@ AliTRDtracker::AliTRDtrackingSector ppl->SetYmax(ymax,ymaxsensitive); ppl->SetZ(zc,zmax,zmaxsensitive); ppl->SetHoles(holes); - if(iTime == T0) ppl->SetT0(); + if(iTime == t0) ppl->SetT0(); InsertLayer(ppl); @@ -3781,7 +3782,7 @@ Int_t AliTRDtracker::Freq(Int_t n, const Int_t *inlist } //_____________________________________________________________________________ -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 diff --git a/TRD/AliTRDtracker.h b/TRD/AliTRDtracker.h index e887ad7e4c3..8d281702c1b 100644 --- a/TRD/AliTRDtracker.h +++ b/TRD/AliTRDtracker.h @@ -59,13 +59,13 @@ class AliTRDtracker : public AliTracker { , 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; } @@ -73,7 +73,7 @@ class AliTRDtracker : public AliTracker { 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; @@ -100,14 +100,14 @@ class AliTRDtracker : public AliTracker { 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); @@ -131,7 +131,7 @@ class AliTRDtracker : public AliTracker { 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(); @@ -150,7 +150,7 @@ class AliTRDtracker : public AliTracker { }; 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 diff --git a/TRD/AliTRDtrackerDebug.cxx b/TRD/AliTRDtrackerDebug.cxx index f91ee07e3cf..70dd46e0c0f 100644 --- a/TRD/AliTRDtrackerDebug.cxx +++ b/TRD/AliTRDtrackerDebug.cxx @@ -25,8 +25,6 @@ // // /////////////////////////////////////////////////////////////////////////////// -#include "AliTRDtrackerDebug.h" - #include "TFile.h" #include "TTree.h" #include "TTreeStream.h" @@ -36,13 +34,15 @@ #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; @@ -51,10 +51,10 @@ Int_t AliTRDtrackerDebug::fgCandidateNumber = 0; //____________________________________________________ AliTRDtrackerDebug::AliTRDtrackerDebug() : AliTRDtrackerV1() - ,fOutputStreamer(0x0) - ,fTree(0x0) - ,fTracklet(0x0) - ,fTrack(0x0) + ,fOutputStreamer(NULL) + ,fTree(NULL) + ,fTracklet(NULL) + ,fTrack(NULL) ,fNClusters(0) ,fAlpha(0.) { @@ -74,7 +74,7 @@ AliTRDtrackerDebug::~AliTRDtrackerDebug() //____________________________________________________ -void AliTRDtrackerDebug::Draw(Option_t *) +void AliTRDtrackerDebug::Draw(Option_t *) { // steer draw function } @@ -119,7 +119,7 @@ Int_t AliTRDtrackerDebug::Process() //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; @@ -139,7 +139,7 @@ void AliTRDtrackerDebug::ResidualsClustersTrack(const AliTRDseedV1 *tracklet) // 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(); @@ -176,7 +176,7 @@ void AliTRDtrackerDebug::ResidualsClustersTracklet(const AliTRDseedV1 *tracklet) //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()*/; @@ -200,7 +200,7 @@ void AliTRDtrackerDebug::ResidualsClustersParametrisation(const AliTRDseedV1 *tr // 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"); @@ -242,8 +242,9 @@ void AliTRDtrackerDebug::ResidualsTrackletsTrack() const // 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); @@ -267,7 +268,7 @@ void AliTRDtrackerDebug::ResidualsTrackletsTrack() const 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 @@ -340,7 +341,7 @@ void AliTRDtrackerDebug::AnalyseFindable(Char_t *treename){ 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); @@ -385,7 +386,7 @@ void AliTRDtrackerDebug::AnalyseTiltedRiemanFit(){ 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); @@ -459,7 +460,7 @@ Float_t AliTRDtrackerDebug::GetDCA(Float_t a, Float_t b, Float_t c) const { //____________________________________________________ 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!"); @@ -470,8 +471,8 @@ void AliTRDtrackerDebug::AnalyseMinMax() 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]); @@ -514,18 +515,18 @@ TCanvas* AliTRDtrackerDebug::PlotSeedingConfiguration(const Char_t *direction, I 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); @@ -535,8 +536,8 @@ TCanvas* AliTRDtrackerDebug::PlotSeedingConfiguration(const Char_t *direction, I 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); @@ -595,7 +596,7 @@ TCanvas* AliTRDtrackerDebug::PlotSeedingConfiguration(const Char_t *direction, I delete seedcl; delete seedRef; delete riemanFit; - return 0x0; + return NULL; } } @@ -617,15 +618,15 @@ TCanvas* AliTRDtrackerDebug::PlotFullTrackFit(Int_t event, Int_t candidate, Int_ 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 @@ -634,7 +635,7 @@ TCanvas* AliTRDtrackerDebug::PlotFullTrackFit(Int_t event, Int_t candidate, Int_ if(!fTree){ AliError(Form("Tree %s not found in File TRD.TrackerDebug.root.", treename->Data())); delete treename; - return 0x0; + return NULL; } delete treename; @@ -646,8 +647,8 @@ TCanvas* AliTRDtrackerDebug::PlotFullTrackFit(Int_t event, Int_t candidate, Int_ 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); @@ -774,7 +775,7 @@ TCanvas* AliTRDtrackerDebug::PlotFullTrackFit(Int_t event, Int_t candidate, Int_ else{ AliError(Form("Combination consisting of event %d and candidate %d not found", event, candidate)); delete fitfun; - return 0x0; + return NULL; } } diff --git a/TRD/AliTRDtrackerDebug.h b/TRD/AliTRDtrackerDebug.h index a17ff443717..2278e2b4ffb 100644 --- a/TRD/AliTRDtrackerDebug.h +++ b/TRD/AliTRDtrackerDebug.h @@ -17,9 +17,7 @@ // // //////////////////////////////////////////////////////////////////////////// -#ifndef ALITRDTRACKERV1_H #include "AliTRDtrackerV1.h" -#endif class TTree; class TCanvas; diff --git a/TRD/AliTRDtrackerV1.cxx b/TRD/AliTRDtrackerV1.cxx index b4ad87e8d0f..55cb7ca5e23 100644 --- a/TRD/AliTRDtrackerV1.cxx +++ b/TRD/AliTRDtrackerV1.cxx @@ -25,10 +25,6 @@ // // /////////////////////////////////////////////////////////////////////////////// -// #include -// #include -// #include - #include #include #include @@ -60,11 +56,8 @@ #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; // @@ -78,18 +71,18 @@ Double_t AliTRDtrackerV1::fgTopologicQA[kNConfigs] = { 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) { // @@ -104,7 +97,7 @@ AliTRDtrackerV1::AliTRDtrackerV1(AliTRDReconstructor *rec) } 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--;){ @@ -120,7 +113,7 @@ AliTRDtrackerV1::AliTRDtrackerV1(AliTRDReconstructor *rec) } // initialize calibration values - AliTRDcalibDB *trd = 0x0; + AliTRDcalibDB *trd = NULL; if (!(trd = AliTRDcalibDB::Instance())) { AliFatal("Could not get calibration."); } @@ -142,9 +135,9 @@ AliTRDtrackerV1::~AliTRDtrackerV1() // 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; islDelete(); delete fTracks;} if(fTracklets) {fTracklets->Delete(); delete fTracklets;} @@ -172,7 +165,7 @@ Int_t AliTRDtrackerV1::Clusters2Tracks(AliESDEvent *esd) // See AliTRDtrackerV1::Clusters2TracksSM() for details. // - if(!fReconstructor->GetRecoParam() ){ + if(!fkReconstructor->GetRecoParam() ){ AliError("Reconstruction configuration not initialized. Call first AliTRDReconstructor::SetRecoParam()."); return 0; } @@ -286,8 +279,8 @@ Int_t AliTRDtrackerV1::PropagateBack(AliESDEvent *event) 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) @@ -338,7 +331,7 @@ Int_t AliTRDtrackerV1::PropagateBack(AliESDEvent *event) 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 @@ -359,7 +352,7 @@ Int_t AliTRDtrackerV1::PropagateBack(AliESDEvent *event) // 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); @@ -422,7 +415,7 @@ Int_t AliTRDtrackerV1::PropagateBack(AliESDEvent *event) //(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())){ @@ -455,7 +448,7 @@ Int_t AliTRDtrackerV1::PropagateBack(AliESDEvent *event) AliInfo(Form("Number of tracks: TRDout[%d]", nFound)); // run stand alone tracking - if (fReconstructor->IsSeeding()) Clusters2Tracks(event); + if (fkReconstructor->IsSeeding()) Clusters2Tracks(event); return 0; } @@ -507,9 +500,9 @@ Int_t AliTRDtrackerV1::RefitInward(AliESDEvent *event) } // 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(o))) continue; calibTrack->SetTrackHigh(track.GetTrackHigh()); @@ -615,7 +608,7 @@ Int_t AliTRDtrackerV1::FollowProlongation(AliTRDtrackV1 &t) } } - if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1){ + if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1){ Int_t index; for(int iplane=0; iplaneGetDebugStream(AliTRDReconstructor::kTracker); + TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker); AliTRDtrackV1 track(t); track.SetOwner(); cstreamer << "FollowProlongation" @@ -682,9 +675,9 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t) 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); @@ -695,7 +688,7 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t) 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 @@ -710,7 +703,7 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t) // 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) || @@ -759,16 +752,16 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t) 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); @@ -811,13 +804,13 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t) 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); @@ -830,7 +823,7 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t) 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; } @@ -866,7 +859,7 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t) 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); @@ -876,7 +869,7 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t) 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 @@ -933,8 +926,8 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t) //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(); @@ -949,7 +942,7 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t) } //_________________________________________________________________________ -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 @@ -1053,7 +1046,7 @@ Float_t AliTRDtrackerV1::FitTiltedRiemanConstraint(AliTRDseedV1 *tracklets, Doub 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]; @@ -1089,7 +1082,7 @@ Float_t AliTRDtrackerV1::FitTiltedRiemanConstraint(AliTRDseedV1 *tracklets, Doub 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); @@ -1097,7 +1090,7 @@ Float_t AliTRDtrackerV1::FitTiltedRiemanConstraint(AliTRDseedV1 *tracklets, Doub 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 @@ -1146,7 +1139,7 @@ Float_t AliTRDtrackerV1::FitTiltedRieman(AliTRDseedV1 *tracklets, Bool_t sigErro 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; @@ -1309,8 +1302,8 @@ Float_t AliTRDtrackerV1::FitTiltedRieman(AliTRDseedV1 *tracklets, Bool_t sigErro 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); @@ -1328,10 +1321,15 @@ Float_t AliTRDtrackerV1::FitTiltedRieman(AliTRDseedV1 *tracklets, Bool_t sigErro //____________________________________________________________________ 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; @@ -1450,9 +1448,9 @@ Double_t AliTRDtrackerV1::FitRiemanTilt(const AliTRDtrackV1 *track, AliTRDseedV1 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; @@ -1529,9 +1527,9 @@ Double_t AliTRDtrackerV1::FitRiemanTilt(const AliTRDtrackV1 *track, AliTRDseedV1 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); @@ -1540,7 +1538,7 @@ Double_t AliTRDtrackerV1::FitRiemanTilt(const AliTRDtrackV1 *track, AliTRDseedV1 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); @@ -1551,7 +1549,7 @@ Double_t AliTRDtrackerV1::FitRiemanTilt(const AliTRDtrackV1 *track, AliTRDseedV1 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); } } @@ -1560,7 +1558,7 @@ Double_t AliTRDtrackerV1::FitRiemanTilt(const AliTRDtrackV1 *track, AliTRDseedV1 Float_t xyz[3]; for(int ip=0; ip 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); } @@ -1571,7 +1569,7 @@ Double_t AliTRDtrackerV1::FitRiemanTilt(const AliTRDtrackV1 *track, AliTRDseedV1 //____________________________________________________________________ -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" @@ -1590,17 +1588,17 @@ Double_t AliTRDtrackerV1::FitKalman(AliTRDtrackV1 *track, AliTRDseedV1 *tracklet //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(&tracklets[iplane]))) continue; }else{ if(!(ptrTracklet = track->GetTracklet(iplane))){ - /*AliTRDtrackerV1 *tracker = 0x0; + /*AliTRDtrackerV1 *tracker = NULL; if(!(tracker = dynamic_cast( AliTRDReconstructor::Tracker()))) continue; ptrTracklet = new(&tracklet) AliTRDseedV1(iplane); if(!tracker->MakeTracklet(ptrTracklet, track)) */ @@ -1796,8 +1794,8 @@ Int_t AliTRDtrackerV1::ReadClusters(TClonesArray* &array, TTree *clusterTree) co 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); } @@ -1806,7 +1804,7 @@ Int_t AliTRDtrackerV1::ReadClusters(TClonesArray* &array, TTree *clusterTree) co 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); @@ -1832,7 +1830,7 @@ Int_t AliTRDtrackerV1::LoadClusters(TTree *cTree) // Fills clusters into TRD tracking sectors // - if(!fReconstructor->IsWritingClusters()){ + if(!fkReconstructor->IsWritingClusters()){ fClusters = AliTRDReconstructor::GetClusters(); } else { if (ReadClusters(fClusters, cTree)) { @@ -1857,7 +1855,7 @@ Int_t AliTRDtrackerV1::LoadClusters(TTree *cTree) } //_____________________________________________________________________________ -Int_t AliTRDtrackerV1::LoadClusters(TClonesArray *clusters) +Int_t AliTRDtrackerV1::LoadClusters(TClonesArray * const clusters) { // // Fills clusters into TRD tracking sectors @@ -1901,7 +1899,7 @@ Int_t AliTRDtrackerV1::BuildTrackingContainers() const AliTRDCalDet *cal = AliTRDcalibDB::Instance()->GetT0Det(); for(int isector =0; isectorDelete(); - 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(); @@ -1947,10 +1945,10 @@ void AliTRDtrackerV1::UnloadClusters() // const AliTRDtrackV1 *track = dynamic_cast(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(); @@ -1960,7 +1958,7 @@ void AliTRDtrackerV1::UnloadClusters() // //_____________________________________________________________________________ -Bool_t AliTRDtrackerV1::AdjustSector(AliTRDtrackV1 *track) +Bool_t AliTRDtrackerV1::AdjustSector(AliTRDtrackV1 *const track) { // // Rotates the track when necessary @@ -1987,7 +1985,7 @@ Bool_t AliTRDtrackerV1::AdjustSector(AliTRDtrackV1 *track) //____________________________________________________________________ -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 // Parameters @@ -2001,13 +1999,13 @@ AliTRDseedV1* AliTRDtrackerV1::GetTracklet(AliTRDtrackV1 *track, Int_t p, Int_t // 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 // @@ -2030,7 +2028,7 @@ AliTRDseedV1* AliTRDtrackerV1::SetTracklet(AliTRDseedV1 *tracklet) } //____________________________________________________________________ -AliTRDtrackV1* AliTRDtrackerV1::SetTrack(AliTRDtrackV1 *track) +AliTRDtrackV1* AliTRDtrackerV1::SetTrack(const AliTRDtrackV1 * const track) { // Add this track to the list of tracks stored in the tracker // @@ -2082,13 +2080,13 @@ Int_t AliTRDtrackerV1::Clusters2TracksSM(Int_t sector, AliESDEvent *esd) Int_t nTracks = 0; Int_t nChambers = 0; - AliTRDtrackingChamber **stack = 0x0, *chamber = 0x0; + AliTRDtrackingChamber **stack = NULL, *chamber = NULL; for(int istack = 0; istackGetNClusters() < 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())); } @@ -2108,7 +2106,7 @@ Int_t AliTRDtrackerV1::Clusters2TracksSM(Int_t sector, AliESDEvent *esd) } //____________________________________________________________________ -Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClonesArray *esdTrackList) +Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClonesArray * const esdTrackList) { // // Make tracks in one TRD stack. @@ -2137,8 +2135,8 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon // 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 @@ -2155,7 +2153,7 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon // 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)); } @@ -2184,7 +2182,7 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon //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; @@ -2204,7 +2202,7 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon // 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)); @@ -2295,7 +2293,7 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon 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]; @@ -2305,7 +2303,7 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon 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 @@ -2344,7 +2342,7 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon 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); @@ -2360,19 +2358,19 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon // 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 @@ -2412,7 +2410,7 @@ Double_t AliTRDtrackerV1::BuildSeedingConfigs(AliTRDtrackingChamber **stack, Int // Double_t chamberQ[kNPlanes];memset(chamberQ, 0, kNPlanes*sizeof(Double_t)); - AliTRDtrackingChamber *chamber = 0x0; + AliTRDtrackingChamber *chamber = NULL; for(int iplane=0; iplaneGetQuality() : 0.; @@ -2435,7 +2433,7 @@ Double_t AliTRDtrackerV1::BuildSeedingConfigs(AliTRDtrackingChamber **stack, Int } //____________________________________________________________________ -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 @@ -2497,9 +2495,9 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss // Alexandru Bercuci // Markus Fasel - 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(&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 @@ -2522,7 +2520,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss 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; iplaneGetPadPlane(iplane, istack); hL[iplane] = TMath::Tan(TMath::DegToRad()*pp->GetTiltingAngle()); @@ -2533,7 +2531,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss // 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]; @@ -2547,7 +2545,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss 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)); } @@ -2556,7 +2554,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss Int_t nlayers = 0; for(int isl=0; islGetSeedingLayer(fSeedTB[isl], fGeom, fReconstructor)) continue; + if(!chamber->GetSeedingLayer(fSeedTB[isl], fGeom, fkReconstructor)) continue; nlayers++; } if(nlayers < kNSeedPlanes) return ntracks; @@ -2605,14 +2603,14 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss 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; @@ -2625,7 +2623,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss 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 @@ -2655,12 +2653,12 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss <<"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; @@ -2692,7 +2690,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss } // temporary exit door for the HLT - if(fReconstructor->IsHLT()){ + if(fkReconstructor->IsHLT()){ // attach clusters to extrapolation chambers for(int iLayer=0; iLayerGetRecoParam() ->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; @@ -2746,8 +2744,8 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss // 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(); @@ -2764,7 +2762,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss << "\n"; } - if(fReconstructor->HasImproveTracklets() && ImproveSeedQuality(stack, cseed) < 4){ + if(fkReconstructor->HasImproveTracklets() && ImproveSeedQuality(stack, cseed) < 4){ AliTRDtrackerDebug::SetCandidateNumber(AliTRDtrackerDebug::GetCandidateNumber() + 1); continue; } @@ -2778,7 +2776,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss // 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.; @@ -2788,8 +2786,8 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss 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(); @@ -2832,7 +2830,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss } //_____________________________________________________________________________ -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 @@ -2871,13 +2869,13 @@ AliTRDtrackV1* AliTRDtrackerV1::MakeTrack(AliTRDseedV1 *seeds, Double_t *params) 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(&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); @@ -2886,18 +2884,18 @@ AliTRDtrackV1* AliTRDtrackerV1::MakeTrack(AliTRDseedV1 *seeds, Double_t *params) } 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 @@ -2916,10 +2914,10 @@ AliTRDtrackV1* AliTRDtrackerV1::MakeTrack(AliTRDseedV1 *seeds, Double_t *params) << "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 @@ -2957,7 +2955,7 @@ Int_t AliTRDtrackerV1::ImproveSeedQuality(AliTRDtrackingChamber **stack, AliTRDs // // 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]; @@ -2992,11 +2990,11 @@ Int_t AliTRDtrackerV1::ImproveSeedQuality(AliTRDtrackingChamber **stack, AliTRDs } 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 @@ -3016,7 +3014,7 @@ Int_t AliTRDtrackerV1::ImproveSeedQuality(AliTRDtrackingChamber **stack, AliTRDs } //_________________________________________________________________________ -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 @@ -3044,16 +3042,16 @@ Double_t AliTRDtrackerV1::CalculateTrackLikelihood(AliTRDseedV1 *tracklets, Doub 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 @@ -3096,7 +3094,7 @@ Double_t AliTRDtrackerV1::CookLikelihood(AliTRDseedV1 *cseed, Int_t planes[4]) // // 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]); @@ -3112,23 +3110,23 @@ Double_t AliTRDtrackerV1::CookLikelihood(AliTRDseedV1 *cseed, Int_t planes[4]) 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 @@ -3147,7 +3145,7 @@ Double_t AliTRDtrackerV1::CookLikelihood(AliTRDseedV1 *cseed, Int_t planes[4]) << "nclusters=" << nclusters << "likeN=" << likeN << "like=" << like - << "meanncls=" << mean_ncls + << "meanncls=" << meanNcls << "\n"; } @@ -3379,21 +3377,21 @@ void AliTRDtrackerV1::GetExtrapolationConfig(Int_t iconfig, Int_t planes[2]) 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; } @@ -3472,7 +3470,7 @@ void AliTRDtrackerV1::ResetSeedTB() //_____________________________________________________________________________ -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 @@ -3487,7 +3485,7 @@ Float_t AliTRDtrackerV1::GetChi2Y(AliTRDseedV1 *tracklets) const } //_____________________________________________________________________________ -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 @@ -3502,7 +3500,7 @@ Float_t AliTRDtrackerV1::GetChi2Z(AliTRDseedV1 *tracklets) const } //____________________________________________________________________ -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 @@ -3556,7 +3554,7 @@ Float_t AliTRDtrackerV1::CalculateReferenceX(AliTRDseedV1 *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 @@ -3601,13 +3599,13 @@ AliTRDtrackerV1::AliTRDLeastSquare::AliTRDLeastSquare(){ } //_____________________________________________________________________________ -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; @@ -3618,14 +3616,14 @@ void AliTRDtrackerV1::AliTRDLeastSquare::AddPoint(Double_t *x, Double_t y, Doubl } //_____________________________________________________________________________ -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; @@ -3659,7 +3657,7 @@ void AliTRDtrackerV1::AliTRDLeastSquare::Eval(){ } //_____________________________________________________________________________ -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 // @@ -3806,7 +3804,7 @@ Double_t AliTRDtrackerV1::AliTRDtrackFitterRieman::Eval(){ } //_____________________________________________________________________________ -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 diff --git a/TRD/AliTRDtrackerV1.h b/TRD/AliTRDtrackerV1.h index 45aad5dc2a3..523fa17018c 100644 --- a/TRD/AliTRDtrackerV1.h +++ b/TRD/AliTRDtrackerV1.h @@ -17,17 +17,17 @@ // // //////////////////////////////////////////////////////////////////////////// -#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 -#endif +//#endif /************************************************************************** * Class Status see source file * @@ -50,6 +50,7 @@ class AliTRDchamberTimeBin; class AliTRDtrackerFitter; class AliTRDtrackV1; class AliTRDReconstructor; + class AliTRDtrackerV1 : public AliTracker { public: @@ -67,7 +68,7 @@ public: , kMaxTracksStack = 100 , kNConfigs = 15 }; - AliTRDtrackerV1(AliTRDReconstructor *rec = 0x0); + AliTRDtrackerV1(AliTRDReconstructor *rec = NULL); virtual ~AliTRDtrackerV1(); //temporary @@ -87,30 +88,30 @@ public: 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{ @@ -118,13 +119,13 @@ public: 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 &); @@ -149,13 +150,13 @@ public: 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(); @@ -172,33 +173,33 @@ public: }; 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 diff --git a/TRD/AliTRDtrackingChamber.cxx b/TRD/AliTRDtrackingChamber.cxx index 86021a0d94a..27bc7cee4c8 100644 --- a/TRD/AliTRDtrackingChamber.cxx +++ b/TRD/AliTRDtrackingChamber.cxx @@ -62,7 +62,7 @@ void AliTRDtrackingChamber::InsertCluster(AliTRDcluster *c, Int_t index) } //_______________________________________________________ -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 @@ -200,7 +200,7 @@ Double_t AliTRDtrackingChamber::GetQuality() //_______________________________________________________ -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 @@ -234,7 +234,7 @@ Bool_t AliTRDtrackingChamber::GetSeedingLayer(AliTRDchamberTimeBin *&fakeLayer, 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]; @@ -379,7 +379,7 @@ Bool_t AliTRDtrackingChamber::GetSeedingLayer(AliTRDchamberTimeBin *&fakeLayer, 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(); @@ -409,6 +409,7 @@ Bool_t AliTRDtrackingChamber::GetSeedingLayer(AliTRDchamberTimeBin *&fakeLayer, //_______________________________________________________ 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)); diff --git a/TRD/AliTRDtrackingChamber.h b/TRD/AliTRDtrackingChamber.h index 54fb5a31d0e..da6adc3a421 100644 --- a/TRD/AliTRDtrackingChamber.h +++ b/TRD/AliTRDtrackingChamber.h @@ -36,17 +36,17 @@ public: 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(); diff --git a/TRD/AliTRDtrackingSector.cxx b/TRD/AliTRDtrackingSector.cxx index f63de7cc282..99789dcee3c 100644 --- a/TRD/AliTRDtrackingSector.cxx +++ b/TRD/AliTRDtrackingSector.cxx @@ -25,10 +25,6 @@ // // /////////////////////////////////////////////////////////////////////////////// -#include "AliTRDcalibDB.h" -#include "AliTRDCommonParam.h" -#include "AliTRDReconstructor.h" -#include "AliTRDpadPlane.h" #include "AliTRDtrackingSector.h" #include "AliTRDtrackingChamber.h" @@ -39,7 +35,7 @@ ClassImp(AliTRDtrackingSector) AliTRDtrackingSector::AliTRDtrackingSector() :fSector(-1) ,fN(0) - ,fGeom(0x0) + ,fGeom(NULL) { // Default constructor @@ -71,7 +67,7 @@ void AliTRDtrackingSector::Init(const AliTRDReconstructor *rec, const AliTRDCalD // Propagate radial position information (calibration/alignment aware) from chambers to sector level // - AliTRDchamberTimeBin *tb = 0x0; + AliTRDchamberTimeBin *tb = NULL; AliTRDtrackingChamber **tc = &fChamber[0]; for(Int_t ic = 0; (icClear(opt); - delete (*tc); (*tc) = 0x0; // I would avoid + delete (*tc); (*tc) = NULL; // I would avoid } memset(fIndex, -1, AliTRDgeometry::kNdets*sizeof(Char_t)); fN = 0; @@ -122,7 +118,7 @@ AliTRDtrackingChamber* AliTRDtrackingSector::GetChamber(Int_t stack, Int_t layer Int_t ch = stack*AliTRDgeometry::kNlayer + layer; if(fIndex[ch] >= 0) return fChamber[Int_t(fIndex[ch])]; - else if(!build) return 0x0; + else if(!build) return NULL; // CHAMBER HAS TO BE BUILD Int_t rch = ch;do rch--; while(rch>=0 && fIndex[rch]<0); @@ -143,19 +139,19 @@ AliTRDtrackingChamber** AliTRDtrackingSector::GetStack(Int_t stack) // Return chamber at position (stack, plane) in current // sector or build a new one if it is not already created - if(stack<0 || stack>=AliTRDgeometry::kNstack) return 0x0; + if(stack<0 || stack>=AliTRDgeometry::kNstack) return NULL; Int_t ich, n = 0; for(int il=0; il=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*/); diff --git a/TRD/Cal/AliTRDCalPID.h b/TRD/Cal/AliTRDCalPID.h index e7c82d2f4d4..1c53ad39270 100644 --- a/TRD/Cal/AliTRDCalPID.h +++ b/TRD/Cal/AliTRDCalPID.h @@ -25,7 +25,9 @@ class AliTRDCalPID : public TNamed public: enum { - kNMom = 11 + kNMom = 11, + kNSlicesLQ = 3, + kNSlicesNN = 8 }; AliTRDCalPID(); diff --git a/TRD/Cal/AliTRDCalPIDNN.cxx b/TRD/Cal/AliTRDCalPIDNN.cxx index e63ad429817..2a59ce2d195 100644 --- a/TRD/Cal/AliTRDCalPIDNN.cxx +++ b/TRD/Cal/AliTRDCalPIDNN.cxx @@ -29,7 +29,7 @@ #include #include "AliPID.h" -#include "AliTRDtrack.h" +#include "AliLog.h" #include "AliTRDgeometry.h" #include "AliTRDCalPIDNN.h" @@ -162,11 +162,11 @@ Double_t AliTRDCalPIDNN::GetProbability(Int_t spec, Float_t mom return 0.; } - Double_t ddedx[AliTRDtrack::kNMLPslice]; + Double_t ddedx[AliTRDCalPID::kNSlicesNN]; - for (int inode=0; inodeGetNumberOfTimeBins()/AliTRDtrack::kNMLPslice); + / (AliTRDcalibDB::Instance()->GetNumberOfTimeBins()/AliTRDCalPID::kNSlicesNN); } lNN1 = nn->Evaluate(spec, ddedx); diff --git a/TRD/Cal/AliTRDCalPIDRefMaker.cxx b/TRD/Cal/AliTRDCalPIDRefMaker.cxx index dc076dced3c..e98b11a0dc0 100644 --- a/TRD/Cal/AliTRDCalPIDRefMaker.cxx +++ b/TRD/Cal/AliTRDCalPIDRefMaker.cxx @@ -55,7 +55,6 @@ #include "AliTRDCalPID.h" #include "AliTRDcalibDB.h" #include "AliTRDgeometry.h" -#include "AliTRDtrack.h" ClassImp(AliTRDCalPIDRefMaker) @@ -286,11 +285,11 @@ Bool_t AliTRDCalPIDRefMaker::BuildLQReferences(const Char_t *File, const Char_t 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; iLayerGetTRDslice(iLayer, iSlice); dEdx = esdTrack->GetTRDslice(iLayer, -1); timebin = esdTrack->GetTRDTimBin(iLayer); diff --git a/TRD/qaRec/AliTRDcheckPID.cxx b/TRD/qaRec/AliTRDcheckPID.cxx index 516e3f43666..adeca4e3a57 100644 --- a/TRD/qaRec/AliTRDcheckPID.cxx +++ b/TRD/qaRec/AliTRDcheckPID.cxx @@ -507,7 +507,7 @@ TH1 *AliTRDcheckPID::PlotdEdxSlice(const AliTRDtrackV1 *track) tracklet = cTrack.GetTracklet(iChamb); if(!tracklet) continue; tracklet -> CookdEdx(AliTRDpidUtil::kLQslices); - fdEdx = tracklet->GetdEdx(); + fdEdx = const_cast(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]); } diff --git a/TRD/qaRec/AliTRDpidRefMaker.cxx b/TRD/qaRec/AliTRDpidRefMaker.cxx index ba448818f27..7ec814a1efe 100644 --- a/TRD/qaRec/AliTRDpidRefMaker.cxx +++ b/TRD/qaRec/AliTRDpidRefMaker.cxx @@ -221,7 +221,7 @@ void AliTRDpidRefMaker::Exec(Option_t *) 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(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)); @@ -236,7 +236,7 @@ void AliTRDpidRefMaker::Exec(Option_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(TRDtracklet->GetdEdx()); memcpy(fdEdx, dedx, AliTRDpidUtil::kLQslices*sizeof(Float_t)); if(fDebugLevel>=2) Printf("LayerLQ : %d", ily); fLayer = ily; -- 2.39.3