From d76c31f4f41294d7ae5a31c2c56a682abef0b827 Mon Sep 17 00:00:00 2001 From: cvetan Date: Wed, 26 Sep 2007 14:22:18 +0000 Subject: [PATCH] Important changes to the reconstructor classes. Complete elimination of the run-loaders, which are now steered only from AliReconstruction. Removal of the corresponding Reconstruct() and FillESD() methods. --- EMCAL/AliEMCALReconstructor.h | 4 +- FMD/AliFMDReconstructor.cxx | 78 +---- FMD/AliFMDReconstructor.h | 42 +-- HLT/src/AliHLTReconstructor.cxx | 490 ++++++++++++++--------------- HLT/src/AliHLTReconstructor.h | 30 +- HMPID/AliHMPIDQualAssDataMaker.cxx | 113 ++++--- HMPID/AliHMPIDQualAssDataMaker.h | 10 +- HMPID/AliHMPIDReconstructor.cxx | 45 +-- HMPID/AliHMPIDReconstructor.h | 7 +- ITS/AliITSReconstructor.cxx | 46 ++- ITS/AliITSReconstructor.h | 29 +- ITS/AliITSpidESD.h | 5 +- ITS/AliITSpidESD1.h | 5 +- ITS/AliITSpidESD2.cxx | 16 +- ITS/AliITSpidESD2.h | 11 +- MUON/AliMUONReconstructor.cxx | 107 +------ MUON/AliMUONReconstructor.h | 10 +- MUON/AliMUONTracker.cxx | 16 +- MUON/AliMUONTracker.h | 5 +- PHOS/AliPHOSClusterizer.cxx | 9 +- PHOS/AliPHOSClusterizer.h | 6 +- PHOS/AliPHOSClusterizerv1.cxx | 17 +- PHOS/AliPHOSClusterizerv2.cxx | 6 - PHOS/AliPHOSDigitizer.cxx | 6 +- PHOS/AliPHOSPID.cxx | 13 +- PHOS/AliPHOSPID.h | 8 +- PHOS/AliPHOSQualAssDataMaker.cxx | 154 +++++---- PHOS/AliPHOSQualAssDataMaker.h | 14 +- PHOS/AliPHOSReconstructor.cxx | 18 +- PHOS/AliPHOSReconstructor.h | 10 +- PHOS/AliPHOSSDigitizer.cxx | 9 +- PHOS/AliPHOSTrackSegmentMaker.cxx | 11 +- PHOS/AliPHOSTrackSegmentMaker.h | 7 +- PMD/AliPMDReconstructor.cxx | 53 ---- PMD/AliPMDReconstructor.h | 17 +- STEER/AliQualAssDataMaker.cxx | 62 ++-- STEER/AliQualAssDataMaker.h | 23 +- STEER/AliReconstruction.cxx | 168 ++++------ STEER/AliReconstructor.cxx | 38 --- STEER/AliReconstructor.h | 14 +- T0/AliT0Reconstructor.cxx | 31 +- T0/AliT0Reconstructor.h | 18 +- TOF/AliTOFReconstructor.cxx | 72 +---- TOF/AliTOFReconstructor.h | 21 +- TPC/AliTPCReconstructor.cxx | 80 +---- TPC/AliTPCReconstructor.h | 25 +- VZERO/AliVZEROReconstructor.cxx | 2 +- VZERO/AliVZEROReconstructor.h | 15 +- 48 files changed, 686 insertions(+), 1310 deletions(-) diff --git a/EMCAL/AliEMCALReconstructor.h b/EMCAL/AliEMCALReconstructor.h index 994f56a1e66..77bf6fad83b 100644 --- a/EMCAL/AliEMCALReconstructor.h +++ b/EMCAL/AliEMCALReconstructor.h @@ -41,9 +41,9 @@ public: using AliReconstructor::FillESD; virtual void FillESD(TTree* digitsTree, TTree* clustersTree, AliESDEvent* esd) const; - AliTracker* CreateTracker (AliRunLoader* )const{return new AliEMCALTracker;} + AliTracker* CreateTracker () const + {return new AliEMCALTracker;} using AliReconstructor::Reconstruct; - virtual Bool_t HasLocalReconstruction() const {return kTRUE;}; virtual void Reconstruct(TTree* digitsTree, TTree* clustersTree) const; virtual Bool_t HasDigitConversion() const {return kTRUE;}; diff --git a/FMD/AliFMDReconstructor.cxx b/FMD/AliFMDReconstructor.cxx index 85c6dfe32ee..fb9a17dd0f9 100644 --- a/FMD/AliFMDReconstructor.cxx +++ b/FMD/AliFMDReconstructor.cxx @@ -35,8 +35,6 @@ // #include // ALILOG_H // #include // ALIRUN_H #include "AliFMDDebug.h" -// to be removed as soon as we remove it from the base class -#include "AliRunLoader.h" #include "AliFMDGeometry.h" // ALIFMDGEOMETRY_H #include "AliFMDParameters.h" // ALIFMDPARAMETERS_H #include "AliFMDDigit.h" // ALIFMDDIGIT_H @@ -140,7 +138,7 @@ AliFMDReconstructor::~AliFMDReconstructor() //____________________________________________________________________ void -AliFMDReconstructor::Init(AliRunLoader* /*runLoader*/) +AliFMDReconstructor::Init() { // Initialize the reconstructor @@ -504,80 +502,6 @@ AliFMDReconstructor::FillESD(TTree* /* digitsTree */, if (fDiagAll) fDiagAll->Reset(); } - -//____________________________________________________________________ -void -AliFMDReconstructor::Reconstruct(AliRawReader* reader, - TTree* /* ctree */) const -{ - // Cannot be used. See member function with same name but with 2 - // TTree arguments. Make sure you do local reconstrucion - AliFMDDebug(2, ("Calling FillESD with loader and tree")); -#if 1 - TClonesArray* array = new TClonesArray("AliFMDDigit"); - // if (ctree) ctree->Branch("FMD", &array); - AliFMDRawReader rawRead(reader, 0); - rawRead.ReadAdcs(array); - // ctree->Fill(); - // Question - how to get the digits in this case? - ProcessDigits(array); - // Reconstruct(array, ctree); - array->Delete(); - delete array; -#else - AliError("MayNotUse"); -#endif -} -//____________________________________________________________________ -void -AliFMDReconstructor::Reconstruct(AliRunLoader*) const -{ - // Cannot be used. See member function with same name but with 2 - // TTree arguments. Make sure you do local reconstrucion - AliFMDDebug(2, ("Calling FillESD with loader")); - AliError("MayNotUse"); -} -//____________________________________________________________________ -void -AliFMDReconstructor::Reconstruct(AliRunLoader*, AliRawReader*) const -{ - // Cannot be used. See member function with same name but with 2 - // TTree arguments. Make sure you do local reconstrucion - AliFMDDebug(2, ("Calling FillESD with loader and raw reader")); - AliError("MayNotUse"); -} -//____________________________________________________________________ -void -AliFMDReconstructor::FillESD(AliRawReader*,TTree*,AliESDEvent* esd) const -{ - // Cannot be used. See member function with same name but with 2 - // TTree arguments. Make sure you do local reconstrucion - AliFMDDebug(2, ("Calling FillESD with raw reader, tree, and ESD")); -#if 1 - FillESD((TTree*)0, (TTree*)0, esd); -#else - AliError("MayNotUse"); -#endif -} -//____________________________________________________________________ -void -AliFMDReconstructor::FillESD(AliRunLoader*,AliESDEvent*) const -{ - // Cannot be used. See member function with same name but with 2 - // TTree arguments. Make sure you do local reconstrucion - AliFMDDebug(2, ("Calling FillESD with loader and ESD")); - AliError("MayNotUse"); -} -//____________________________________________________________________ -void -AliFMDReconstructor::FillESD(AliRunLoader*,AliRawReader*,AliESDEvent*) const -{ - // Cannot be used. See member function with same name but with 2 - // TTree arguments. Make sure you do local reconstrucion - AliFMDDebug(2, ("Calling FillESD with loader, raw reader, and ESD")); - AliError("MayNotUse"); -} - //____________________________________________________________________ // // EOF diff --git a/FMD/AliFMDReconstructor.h b/FMD/AliFMDReconstructor.h index 6c5ca95509d..f93a204bf55 100644 --- a/FMD/AliFMDReconstructor.h +++ b/FMD/AliFMDReconstructor.h @@ -25,12 +25,13 @@ # include #endif +#include "AliLog.h" + //____________________________________________________________________ class TTree; class TClonesArray; class AliFMDDigit; class AliRawReader; -class AliRunLoader; class AliESDEvent; class AliESDFMD; class TH1; @@ -60,7 +61,7 @@ public: initialized (meaning that the calibration parameters is read from CDB). */ - virtual void Init(AliRunLoader* /*runLoader*/); + virtual void Init(); /** Flag that we can convert raw data into digits. @return always @c true */ virtual Bool_t HasDigitConversion() const { return kTRUE; } @@ -71,9 +72,6 @@ public: @param reader Raw reader. @param digitsTree Tree to store read digits in. */ virtual void ConvertDigits(AliRawReader* reader, TTree* digitsTree) const; - /** Flag that we can do one-event reconstruction. - @return always @c true */ - virtual Bool_t HasLocalReconstruction() const { return kTRUE; } /** Reconstruct one event from the digits passed in @a digitsTree. The member function creates AliFMDRecPoint objects and stores them on the output tree @a clusterTree. An FMD ESD object is @@ -82,14 +80,8 @@ public: @param digitsTree Tree holding the digits of this event @param clusterTree Tree to store AliFMDRecPoint objects in. */ virtual void Reconstruct(TTree* digitsTree, TTree* clusterTree) const; - /** Reconstruct one event from the raw data, via a digits read using - @a reader. The member function @e does @e not create - AliFMDRecPoint objects, and the read AliFMDDigit objects are not - stored. An FMD ESD object is created in parallel. - @todo Make sure we get a vertex. - @param reader Raw data reader - @param clusterTree Tree to store AliFMDRecPoint objects in (not used). */ - void Reconstruct(AliRawReader* reader, TTree* clusterTree) const; + virtual void Reconstruct(AliRawReader *, TTree*) const + {AliError("Method is not used");} /** Put in the ESD data, the FMD ESD data. The object created by the Reconstruct member function is copied to the ESD object. @param digitsTree Tree of digits for this event - not used @@ -97,16 +89,10 @@ public: - not used. @param esd ESD object to store data in. */ + virtual void FillESD(AliRawReader*, TTree*clusterTree, AliESDEvent*esd) const + {FillESD((TTree*)NULL,clusterTree,esd);} virtual void FillESD(TTree* digitsTree, TTree* clusterTree, AliESDEvent* esd) const; - /** Put in the ESD data, the FMD ESD data. The object created by - the Reconstruct member function is copied to the ESD object. - @param reader Raw data reader - not used. - @param clusterTree Tree of reconstructed points for this event - - not used. - @param esd ESD object to store data in. */ - void FillESD(AliRawReader* reader, TTree* clusterTree, - AliESDEvent* esd) const; /** Not used */ virtual void SetESD(AliESDEvent* esd) { fESD = esd; } /** Set the noise factor @@ -207,18 +193,8 @@ protected: TH1* fDiagStep4; // Diagnostics histogram TH1* fDiagAll; // Diagnostics histogram private: - /** Hide base classes unused function */ - void Reconstruct(AliRunLoader*) const; - /** Hide base classes unused function */ - void Reconstruct(AliRunLoader*, AliRawReader*) const; - // /** Hide base classes unused function */ - // void FillESD(AliRawReader*, TTree*, AliESDEvent*) const; - /** Hide base classes unused function */ - void FillESD(AliRunLoader*, AliESDEvent*) const; - /** Hide base classes unused function */ - void FillESD(AliRunLoader*, AliRawReader*, AliESDEvent*) const; - - ClassDef(AliFMDReconstructor, 2) // class for the FMD reconstruction + + ClassDef(AliFMDReconstructor, 3) // class for the FMD reconstruction }; #endif //____________________________________________________________________ diff --git a/HLT/src/AliHLTReconstructor.cxx b/HLT/src/AliHLTReconstructor.cxx index f26c4bb9922..ef331b3c8c3 100644 --- a/HLT/src/AliHLTReconstructor.cxx +++ b/HLT/src/AliHLTReconstructor.cxx @@ -12,9 +12,6 @@ #include #include -#include -#include -#include #include #include @@ -31,7 +28,6 @@ #include "AliHLTTrackArray.h" #include "AliLog.h" -#include "AliRun.h" #include "AliITS.h" #include "AliHLTITStracker.h" #include "AliHLTTPCtracker.h" @@ -126,14 +122,9 @@ AliHLTReconstructor::~AliHLTReconstructor() fpSystem=NULL; } -void AliHLTReconstructor::Init(AliRunLoader* runLoader) +void AliHLTReconstructor::Init() { // init the reconstructor - if(!runLoader) { - AliError("Missing RunLoader! 0x0"); - return; - } - if (!fpSystem) fpSystem=new AliHLTSystem; if (!fpSystem) { AliError("can not create AliHLTSystem object"); @@ -188,258 +179,253 @@ void AliHLTReconstructor::Init(AliRunLoader* runLoader) AliError("error while loading HLT libraries"); return; } - if (!fpSystem->CheckStatus(AliHLTSystem::kReady) && - (fpSystem->Configure(runLoader))<0) { - AliError("error during HLT system configuration"); - return; - } -} - -void AliHLTReconstructor::Reconstruct(AliRunLoader* runLoader) const -{ - // reconstruction of simulated data - Reconstruct(runLoader, NULL); + // No run-loaders anymore...needs a fix +// if (!fpSystem->CheckStatus(AliHLTSystem::kReady) && +// (fpSystem->Configure(runLoader))<0) { +// AliError("error during HLT system configuration"); +// return; +// } } -void AliHLTReconstructor::Reconstruct(AliRunLoader* runLoader, AliRawReader* rawReader) const -{ - // reconstruction of real data if rawReader!=NULL - if(!runLoader) { - AliError("Missing RunLoader! 0x0"); - return; - } - - Int_t nEvents = runLoader->GetNumberOfEvents(); - int iResult=0; - - if (fpSystem) { - if (fpSystem->CheckStatus(AliHLTSystem::kError)) { - AliError("HLT system in error state"); - return; - } - if ((iResult=fpSystem->Reconstruct(nEvents, runLoader, rawReader))>=0) { - } - } -} - -void AliHLTReconstructor::ReconstructWithConformalMapping(AliRunLoader* runLoader,Int_t iEvent) const -{ - // reconstruct with conformal mapper - /* - AliLevel3 *fHLT = new AliLevel3(runLoader); - fHLT->Init("./", AliLevel3::kRunLoader, 1); - - Int_t phiSegments = 50; - Int_t etaSegments = 100; - Int_t trackletlength = 3; - Int_t tracklength = 10; - Int_t rowscopetracklet = 2; - Int_t rowscopetrack = 10; - Double_t minPtFit = 0; - Double_t maxangle = 0.1745; - Double_t goodDist = 5; - Double_t maxphi = 0.1; - Double_t maxeta = 0.1; - Double_t hitChi2Cut = 20; - Double_t goodHitChi2 = 5; - Double_t trackChi2Cut = 10; - Double_t xyerror = -1; - Double_t zerror = -1; +// void AliHLTReconstructor::Reconstruct(AliRunLoader* runLoader, AliRawReader* rawReader) const +// { +// // reconstruction of real data if rawReader!=NULL +// if(!runLoader) { +// AliError("Missing RunLoader! 0x0"); +// return; +// } + +// Int_t nEvents = runLoader->GetNumberOfEvents(); +// int iResult=0; + +// if (fpSystem) { +// if (fpSystem->CheckStatus(AliHLTSystem::kError)) { +// AliError("HLT system in error state"); +// return; +// } +// if ((iResult=fpSystem->Reconstruct(nEvents, runLoader, rawReader))>=0) { +// } +// } +// } + +// void AliHLTReconstructor::ReconstructWithConformalMapping(AliRunLoader* runLoader,Int_t iEvent) const +// { +// // reconstruct with conformal mapper +// /* +// AliLevel3 *fHLT = new AliLevel3(runLoader); +// fHLT->Init("./", AliLevel3::kRunLoader, 1); + +// Int_t phiSegments = 50; +// Int_t etaSegments = 100; +// Int_t trackletlength = 3; +// Int_t tracklength = 10; +// Int_t rowscopetracklet = 2; +// Int_t rowscopetrack = 10; +// Double_t minPtFit = 0; +// Double_t maxangle = 0.1745; +// Double_t goodDist = 5; +// Double_t maxphi = 0.1; +// Double_t maxeta = 0.1; +// Double_t hitChi2Cut = 20; +// Double_t goodHitChi2 = 5; +// Double_t trackChi2Cut = 10; +// Double_t xyerror = -1; +// Double_t zerror = -1; - fHLT->SetClusterFinderParam(xyerror,zerror,kTRUE); - fHLT->SetTrackerParam(phiSegments, etaSegments, - trackletlength, tracklength, - rowscopetracklet, rowscopetrack, - minPtFit, maxangle, goodDist, hitChi2Cut, - goodHitChi2, trackChi2Cut, 50, maxphi, maxeta, kTRUE); - fHLT->SetTrackerParam(phiSegments, etaSegments, - trackletlength, tracklength, - rowscopetracklet, rowscopetrack, - minPtFit, maxangle, goodDist, hitChi2Cut, - goodHitChi2, trackChi2Cut, 50, maxphi, maxeta, kFALSE); - fHLT->SetMergerParameters(2,3,0.003,0.1,0.05); - fHLT->DoMc(); - fHLT->DoNonVertexTracking(); // 2 tracking passes, last without vertex contraint. - fHLT->WriteFiles("./hlt/"); - fHLT->ProcessEvent(0, 35, iEvent); - if(fDoBench){ - char filename[256]; - sprintf(filename, "confmap_%d",iEvent); - fHLT->DoBench(filename); - } - - delete fHLT; - */ -} - -void AliHLTReconstructor::ReconstructWithHoughTransform(AliRunLoader* runLoader,Int_t iEvent) const -{ - //reconstruct with hough - //not used anymore, Hough tracking is moved out of the local - //reconstruction chain - Float_t ptmin = 0.1*AliHLTTransform::GetSolenoidField(); - - Float_t zvertex = 0; - TArrayF mcVertex(3); - AliHeader * header = runLoader->GetHeader(); - if (header) { - AliGenEventHeader * genHeader = header->GenEventHeader(); - if (genHeader) genHeader->PrimaryVertex(mcVertex); - } - zvertex = mcVertex[2]; - - AliInfo(Form("Hough Transform will run with ptmin=%f and zvertex=%f", ptmin, zvertex)); - - AliHLTHough *hough = new AliHLTHough(); +// fHLT->SetClusterFinderParam(xyerror,zerror,kTRUE); +// fHLT->SetTrackerParam(phiSegments, etaSegments, +// trackletlength, tracklength, +// rowscopetracklet, rowscopetrack, +// minPtFit, maxangle, goodDist, hitChi2Cut, +// goodHitChi2, trackChi2Cut, 50, maxphi, maxeta, kTRUE); +// fHLT->SetTrackerParam(phiSegments, etaSegments, +// trackletlength, tracklength, +// rowscopetracklet, rowscopetrack, +// minPtFit, maxangle, goodDist, hitChi2Cut, +// goodHitChi2, trackChi2Cut, 50, maxphi, maxeta, kFALSE); +// fHLT->SetMergerParameters(2,3,0.003,0.1,0.05); +// fHLT->DoMc(); +// fHLT->DoNonVertexTracking(); // 2 tracking passes, last without vertex contraint. +// fHLT->WriteFiles("./hlt/"); +// fHLT->ProcessEvent(0, 35, iEvent); +// if(fDoBench){ +// char filename[256]; +// sprintf(filename, "confmap_%d",iEvent); +// fHLT->DoBench(filename); +// } + +// delete fHLT; +// */ +// } + +// void AliHLTReconstructor::ReconstructWithHoughTransform(AliRunLoader* runLoader,Int_t iEvent) const +// { +// //reconstruct with hough +// //not used anymore, Hough tracking is moved out of the local +// //reconstruction chain +// Float_t ptmin = 0.1*AliHLTTransform::GetSolenoidField(); + +// Float_t zvertex = 0; +// TArrayF mcVertex(3); +// AliHeader * header = runLoader->GetHeader(); +// if (header) { +// AliGenEventHeader * genHeader = header->GenEventHeader(); +// if (genHeader) genHeader->PrimaryVertex(mcVertex); +// } +// zvertex = mcVertex[2]; + +// AliInfo(Form("Hough Transform will run with ptmin=%f and zvertex=%f", ptmin, zvertex)); + +// AliHLTHough *hough = new AliHLTHough(); - hough->SetThreshold(4); - hough->CalcTransformerParams(ptmin); - hough->SetPeakThreshold(70,-1); - hough->SetRunLoader(runLoader); - hough->Init("./", kFALSE, 100, kFALSE,4,0,0,zvertex); - hough->SetAddHistograms(); - - for(Int_t slice=0; slice<=35; slice++) - { - //cout<<"Processing slice "<ReadData(slice,iEvent); - hough->Transform(); - hough->AddAllHistogramsRows(); - hough->FindTrackCandidatesRow(); - //hough->WriteTracks(slice,"./hough"); - hough->AddTracks(); - } - hough->WriteTracks("./hough"); +// hough->SetThreshold(4); +// hough->CalcTransformerParams(ptmin); +// hough->SetPeakThreshold(70,-1); +// hough->SetRunLoader(runLoader); +// hough->Init("./", kFALSE, 100, kFALSE,4,0,0,zvertex); +// hough->SetAddHistograms(); + +// for(Int_t slice=0; slice<=35; slice++) +// { +// //cout<<"Processing slice "<ReadData(slice,iEvent); +// hough->Transform(); +// hough->AddAllHistogramsRows(); +// hough->FindTrackCandidatesRow(); +// //hough->WriteTracks(slice,"./hough"); +// hough->AddTracks(); +// } +// hough->WriteTracks("./hough"); - if(fDoBench){ - char filename[256]; - sprintf(filename, "hough_%d",iEvent); - hough->DoBench(filename); - } - delete hough; -} - -void AliHLTReconstructor::FillESD(AliRunLoader* runLoader, - AliESDEvent* esd) const -{ - //fill the esd file with found tracks - if(!runLoader) { - AliError("Missing RunLoader! 0x0"); - return; - } - Int_t iEvent = runLoader->GetEventNumber(); - if (fpSystem) { - if (fpSystem->CheckStatus(AliHLTSystem::kError)) { - AliError("HLT system in error state"); - return; - } - if (!fpSystem->CheckStatus(AliHLTSystem::kReady)) { - AliError("HLT system in wrong state"); - return; - } - fpSystem->FillESD(iEvent, runLoader, esd); - } - /* - if(fDoTracker) FillESDforConformalMapping(esd,iEvent); - if(fDoHough) FillESDforHoughTransform(esd,iEvent); - */ -} - -void AliHLTReconstructor::FillESDforConformalMapping(AliESDEvent* esd,Int_t iEvent) const -{ - //fill esd with tracks from conformal mapping - /* - Int_t slicerange[2]={0,35}; - Int_t good = (int)(0.4*AliHLTTransform::GetNRows()); - Int_t nclusters = (int)(0.4*AliHLTTransform::GetNRows()); - Int_t nminpointsontracks = (int)(0.3*AliHLTTransform::GetNRows()); - Float_t ptmin = 0.; - Float_t ptmax = 0.; - Float_t maxfalseratio = 0.1; +// if(fDoBench){ +// char filename[256]; +// sprintf(filename, "hough_%d",iEvent); +// hough->DoBench(filename); +// } +// delete hough; +// } + +// void AliHLTReconstructor::FillESD(AliRunLoader* runLoader, +// AliESDEvent* esd) const +// { +// //fill the esd file with found tracks +// if(!runLoader) { +// AliError("Missing RunLoader! 0x0"); +// return; +// } +// Int_t iEvent = runLoader->GetEventNumber(); +// if (fpSystem) { +// if (fpSystem->CheckStatus(AliHLTSystem::kError)) { +// AliError("HLT system in error state"); +// return; +// } +// if (!fpSystem->CheckStatus(AliHLTSystem::kReady)) { +// AliError("HLT system in wrong state"); +// return; +// } +// fpSystem->FillESD(iEvent, runLoader, esd); +// } +// /* +// if(fDoTracker) FillESDforConformalMapping(esd,iEvent); +// if(fDoHough) FillESDforHoughTransform(esd,iEvent); +// */ +// } + +// void AliHLTReconstructor::FillESDforConformalMapping(AliESDEvent* esd,Int_t iEvent) const +// { +// //fill esd with tracks from conformal mapping +// /* +// Int_t slicerange[2]={0,35}; +// Int_t good = (int)(0.4*AliHLTTransform::GetNRows()); +// Int_t nclusters = (int)(0.4*AliHLTTransform::GetNRows()); +// Int_t nminpointsontracks = (int)(0.3*AliHLTTransform::GetNRows()); +// Float_t ptmin = 0.; +// Float_t ptmax = 0.; +// Float_t maxfalseratio = 0.1; - AliHLTEvaluate *fHLTEval = new AliHLTEvaluate("./hlt",nclusters,good,ptmin,ptmax,slicerange); - fHLTEval->SetMaxFalseClusters(maxfalseratio); - fHLTEval->LoadData(iEvent,kTRUE); - fHLTEval->AssignPIDs(); - fHLTEval->AssignIDs(); - AliHLTTrackArray *fTracks = fHLTEval->GetTracks(); - if(!fTracks){ - delete fHLTEval; - return; - } - for(Int_t i=0; iGetNTracks(); i++) - { - AliHLTTrack *tpt = (AliHLTTrack *)fTracks->GetCheckedTrack(i); - if(!tpt) continue; - if(tpt->GetNumberOfPoints() < nminpointsontracks) continue; +// AliHLTEvaluate *fHLTEval = new AliHLTEvaluate("./hlt",nclusters,good,ptmin,ptmax,slicerange); +// fHLTEval->SetMaxFalseClusters(maxfalseratio); +// fHLTEval->LoadData(iEvent,kTRUE); +// fHLTEval->AssignPIDs(); +// fHLTEval->AssignIDs(); +// AliHLTTrackArray *fTracks = fHLTEval->GetTracks(); +// if(!fTracks){ +// delete fHLTEval; +// return; +// } +// for(Int_t i=0; iGetNTracks(); i++) +// { +// AliHLTTrack *tpt = (AliHLTTrack *)fTracks->GetCheckedTrack(i); +// if(!tpt) continue; +// if(tpt->GetNumberOfPoints() < nminpointsontracks) continue; - AliESDHLTtrack *esdtrack = new AliESDHLTtrack() ; - - esdtrack->SetRowRange(tpt->GetFirstRow(),tpt->GetLastRow()); - esdtrack->SetNHits(tpt->GetNHits()); - esdtrack->SetFirstPoint(tpt->GetFirstPointX(),tpt->GetFirstPointY(),tpt->GetFirstPointZ()); - esdtrack->SetLastPoint(tpt->GetLastPointX(),tpt->GetLastPointY(),tpt->GetLastPointZ()); - esdtrack->SetPt(tpt->GetPt()); - esdtrack->SetPsi(tpt->GetPsi()); - esdtrack->SetTgl(tpt->GetTgl()); - esdtrack->SetCharge(tpt->GetCharge()); - esdtrack->SetMCid(tpt->GetMCid()); - esdtrack->SetSector(tpt->GetSector()); - esdtrack->SetPID(tpt->GetPID()); - esdtrack->ComesFromMainVertex(tpt->ComesFromMainVertex()); - - esd->AddHLTConfMapTrack(esdtrack); - delete esdtrack; - } - delete fHLTEval; - */ -} - -void AliHLTReconstructor::FillESDforHoughTransform(AliESDEvent* esd,Int_t iEvent) const -{ - //fill esd with tracks from hough - char filename[256]; - sprintf(filename,"./hough/tracks_%d.raw",iEvent); +// AliESDHLTtrack *esdtrack = new AliESDHLTtrack() ; + +// esdtrack->SetRowRange(tpt->GetFirstRow(),tpt->GetLastRow()); +// esdtrack->SetNHits(tpt->GetNHits()); +// esdtrack->SetFirstPoint(tpt->GetFirstPointX(),tpt->GetFirstPointY(),tpt->GetFirstPointZ()); +// esdtrack->SetLastPoint(tpt->GetLastPointX(),tpt->GetLastPointY(),tpt->GetLastPointZ()); +// esdtrack->SetPt(tpt->GetPt()); +// esdtrack->SetPsi(tpt->GetPsi()); +// esdtrack->SetTgl(tpt->GetTgl()); +// esdtrack->SetCharge(tpt->GetCharge()); +// esdtrack->SetMCid(tpt->GetMCid()); +// esdtrack->SetSector(tpt->GetSector()); +// esdtrack->SetPID(tpt->GetPID()); +// esdtrack->ComesFromMainVertex(tpt->ComesFromMainVertex()); + +// esd->AddHLTConfMapTrack(esdtrack); +// delete esdtrack; +// } +// delete fHLTEval; +// */ +// } + +// void AliHLTReconstructor::FillESDforHoughTransform(AliESDEvent* esd,Int_t iEvent) const +// { +// //fill esd with tracks from hough +// char filename[256]; +// sprintf(filename,"./hough/tracks_%d.raw",iEvent); - AliHLTFileHandler *tfile = new AliHLTFileHandler(); - if(!tfile->SetBinaryInput(filename)){ - AliError(Form("Missing file %s", filename)); - return; - } +// AliHLTFileHandler *tfile = new AliHLTFileHandler(); +// if(!tfile->SetBinaryInput(filename)){ +// AliError(Form("Missing file %s", filename)); +// return; +// } - AliHLTTrackArray *fTracks = new AliHLTTrackArray("AliHLTHoughTrack"); - tfile->Binary2TrackArray(fTracks); - tfile->CloseBinaryInput(); - delete tfile; - if(!fTracks) return; - for(Int_t i=0; iGetNTracks(); i++) - { - AliHLTHoughTrack *tpt = (AliHLTHoughTrack *)fTracks->GetCheckedTrack(i); - if(!tpt) continue; +// AliHLTTrackArray *fTracks = new AliHLTTrackArray("AliHLTHoughTrack"); +// tfile->Binary2TrackArray(fTracks); +// tfile->CloseBinaryInput(); +// delete tfile; +// if(!fTracks) return; +// for(Int_t i=0; iGetNTracks(); i++) +// { +// AliHLTHoughTrack *tpt = (AliHLTHoughTrack *)fTracks->GetCheckedTrack(i); +// if(!tpt) continue; - AliESDHLTtrack *esdtrack = new AliESDHLTtrack() ; - - esdtrack->SetRowRange(tpt->GetFirstRow(),tpt->GetLastRow()); - esdtrack->SetNHits(tpt->GetNHits()); - esdtrack->SetFirstPoint(tpt->GetFirstPointX(),tpt->GetFirstPointY(),tpt->GetFirstPointZ()); - esdtrack->SetLastPoint(tpt->GetLastPointX(),tpt->GetLastPointY(),tpt->GetLastPointZ()); - esdtrack->SetPt(tpt->GetPt()); - esdtrack->SetPsi(tpt->GetPsi()); - esdtrack->SetTgl(tpt->GetTgl()); - esdtrack->SetCharge(tpt->GetCharge()); - esdtrack->SetMCid(tpt->GetMCid()); - esdtrack->SetWeight(tpt->GetWeight()); - esdtrack->SetSector(tpt->GetSector()); - esdtrack->SetBinXY(tpt->GetBinX(),tpt->GetBinY(),tpt->GetSizeX(),tpt->GetSizeY()); - esdtrack->SetPID(tpt->GetPID()); - esdtrack->ComesFromMainVertex(tpt->ComesFromMainVertex()); - - esd->AddHLTHoughTrack(esdtrack); - delete esdtrack; - } - - delete fTracks; -} +// AliESDHLTtrack *esdtrack = new AliESDHLTtrack() ; + +// esdtrack->SetRowRange(tpt->GetFirstRow(),tpt->GetLastRow()); +// esdtrack->SetNHits(tpt->GetNHits()); +// esdtrack->SetFirstPoint(tpt->GetFirstPointX(),tpt->GetFirstPointY(),tpt->GetFirstPointZ()); +// esdtrack->SetLastPoint(tpt->GetLastPointX(),tpt->GetLastPointY(),tpt->GetLastPointZ()); +// esdtrack->SetPt(tpt->GetPt()); +// esdtrack->SetPsi(tpt->GetPsi()); +// esdtrack->SetTgl(tpt->GetTgl()); +// esdtrack->SetCharge(tpt->GetCharge()); +// esdtrack->SetMCid(tpt->GetMCid()); +// esdtrack->SetWeight(tpt->GetWeight()); +// esdtrack->SetSector(tpt->GetSector()); +// esdtrack->SetBinXY(tpt->GetBinX(),tpt->GetBinY(),tpt->GetSizeX(),tpt->GetSizeY()); +// esdtrack->SetPID(tpt->GetPID()); +// esdtrack->ComesFromMainVertex(tpt->ComesFromMainVertex()); + +// esd->AddHLTHoughTrack(esdtrack); +// delete esdtrack; +// } + +// delete fTracks; +// } /* The following functions are deprecated and need to be removed. AliTracker* AliHLTReconstructor::CreateTracker(AliRunLoader* runLoader) const diff --git a/HLT/src/AliHLTReconstructor.h b/HLT/src/AliHLTReconstructor.h index e60a8b1ff38..de1547740be 100644 --- a/HLT/src/AliHLTReconstructor.h +++ b/HLT/src/AliHLTReconstructor.h @@ -50,19 +50,11 @@ public: virtual ~AliHLTReconstructor(); /** init the reconstructor */ - void Init(AliRunLoader* runLoader); - - /** reconstruct simulated MC data */ - void Reconstruct(AliRunLoader* runLoader) const; - /** reconstruct data from RawReader */ - void Reconstruct(AliRunLoader* runLoader, AliRawReader* rawReader) const; + void Init(); /** create a tracker */ -// Deprecated and must be removed. -// AliTracker* CreateTracker(AliRunLoader*) const; - - /** fill esd for one event */ - void FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const; + // Deprecated and must be removed. + // AliTracker* CreateTracker() const; virtual void Reconstruct(TTree* digitsTree, TTree* clustersTree) const{ AliReconstructor::Reconstruct(digitsTree,clustersTree); @@ -79,10 +71,6 @@ public: AliESDEvent* esd) const { AliReconstructor::FillESD(rawReader,clustersTree,esd); } - virtual void FillESD(AliRunLoader* runLoader, - AliRawReader* rawReader, AliESDEvent* esd) const { - AliReconstructor:: FillESD(runLoader,rawReader,esd); - } void SetDoBench(Bool_t b){fDoBench=b;} void SetDoCleanup(Bool_t b){fDoCleanUp=b;} @@ -90,10 +78,10 @@ public: // virtual void FillDHLTRecPoint(AliRawReader* rawReader, Int_t nofEvent, Int_t dcCut) const; private: - void ReconstructWithConformalMapping(AliRunLoader* runLoader,Int_t iEvent) const; - void ReconstructWithHoughTransform(AliRunLoader* runLoader,Int_t iEvent) const; - void FillESDforConformalMapping(AliESDEvent* esd,Int_t iEvent) const; - void FillESDforHoughTransform(AliESDEvent* esd,Int_t iEvent) const; +/* void ReconstructWithConformalMapping(AliRunLoader* runLoader,Int_t iEvent) const; */ +/* void ReconstructWithHoughTransform(AliRunLoader* runLoader,Int_t iEvent) const; */ +/* void FillESDforConformalMapping(AliESDEvent* esd,Int_t iEvent) const; */ +/* void FillESDforHoughTransform(AliESDEvent* esd,Int_t iEvent) const; */ Bool_t fDoHough; //do the hough transform Bool_t fDoTracker; //do the standard conformal tracker @@ -101,10 +89,8 @@ private: Bool_t fDoCleanUp; //delete tmp tracking files AliHLTSystem* fpSystem; //! HLT steering object - Int_t fRecEvents; //! number of reconstructed events - Int_t fFilled; //! number of event filled to ESD - ClassDef(AliHLTReconstructor, 1) // class for the TPC reconstruction + ClassDef(AliHLTReconstructor, 2) // class for the HLT reconstruction }; typedef AliHLTReconstructor AliL3Reconstructor; // for backward compatibility diff --git a/HMPID/AliHMPIDQualAssDataMaker.cxx b/HMPID/AliHMPIDQualAssDataMaker.cxx index 69f509dbba8..fc9ba6a310a 100644 --- a/HMPID/AliHMPIDQualAssDataMaker.cxx +++ b/HMPID/AliHMPIDQualAssDataMaker.cxx @@ -158,80 +158,97 @@ void AliHMPIDQualAssDataMaker::InitESDs() } //____________________________________________________________________________ -void AliHMPIDQualAssDataMaker::MakeHits() +void AliHMPIDQualAssDataMaker::MakeHits(TObject * data) { //fills QA histos for Hits - TClonesArray * hits = dynamic_cast(fData) ; - TIter next(hits); - AliHMPIDHit * hit ; - while ( hit = dynamic_cast(next()) ) { - if(hit->Pid()<500000) fhHitQdc->Fill(hit->Q()) ; - if(hit->Pid()<500000) fhHitMap[hit->Ch()]->Fill(hit->LorsX(),hit->LorsY()); - } -} - + TClonesArray * hits = dynamic_cast(data) ; + if (!hits){ + AliError("Wrong type of hits container") ; + } else { + TIter next(hits); + AliHMPIDHit * hit ; + while ( (hit = dynamic_cast(next())) ) { + if(hit->Pid()<500000) fhHitQdc->Fill(hit->Q()) ; + if(hit->Pid()<500000) fhHitMap[hit->Ch()]->Fill(hit->LorsX(),hit->LorsY()); + } + } +} + //____________________________________________________________________________ -void AliHMPIDQualAssDataMaker::MakeDigits() +void AliHMPIDQualAssDataMaker::MakeDigits( TObject * data) { //fills QA histos for Digits - TObjArray *chambers = dynamic_cast(fData); - for(Int_t i =0; i< chambers->GetEntries(); i++) - { - TClonesArray * digits = dynamic_cast(chambers->At(i)); - fhDigChEvt->Fill(i,digits->GetEntriesFast()/(48.*80.*6.)); - TIter next(digits); - AliHMPIDDigit * digit; - while ( (digit = dynamic_cast(next())) ) { - fhDigPcEvt->Fill(10.*i+digit->Pc(),1./(48.*80.)); - fhDigQ->Fill(digit->Q()); - } - } + TObjArray *chambers = dynamic_cast(data); + if ( !chambers) { + AliError("Wrong type of digits container") ; + } else { + for(Int_t i =0; i< chambers->GetEntries(); i++) + { + TClonesArray * digits = dynamic_cast(chambers->At(i)); + fhDigChEvt->Fill(i,digits->GetEntriesFast()/(48.*80.*6.)); + TIter next(digits); + AliHMPIDDigit * digit; + while ( (digit = dynamic_cast(next())) ) { + fhDigPcEvt->Fill(10.*i+digit->Pc(),1./(48.*80.)); + fhDigQ->Fill(digit->Q()); + } + } + } } //____________________________________________________________________________ -void AliHMPIDQualAssDataMaker::MakeSDigits() +void AliHMPIDQualAssDataMaker::MakeSDigits( TObject * data) { //fills QA histos for SDigits - TClonesArray * sdigits = dynamic_cast(fData) ; - AliHMPIDDigit *ref = (AliHMPIDDigit *)sdigits->At(0); - Float_t zero = ref->GetTrack(0); - TIter next(sdigits) ; - AliHMPIDDigit * sdigit ; - while ( (sdigit = dynamic_cast(next())) ) { - fhSDigits->Fill(sdigit->Q()) ; - if(zero == sdigit->GetTrack(0)) continue; - else zero == sdigit->GetTrack(0); - } + TClonesArray * sdigits = dynamic_cast(data) ; + if (!sdigits) { + AliError("Wrong type of sdigits container") ; + } else { + AliHMPIDDigit *ref = (AliHMPIDDigit *)sdigits->At(0); + Float_t zero = ref->GetTrack(0); + TIter next(sdigits) ; + AliHMPIDDigit * sdigit ; + while ( (sdigit = dynamic_cast(next())) ) { + fhSDigits->Fill(sdigit->Q()) ; + if(zero == sdigit->GetTrack(0)) continue; + else zero = sdigit->GetTrack(0); + } + } } -void AliHMPIDQualAssDataMaker::MakeRecPoints() +//____________________________________________________________________________ +void AliHMPIDQualAssDataMaker::MakeRecPoints(TTree * clustersTree) { //fills QA histos for clusters - TObjArray *chambers = dynamic_cast(fData); - for(Int_t i =0; i< chambers->GetEntries(); i++) - { - TClonesArray * clusters = dynamic_cast(chambers->At(i)); + TClonesArray *clusters = new TClonesArray("AliHMPIDCluster"); + for(int i=AliHMPIDParam::kMinCh;i<=AliHMPIDParam::kMaxCh;i++){ + TBranch *branch = clustersTree->GetBranch(Form("HMPID%d",i)); + branch->SetAddress(&clusters); + branch->GetEntry(0); + fhCluEvt->Fill(i,clusters->GetEntries()); TIter next(clusters); AliHMPIDCluster *clu; while ( (clu = dynamic_cast(next())) ) {; - fhCluFlg->Fill(clu->Status()); fhCluChi2->Fill(clu->Chi2()); fhCluSize->Fill(clu->Size()); - fhCluQ->Fill(clu->Q()); - Int_t qCut=100; - if(clu->Q()>qCut) { - fhMipCluSize->SetTitle(Form("Mip cluster size at a Qcut = %i ADC",qCut)); - fhMipCluSize->Fill(clu->Size()); + fhCluFlg->Fill(clu->Status()); fhCluChi2->Fill(clu->Chi2()); fhCluSize->Fill(clu->Size()); + fhCluQ->Fill(clu->Q()); + Int_t qCut=100; + if(clu->Q()>qCut) { + fhMipCluSize->SetTitle(Form("Mip cluster size at a Qcut = %i ADC",qCut)); + fhMipCluSize->Fill(clu->Size()); + } } } - } + + clusters->Delete(); + delete clusters; } //____________________________________________________________________________ -void AliHMPIDQualAssDataMaker::MakeESDs() +void AliHMPIDQualAssDataMaker::MakeESDs(AliESDEvent * esd) { //fills QA histos for ESD - AliESDEvent * esd = dynamic_cast(fData) ; for(Int_t iTrk = 0 ; iTrk < esd->GetNumberOfTracks() ; iTrk++){ AliESDtrack *pTrk = esd->GetTrack(iTrk) ; fhCkovP->Fill(pTrk->GetP(),pTrk->GetHMPIDsignal()); diff --git a/HMPID/AliHMPIDQualAssDataMaker.h b/HMPID/AliHMPIDQualAssDataMaker.h index 1f86a0453c1..10e256a8527 100644 --- a/HMPID/AliHMPIDQualAssDataMaker.h +++ b/HMPID/AliHMPIDQualAssDataMaker.h @@ -42,11 +42,11 @@ private: virtual void InitSDigits() ; //book SDigits QA histo virtual void InitRecPoints(); //book cluster QA histo virtual void InitESDs() ; //book ESD QA histo - virtual void MakeHits() ; //Fill hit QA histo - virtual void MakeDigits() ; //Fill Digit QA histo - virtual void MakeSDigits() ; //Fill SDigit QA histo - virtual void MakeRecPoints() ; //Fill cluster QA histo - virtual void MakeESDs() ; //Fill hit QA histo + virtual void MakeHits(TObject * hits) ; //Fill hit QA histo + virtual void MakeDigits(TObject * digits) ; //Fill Digit QA histo + virtual void MakeSDigits(TObject * sdigits) ; //Fill SDigit QA histo + virtual void MakeRecPoints(TTree * clusters) ; //Fill cluster QA histo + virtual void MakeESDs(AliESDEvent * esd) ; //Fill hit QA histo TH1F *fhHitQdc; // Hit Q distr TH2F *fhHitMap[7]; // Hit Q positions diff --git a/HMPID/AliHMPIDReconstructor.cxx b/HMPID/AliHMPIDReconstructor.cxx index 80e9d5542b9..4a4f076b1bb 100644 --- a/HMPID/AliHMPIDReconstructor.cxx +++ b/HMPID/AliHMPIDReconstructor.cxx @@ -25,6 +25,7 @@ #include //ctor #include //FillEsd() #include //Reconstruct() for raw digits +#include "AliHMPIDRawStream.h" //ConvertDigits() ClassImp(AliHMPIDReconstructor) //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -139,47 +140,6 @@ void AliHMPIDReconstructor::Reconstruct(TTree *pDigTree,TTree *pCluTree)const AliDebug(1,"Stop."); }//Reconstruct(for simulated digits) //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -void AliHMPIDReconstructor::Reconstruct(AliRunLoader *pAL,AliRawReader* pRR)const -{ -//Invoked by AliReconstruction to convert raw digits from DDL files to clusters -//Arguments: pAL - ALICE run loader pointer -// pRR - ALICE raw reader pointer -// Returns: none - AliLoader *pRL=pAL->GetDetectorLoader("HMPID"); AliHMPID *pRich=(AliHMPID*)pAL->GetAliRun()->GetDetector("HMPID");//get pointers for HMPID and HMPID loader - - AliHMPIDDigit dig; //tmp digit, raw digit will be converted to it - - TObjArray digLst; Int_t iDigCnt[7]; for(Int_t i=0;i<7;i++){digLst.AddAt(new TClonesArray("AliHMPIDDigit"),i); iDigCnt[i]=0;} //tmp list of digits for allchambers - - Int_t iEvtN=0; - while(pRR->NextEvent()){//events loop - pAL->GetEvent(iEvtN++); - pRL->MakeTree("R"); pRich->MakeBranch("R"); - - for(Int_t iCh=AliHMPIDParam::kMinCh;iCh<=AliHMPIDParam::kMaxCh;iCh++) { - AliHMPIDRawStream stream(pRR); - while(stream.Next()) - { - UInt_t ddl=stream.GetDDLNumber(); //returns 0,1,2 ... 13 - if((UInt_t)(2*iCh)==ddl || (UInt_t)(2*iCh+1)==ddl) { - for(Int_t row = 1; row <=AliHMPIDRawStream::kNRows; row++){ - for(Int_t dil = 1; dil <=AliHMPIDRawStream::kNDILOGICAdd; dil++){ - for(Int_t pad = 0; pad < AliHMPIDRawStream::kNPadAdd; pad++){ - if(stream.GetCharge(ddl,row,dil,pad) < 1) continue; - AliHMPIDDigit dig(stream.GetPad(ddl,row,dil,pad),stream.GetCharge(ddl,row,dil,pad)); - if(!IsDigSurvive(&dig)) continue; - new((*((TClonesArray*)digLst.At(iCh)))[iDigCnt[iCh]++]) AliHMPIDDigit(dig); //add this digit to the tmp list - }//pad - }//dil - }//row - }//while stream - }//ch loop - } - } - - pRL->UnloadRecPoints(); -}//Reconstruct raw data -//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ void AliHMPIDReconstructor::ConvertDigits(AliRawReader *pRR,TTree *pDigTree)const { //Invoked by AliReconstruction to convert raw digits from DDL files to digits @@ -221,7 +181,7 @@ void AliHMPIDReconstructor::ConvertDigits(AliRawReader *pRR,TTree *pDigTree)cons AliDebug(1,"Stop."); }//Reconstruct digits from raw digits //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -void AliHMPIDReconstructor::FillESD(AliRunLoader *, AliESDEvent *pESD) const +void AliHMPIDReconstructor::FillESD(TTree */*digitsTree*/, TTree */*clustersTree*/, AliESDEvent *pESD) const { // Calculates probability to be a electron-muon-pion-kaon-proton // from the given Cerenkov angle and momentum assuming no initial particle composition @@ -259,4 +219,3 @@ void AliHMPIDReconstructor::FillESD(AliRunLoader *, AliESDEvent *pESD) const pTrk->SetHMPIDpid(pid); }//ESD tracks loop }//FillESD() -//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ diff --git a/HMPID/AliHMPIDReconstructor.h b/HMPID/AliHMPIDReconstructor.h index 085a3bb0a8a..b29b0d19348 100644 --- a/HMPID/AliHMPIDReconstructor.h +++ b/HMPID/AliHMPIDReconstructor.h @@ -8,7 +8,6 @@ #include //base class #include "AliHMPIDTracker.h" //CreateTracker() #include "AliHMPIDDigit.h" //Dig2Clu(), UseDig() -#include "AliHMPIDRawStream.h" //ConvertDigits() #include //UseDig() #include //UseDig() @@ -22,13 +21,11 @@ public: AliHMPIDReconstructor(); virtual ~AliHMPIDReconstructor() {delete fDig;delete fClu;delete [] fUserCut;}//dtor //framework part - AliTracker* CreateTracker (AliRunLoader* )const{return new AliHMPIDTracker;} //from AliReconstructor for clusters->PID + AliTracker* CreateTracker () const {return new AliHMPIDTracker;} //from AliReconstructor for clusters->PID void ConvertDigits (AliRawReader *pRR, TTree *pDigTree) const; //from AliReconstruction for raw->digit Bool_t HasDigitConversion() const {return kTRUE;} //HMPID digits converted with ConvertDigits void Reconstruct (TTree* digitsTree, TTree* clustersTree) const; //from AliReconstruction for digit->cluster - void Reconstruct (AliRunLoader *pAL,AliRawReader* pRR)const; //from AliReconstruction for raw->cluster with Digits on fly - Bool_t HasLocalReconstruction() const {return kTRUE;} // HMPID has local reconstruction algorithm - void FillESD (AliRunLoader* pAL,AliESDEvent *pESD)const; //calculate pid for HMPID + void FillESD (TTree* /*digitsTree*/, TTree* /*clustersTree*/, AliESDEvent *pESD)const; //calculate pid for HMPID using AliReconstructor::FillESD; // using AliReconstructor::Reconstruct; // diff --git a/ITS/AliITSReconstructor.cxx b/ITS/AliITSReconstructor.cxx index ede20b82ba7..13dcdb9ac5c 100644 --- a/ITS/AliITSReconstructor.cxx +++ b/ITS/AliITSReconstructor.cxx @@ -24,7 +24,6 @@ #include "Riostream.h" #include "AliITSReconstructor.h" #include "AliRun.h" -#include "AliRunLoader.h" #include "AliRawReader.h" #include "AliITSDetTypeRec.h" #include "AliITSgeom.h" @@ -84,13 +83,11 @@ AliITSReconstructor& AliITSReconstructor::operator=(const AliITSReconstructor& } //______________________________________________________________________ -void AliITSReconstructor::Init(AliRunLoader */*runLoader*/) { +void AliITSReconstructor::Init() { // Initalize this constructor bet getting/creating the objects // nesseary for a proper ITS reconstruction. // Inputs: - // AliRunLoader *runLoader Pointer to the run loader to allow - // the getting of files/folders data - // needed to do reconstruction + // none. // Output: // none. // Return: @@ -132,7 +129,7 @@ void AliITSReconstructor::Reconstruct(AliRawReader* rawReader, TTree *clustersTr } //_____________________________________________________________________________ -AliTracker* AliITSReconstructor::CreateTracker(AliRunLoader* runLoader)const +AliTracker* AliITSReconstructor::CreateTracker() const { // create a ITS tracker @@ -155,23 +152,23 @@ AliTracker* AliITSReconstructor::CreateTracker(AliRunLoader* runLoader)const } TString selectedPIDmethod = GetOption(); - AliITSLoader *loader = (AliITSLoader*)runLoader->GetLoader("ITSLoader"); - if (!loader) { - Error("CreateTracker", "ITS loader not found"); - } + AliITSReconstructor* nc = const_cast(this); if(selectedPIDmethod.Contains("LandauFitPID")){ - loader->AdoptITSpid(new AliITSpidESD2((AliITStrackerMI*)tracker,loader)); + Info("FillESD","ITS LandauFitPID option has been selected\n"); + nc->fItsPID = new AliITSpidESD2((AliITStrackerMI*)tracker); } else{ + Info("FillESD","ITS default PID\n"); Double_t parITS[] = {0.15, 10.}; //PH positions of the MIP peak - loader->AdoptITSpid(new AliITSpidESD1(parITS)); + nc->fItsPID = new AliITSpidESD1(parITS); } + return tracker; } //_____________________________________________________________________________ -AliVertexer* AliITSReconstructor::CreateVertexer(AliRunLoader* /*runLoader*/) const +AliVertexer* AliITSReconstructor::CreateVertexer() const { // create a ITS vertexer @@ -199,23 +196,18 @@ AliVertexer* AliITSReconstructor::CreateVertexer(AliRunLoader* /*runLoader*/) co } //_____________________________________________________________________________ -void AliITSReconstructor::FillESD(AliRunLoader* runLoader, +void AliITSReconstructor::FillESD(TTree * /*digitsTree*/, TTree *clustersTree, AliESDEvent* esd) const { // make PID, find V0s and cascade - AliITSLoader *loader = (AliITSLoader*)runLoader->GetLoader("ITSLoader"); - AliITSpidESD *pidESD = 0; - TString selectedPIDmethod = GetOption(); - if(selectedPIDmethod.Contains("LandauFitPID")){ - Info("FillESD","ITS LandauFitPID option has been selected\n"); - pidESD=loader->GetITSpid(); - } - else{ - Info("FillESD","ITS default PID\n"); - pidESD=loader->GetITSpid(); - } - if(pidESD!=0){ - pidESD->MakePID(esd); + if(fItsPID!=0) { + TString selectedPIDmethod = GetOption(); + if(selectedPIDmethod.Contains("LandauFitPID")){ + fItsPID->MakePID(clustersTree,esd); + } + else{ + fItsPID->MakePID(esd); + } } else { Error("FillESD","!! cannot do the PID !!\n"); diff --git a/ITS/AliITSReconstructor.h b/ITS/AliITSReconstructor.h index 99ab8ed3c02..8a0bc1f6126 100644 --- a/ITS/AliITSReconstructor.h +++ b/ITS/AliITSReconstructor.h @@ -25,31 +25,19 @@ public: virtual ~AliITSReconstructor(); AliITSReconstructor(const AliITSReconstructor &ob); // copy constructor AliITSReconstructor& operator=(const AliITSReconstructor & ob); // ass. op. - virtual void Init(AliRunLoader* runLoader); + virtual void Init(); - virtual Bool_t HasLocalReconstruction() const {return kTRUE;}; - - virtual void Reconstruct(AliRunLoader* runLoader) const - {AliReconstructor::Reconstruct(runLoader);} - virtual void Reconstruct(AliRunLoader* runLoader, - AliRawReader* rawReader) const - {AliReconstructor::Reconstruct(runLoader,rawReader);} virtual void Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const; virtual void Reconstruct(TTree* digitsTree, TTree* clustersTree) const; - virtual AliTracker* CreateTracker(AliRunLoader* runLoader) const; - virtual AliVertexer* CreateVertexer(AliRunLoader* runLoader) const; - virtual void FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const; + virtual AliTracker* CreateTracker() const; + virtual AliVertexer* CreateVertexer() const; - virtual void FillESD(TTree* digitsTree, TTree* clustersTree, - AliESDEvent* esd) const - {AliReconstructor::FillESD(digitsTree, clustersTree, esd);} - virtual void FillESD(AliRawReader* rawReader, TTree* clustersTree, + virtual void FillESD(TTree* /*digitsTree*/, TTree* clustersTree, + AliESDEvent* esd) const; + virtual void FillESD(AliRawReader* /*rawReader*/, TTree* clustersTree, AliESDEvent* esd) const - {AliReconstructor::FillESD(rawReader, clustersTree, esd);} - virtual void FillESD(AliRunLoader* runLoader, - AliRawReader* rawReader, AliESDEvent* esd) const - {AliReconstructor::FillESD(runLoader,rawReader, esd);} + {FillESD((TTree*)NULL, clustersTree, esd);} void SetRecoParam(AliITSRecoParam * param){ fgkRecoParam = param;} static const AliITSRecoParam* GetRecoParam(){ return fgkRecoParam;} @@ -59,7 +47,8 @@ private: static AliITSRecoParam *fgkRecoParam; // reconstruction parameters AliITSpidESD *fItsPID; // Pid for ITS AliITSDetTypeRec *fDetTypeRec; // reconstructor - ClassDef(AliITSReconstructor, 2) // class for the ITS reconstruction + + ClassDef(AliITSReconstructor, 3) // class for the ITS reconstruction }; #endif diff --git a/ITS/AliITSpidESD.h b/ITS/AliITSpidESD.h index 1816a7b04b2..4f83faf9c2e 100644 --- a/ITS/AliITSpidESD.h +++ b/ITS/AliITSpidESD.h @@ -13,13 +13,16 @@ //#include #include +class TTree; class AliESDEvent; class AliITSpidESD : public TObject { public: AliITSpidESD(); virtual ~AliITSpidESD() {} - virtual Int_t MakePID(AliESDEvent *event) =0; + virtual Int_t MakePID(AliESDEvent *event) = 0; + // This method is here because of the AliITSpidESD2 class... + virtual Int_t MakePID(TTree *clustersTree, AliESDEvent *event) = 0; static Double_t Bethe(Double_t p,Double_t mass); private: ClassDef(AliITSpidESD,1) // ITS PID class diff --git a/ITS/AliITSpidESD1.h b/ITS/AliITSpidESD1.h index 8232a865bcf..f18eb04533e 100755 --- a/ITS/AliITSpidESD1.h +++ b/ITS/AliITSpidESD1.h @@ -12,7 +12,7 @@ // Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch //------------------------------------------------------- #include "AliITSpidESD.h" - +#include "AliLog.h" class AliITSpidESD1 : public AliITSpidESD { public: @@ -20,6 +20,9 @@ public: AliITSpidESD1(Double_t *param); virtual ~AliITSpidESD1() {} virtual Int_t MakePID(AliESDEvent *event); + // This method is here because of the AliITSpidESD2 class... + virtual Int_t MakePID(TTree */*clustersTree*/, AliESDEvent */*event*/) + {AliError("Method should not be used!"); return 0;} private: Double_t fRes; // relative dEdx resolution diff --git a/ITS/AliITSpidESD2.cxx b/ITS/AliITSpidESD2.cxx index 0935236b8ce..6c247041020 100644 --- a/ITS/AliITSpidESD2.cxx +++ b/ITS/AliITSpidESD2.cxx @@ -40,20 +40,16 @@ ClassImp(AliITSpidESD2) //_________________________________________________________________________ AliITSpidESD2::AliITSpidESD2():AliITSpidESD(), fTracker(0), -fLoader(0), fSp(0) { // // The main constructor } //_________________________________________________________________________ -AliITSpidESD2::AliITSpidESD2(AliITStrackerMI* tracker,AliITSLoader* loader):AliITSpidESD(), -fTracker(0), -fLoader(0), +AliITSpidESD2::AliITSpidESD2(AliITStrackerMI* tracker):AliITSpidESD(), +fTracker(tracker), fSp(0) { // // The main constructor - fTracker=tracker; - fLoader=loader; fSp=new AliITSSteerPid(); fSp->InitLayer(); } @@ -67,7 +63,6 @@ AliITSpidESD2::~AliITSpidESD2(){ //______________________________________________________________________ AliITSpidESD2::AliITSpidESD2(const AliITSpidESD2 &ob) :AliITSpidESD(ob), fTracker(ob.fTracker), -fLoader(ob.fLoader), fSp(ob.fSp) { // Copy constructor @@ -83,7 +78,7 @@ AliITSpidESD2& AliITSpidESD2::operator=(const AliITSpidESD2& ob ){ } //_________________________________________________________________________ -Int_t AliITSpidESD2::MakePID(AliESDEvent *event) +Int_t AliITSpidESD2::MakePID(TTree *clustersTree, AliESDEvent *event) { // @@ -91,9 +86,7 @@ Int_t AliITSpidESD2::MakePID(AliESDEvent *event) // Double_t xr,par[5]; AliITStrackV2* track=0; - fLoader->LoadRecPoints(); - TTree *cTree=fLoader->TreeR(); - fTracker->LoadClusters(cTree); + fTracker->LoadClusters(clustersTree); printf("==== Landau Fit PID ITS ====== \n"); Int_t ntrk=event->GetNumberOfTracks(); Double_t momits; @@ -165,6 +158,5 @@ Int_t AliITSpidESD2::MakePID(AliESDEvent *event) delete track; } fTracker->UnloadClusters(); - fLoader->UnloadRecPoints(); return 0; } diff --git a/ITS/AliITSpidESD2.h b/ITS/AliITSpidESD2.h index a4a6a8866cc..ff07be00173 100755 --- a/ITS/AliITSpidESD2.h +++ b/ITS/AliITSpidESD2.h @@ -15,26 +15,27 @@ // Origin: Elena Bruna bruna@to.infn.it, Massimo Masera masera@to.infn.it// //-----------------------------------------------------------------------// #include "AliITSpidESD.h" +#include "AliLog.h" class AliITStrackerMI; -class AliITSLoader; class AliITSSteerPid; class AliITSpidESD2 : public AliITSpidESD { public: AliITSpidESD2(); - AliITSpidESD2(AliITStrackerMI *tracker,AliITSLoader* loader); + AliITSpidESD2(AliITStrackerMI *tracker); virtual ~AliITSpidESD2(); - virtual Int_t MakePID(AliESDEvent *event); + virtual Int_t MakePID(AliESDEvent */*event*/) + {AliError("Method should not be used!"); return 0;} + virtual Int_t MakePID(TTree *clustersTree, AliESDEvent *event); AliITSpidESD2(const AliITSpidESD2 &ob); // copy constructor AliITSpidESD2& operator=(const AliITSpidESD2 & source); // ass. op. private: AliITStrackerMI *fTracker; //!tracker MI - AliITSLoader* fLoader; //!ITS Loader AliITSSteerPid* fSp; //!pointer to AliITSSteerPid - ClassDef(AliITSpidESD2,1) // ITS PID class + ClassDef(AliITSpidESD2,2) // ITS PID class }; #endif diff --git a/MUON/AliMUONReconstructor.cxx b/MUON/AliMUONReconstructor.cxx index 092325c6469..68026800a02 100644 --- a/MUON/AliMUONReconstructor.cxx +++ b/MUON/AliMUONReconstructor.cxx @@ -66,9 +66,7 @@ #include "AliMUONReconstructor.h" #include "AliCDBManager.h" -#include "AliLoader.h" #include "AliLog.h" -#include "AliRunLoader.h" #include "AliMUONCalibrationData.h" #include "AliMUONClusterFinderCOG.h" #include "AliMUONClusterFinderMLEM.h" @@ -298,7 +296,7 @@ AliMUONReconstructor::CreateTriggerChamberEff() const //_____________________________________________________________________________ AliTracker* -AliMUONReconstructor::CreateTracker(AliRunLoader* runLoader) const +AliMUONReconstructor::CreateTracker() const { /// Create the MUONTracker object /// The MUONTracker is passed the GetOption(), i.e. our own options @@ -307,13 +305,7 @@ AliMUONReconstructor::CreateTracker(AliRunLoader* runLoader) const CreateDigitMaker(); CreateTriggerChamberEff(); - AliLoader* loader = runLoader->GetDetectorLoader("MUON"); - if (!loader) - { - AliError("Cannot get MUONLoader, so cannot create MUONTracker"); - return 0x0; - } - AliMUONTracker* tracker = new AliMUONTracker(loader,fDigitMaker,fTransformer,fTriggerCircuit,fTrigChamberEff); + AliMUONTracker* tracker = new AliMUONTracker(fDigitMaker,fTransformer,fTriggerCircuit,fTrigChamberEff); tracker->SetOption(GetOption()); return tracker; @@ -523,23 +515,6 @@ AliMUONReconstructor::HasDigitConversion() const } } -//_____________________________________________________________________________ -Bool_t -AliMUONReconstructor::HasLocalReconstruction() const -{ - /// Whether or not we have local reconstruction - TString opt(GetOption()); - opt.ToUpper(); - if ( opt.Contains("NOLOCALRECONSTRUCTION" ) ) - { - return kFALSE; - } - else - { - return kTRUE; - } -} - //_____________________________________________________________________________ void AliMUONReconstructor::Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const @@ -559,84 +534,6 @@ AliMUONReconstructor::Reconstruct(AliRawReader* rawReader, TTree* clustersTree) FillTreeR(TriggerStore(),ClusterStore(),*clustersTree); } -//_____________________________________________________________________________ -void -AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader) const -{ - /// Reconstruct simulated data - - AliCodeTimerAuto("Reconstruct(AliRunLoader*)") - - AliLoader* loader = runLoader->GetDetectorLoader("MUON"); - if (!loader) - { - AliError("Could not get MUON loader"); - return; - } - - Int_t nEvents = runLoader->GetNumberOfEvents(); - - for ( Int_t i = 0; i < nEvents; ++i ) - { - runLoader->GetEvent(i); - - loader->LoadRecPoints("update"); - loader->CleanRecPoints(); - loader->MakeRecPointsContainer(); - TTree* clustersTree = loader->TreeR(); - - loader->LoadDigits("read"); - TTree* digitsTree = loader->TreeD(); - - Reconstruct(digitsTree,clustersTree); - - loader->UnloadDigits(); - loader->WriteRecPoints("OVERWRITE"); - loader->UnloadRecPoints(); - } -} - -//_____________________________________________________________________________ -void -AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader, AliRawReader* rawReader) const -{ - /// This method is called by AliReconstruction if HasLocalReconstruction()==kFALSE - - AliCodeTimerAuto("AliMUONReconstructor::Reconstruct(AliRunLoader*, AliRawReader*)") - - AliLoader* loader = runLoader->GetDetectorLoader("MUON"); - if (!loader) - { - AliError("Could not get MUON loader"); - return; - } - - Int_t i(0); - - while (rawReader->NextEvent()) - { - runLoader->GetEvent(i++); - - loader->LoadRecPoints("update"); - loader->CleanRecPoints(); - loader->MakeRecPointsContainer(); - TTree* clustersTree = loader->TreeR(); - - loader->LoadDigits("update"); - loader->CleanDigits(); - loader->MakeDigitsContainer(); - TTree* digitsTree = loader->TreeD(); - ConvertDigits(rawReader, digitsTree); - loader->WriteDigits("OVERWRITE"); - - Reconstruct(digitsTree,clustersTree); - - loader->UnloadDigits(); - loader->WriteRecPoints("OVERWRITE"); - loader->UnloadRecPoints(); - } -} - //_____________________________________________________________________________ void AliMUONReconstructor::Reconstruct(TTree* digitsTree, TTree* clustersTree) const diff --git a/MUON/AliMUONReconstructor.h b/MUON/AliMUONReconstructor.h index c6d2db7ea44..56ea533e791 100644 --- a/MUON/AliMUONReconstructor.h +++ b/MUON/AliMUONReconstructor.h @@ -48,17 +48,11 @@ public: virtual void ConvertDigits(AliRawReader* rawReader, TTree* digitsTree) const; - virtual Bool_t HasLocalReconstruction() const; - - virtual void Reconstruct(AliRunLoader* runLoader) const; - - virtual void Reconstruct(AliRunLoader* runLoader, AliRawReader* rawReader) const; - virtual void Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const; virtual void Reconstruct(TTree* digitsTree, TTree* clustersTree) const; - virtual AliTracker* CreateTracker(AliRunLoader* runLoader) const; + virtual AliTracker* CreateTracker() const; private: /// Not implemented @@ -99,7 +93,7 @@ private: mutable AliMUONVTrackStore* fTrackStore; //!< Track container mutable AliMUONTriggerChamberEff* fTrigChamberEff; //!< pointer to trigger chamber efficiency class - ClassDef(AliMUONReconstructor,2) // Implementation of AliReconstructor + ClassDef(AliMUONReconstructor,3) // Implementation of AliReconstructor }; #endif diff --git a/MUON/AliMUONTracker.cxx b/MUON/AliMUONTracker.cxx index 5937010baab..caf04934faf 100644 --- a/MUON/AliMUONTracker.cxx +++ b/MUON/AliMUONTracker.cxx @@ -44,7 +44,6 @@ #include "AliESDEvent.h" #include "AliESDMuonTrack.h" #include "AliESDVertex.h" -#include "AliLoader.h" #include "AliLog.h" #include @@ -56,13 +55,11 @@ ClassImp(AliMUONTracker) //_____________________________________________________________________________ -AliMUONTracker::AliMUONTracker(AliLoader* loader, - const AliMUONDigitMaker* digitMaker, +AliMUONTracker::AliMUONTracker(const AliMUONDigitMaker* digitMaker, const AliMUONGeometryTransformer* transformer, const AliMUONTriggerCircuit* triggerCircuit, AliMUONTriggerChamberEff* chamberEff) : AliTracker(), - fLoader(loader), fDigitMaker(digitMaker), // not owner fTransformer(transformer), // not owner fTriggerCircuit(triggerCircuit), // not owner @@ -127,14 +124,9 @@ AliMUONTracker::Clusters2Tracks(AliESDEvent* esd) /// the TreeT and the ESD Int_t rv(0); - - TTree* tracksTree = fLoader->TreeT(); - - if (!tracksTree) - { - AliError("Cannot get TreeT"); - rv=1; - } + + TTree *tracksTree = new TTree; + if (!fClusterStore) { AliError("ClusterStore is NULL"); diff --git a/MUON/AliMUONTracker.h b/MUON/AliMUONTracker.h index 4f8e35fba2d..74b009d0127 100644 --- a/MUON/AliMUONTracker.h +++ b/MUON/AliMUONTracker.h @@ -14,7 +14,6 @@ class AliCluster; class AliESDEvent; -class AliLoader; class AliMUONDigitMaker; class AliMUONGeometryTransformer; class AliMUONTrackHitPattern; @@ -29,8 +28,7 @@ class AliMUONTracker : public AliTracker { public: - AliMUONTracker(AliLoader* loader, - const AliMUONDigitMaker* digitMaker=0, + AliMUONTracker(const AliMUONDigitMaker* digitMaker=0, const AliMUONGeometryTransformer* transformer=0, const AliMUONTriggerCircuit* triggerCircuit=0, AliMUONTriggerChamberEff* chamberEff=0); @@ -65,7 +63,6 @@ private: void FillESD(AliMUONVTrackStore& trackStore, AliESDEvent* esd) const; private: - AliLoader* fLoader; //!< loader to get access to trees const AliMUONDigitMaker* fDigitMaker; //!< digit maker (not owner) const AliMUONGeometryTransformer* fTransformer; //!< geometry transformer (not owner) const AliMUONTriggerCircuit* fTriggerCircuit; //!< trigger circuit (not owner) diff --git a/PHOS/AliPHOSClusterizer.cxx b/PHOS/AliPHOSClusterizer.cxx index 70b322f906d..381624be23e 100644 --- a/PHOS/AliPHOSClusterizer.cxx +++ b/PHOS/AliPHOSClusterizer.cxx @@ -23,15 +23,14 @@ #include #include "AliPHOSClusterizer.h" -#include "AliPHOSQualAssDataMaker.h" #include "AliPHOSDigit.h" +#include "AliLog.h" ClassImp(AliPHOSClusterizer) //____________________________________________________________________________ AliPHOSClusterizer::AliPHOSClusterizer(): fGeom(NULL), - fQADM(0), fDigitsArr(0), fTreeR(0), fEMCRecPoints(0), @@ -43,23 +42,19 @@ AliPHOSClusterizer::AliPHOSClusterizer(): //____________________________________________________________________________ AliPHOSClusterizer::AliPHOSClusterizer(AliPHOSGeometry *geom): fGeom(geom), - fQADM(0), fDigitsArr(0), fTreeR(0), fEMCRecPoints(0), fCPVRecPoints(0) { // ctor - fQADM = new AliPHOSQualAssDataMaker() ; - //initiaizes the quality assurance data maker - fQADM ->Init(AliQualAss::kRECPOINTS) ; + } //____________________________________________________________________________ AliPHOSClusterizer::~AliPHOSClusterizer() { // dtor - delete fQADM ; if (fDigitsArr) { fDigitsArr->Delete(); delete fDigitsArr; diff --git a/PHOS/AliPHOSClusterizer.h b/PHOS/AliPHOSClusterizer.h index 9176f203dc6..0260a3e038d 100644 --- a/PHOS/AliPHOSClusterizer.h +++ b/PHOS/AliPHOSClusterizer.h @@ -6,6 +6,9 @@ /* History of cvs commits: * * $Log$ + * Revision 1.42 2007/08/28 12:55:07 policheh + * Loaders removed from the reconstruction code (C.Cheshkov) + * * Revision 1.41 2007/08/07 14:12:03 kharlov * Quality assurance added (Yves Schutz) * @@ -33,7 +36,6 @@ class TTree; class AliPHOSGeometry; -class AliPHOSQualAssDataMaker ; class AliPHOSClusterizer : public TObject { @@ -70,10 +72,8 @@ public: virtual void SetOutput(TTree *clustersTree); protected: - AliPHOSQualAssDataMaker * GetQualAssDataMaker() const { return fQADM ; } AliPHOSGeometry *fGeom; // Pointer to PHOS geometry - AliPHOSQualAssDataMaker * fQADM ; //!Quality Assurance Data Maker TClonesArray *fDigitsArr; // Array with input digits TTree *fTreeR; // Tree with output clusters TObjArray *fEMCRecPoints; // Array with EMC clusters diff --git a/PHOS/AliPHOSClusterizerv1.cxx b/PHOS/AliPHOSClusterizerv1.cxx index 2147a605a42..f9179a85dd8 100644 --- a/PHOS/AliPHOSClusterizerv1.cxx +++ b/PHOS/AliPHOSClusterizerv1.cxx @@ -18,6 +18,9 @@ /* History of cvs commits: * * $Log$ + * Revision 1.114 2007/09/06 16:06:44 kharlov + * Absence of sorting results in loose of all unfolded clusters + * * Revision 1.113 2007/08/28 12:55:07 policheh * Loaders removed from the reconstruction code (C.Cheshkov) * @@ -170,7 +173,6 @@ #include "AliCDBStorage.h" #include "AliCDBEntry.h" #include "AliPHOSRecoParam.h" -#include "AliPHOSQualAssDataMaker.h" #include "AliPHOSCalibData.h" #include "AliPHOSReconstructor.h" @@ -298,24 +300,11 @@ void AliPHOSClusterizerv1::Digits2Clusters(Option_t *option) if(fToUnfold) MakeUnfolding(); - //makes the quality assurance data - if (GetQualAssDataMaker()) { - GetQualAssDataMaker()->SetData(fEMCRecPoints) ; - GetQualAssDataMaker()->Exec(AliQualAss::kRECPOINTS) ; - GetQualAssDataMaker()->SetData(fCPVRecPoints) ; - GetQualAssDataMaker()->Exec(AliQualAss::kRECPOINTS) ; - } - WriteRecPoints(); if(strstr(option,"deb")) PrintRecPoints(option) ; - // PLEASE FIX BY MOVING IT TO ALIRECONSTRUCTION !!! - //Write the quality assurance data only after the last event - // if (GetQualAssDataMaker() && fEventCounter == gime->MaxEvent()) - // GetQualAssDataMaker()->Finish(AliQualAss::kRECPOINTS) ; - if(strstr(option,"tim")){ gBenchmark->Stop("PHOSClusterizer"); AliInfo(Form("took %f seconds for Clusterizing\n", diff --git a/PHOS/AliPHOSClusterizerv2.cxx b/PHOS/AliPHOSClusterizerv2.cxx index 61d9ccbc252..e774731781f 100644 --- a/PHOS/AliPHOSClusterizerv2.cxx +++ b/PHOS/AliPHOSClusterizerv2.cxx @@ -33,7 +33,6 @@ #include "AliPHOSRecCpvManager.h" #include "AliPHOSRecEmcManager.h" #include "AliPHOSGeometry.h" -#include "AliPHOSQualAssDataMaker.h" #include "AliPHOSDigit.h" ClassImp(AliPHOSClusterizerv2) @@ -168,11 +167,6 @@ void AliPHOSClusterizerv2::Digits2Clusters(Option_t* option) // nOldEmc, // gime->EmcRecPoints()->GetEntries(), emcRecPoints->GetEntries() )); -// GetQualAssDataMaker()->Init(AliQualAss::kRECPOINTS) ; -// GetQualAssDataMaker()->SetData(gime->EmcRecPoints()) ; -// GetQualAssDataMaker()->Exec(AliQualAss::kRECPOINTS) ; -// GetQualAssDataMaker()->SetData(gime->CpvRecPoints()) ; -// GetQualAssDataMaker()->Exec(AliQualAss::kRECPOINTS) ; // WriteRecPoints(); diff --git a/PHOS/AliPHOSDigitizer.cxx b/PHOS/AliPHOSDigitizer.cxx index 3f10835e057..e776cc07233 100644 --- a/PHOS/AliPHOSDigitizer.cxx +++ b/PHOS/AliPHOSDigitizer.cxx @@ -18,6 +18,9 @@ /* History of cvs commits: * * $Log$ + * Revision 1.97 2007/08/07 14:12:03 kharlov + * Quality assurance added (Yves Schutz) + * * Revision 1.96 2007/04/28 10:43:36 policheh * Dead channels simulation: digit energy sets to 0. * @@ -625,8 +628,7 @@ void AliPHOSDigitizer::Exec(Option_t *option) Digitize(ievent) ; //Add prepared SDigits to digits and add the noise //makes the quality assurance data - GetQualAssDataMaker()->SetData(gime->Digits()) ; - GetQualAssDataMaker()->Exec(AliQualAss::kDIGITS) ; + GetQualAssDataMaker()->Exec(AliQualAss::kDIGITS, gime->Digits()) ; WriteDigits() ; diff --git a/PHOS/AliPHOSPID.cxx b/PHOS/AliPHOSPID.cxx index f9e1843cbcc..d1bf115ed8c 100644 --- a/PHOS/AliPHOSPID.cxx +++ b/PHOS/AliPHOSPID.cxx @@ -34,7 +34,6 @@ #include "AliConfig.h" #include "AliPHOSPID.h" #include "AliPHOSGetter.h" -#include "AliPHOSQualAssDataMaker.h" ClassImp(AliPHOSPID) @@ -46,8 +45,7 @@ AliPHOSPID::AliPHOSPID(): fEMCRecPoints(NULL), fCPVRecPoints(NULL), fTrackSegments(NULL), - fRecParticles(NULL), - fQADM(0x0) + fRecParticles(NULL) { // ctor } @@ -61,15 +59,12 @@ AliPHOSPID::AliPHOSPID(AliPHOSGeometry *geom): fEMCRecPoints(NULL), fCPVRecPoints(NULL), fTrackSegments(NULL), - fRecParticles(NULL), - fQADM(0x0) + fRecParticles(NULL) { // ctor fRecParticles = new TClonesArray("AliPHOSRecParticle",100) ; fRecParticles->SetName("RECPARTICLES"); - fQADM = new AliPHOSQualAssDataMaker() ; //!Quality Assurance Data Maker - GetQualAssDataMaker()->Init(AliQualAss::kRECPARTICLES) ; } //____________________________________________________________________________ @@ -80,8 +75,7 @@ AliPHOSPID::AliPHOSPID(const AliPHOSPID & pid) : fEMCRecPoints(pid.fEMCRecPoints), fCPVRecPoints(pid.fCPVRecPoints), fTrackSegments(pid.fTrackSegments), - fRecParticles(pid.fRecParticles), - fQADM(pid.fQADM) + fRecParticles(pid.fRecParticles) { // Copy constructor } @@ -98,7 +92,6 @@ AliPHOSPID::~AliPHOSPID() fCPVRecPoints->Delete(); delete fCPVRecPoints; } - delete fQADM ; } //____________________________________________________________________________ diff --git a/PHOS/AliPHOSPID.h b/PHOS/AliPHOSPID.h index 1db79aded0c..f1e53515382 100644 --- a/PHOS/AliPHOSPID.h +++ b/PHOS/AliPHOSPID.h @@ -8,6 +8,9 @@ /* History of cvs commits: * * $Log$ + * Revision 1.41 2007/08/28 12:55:08 policheh + * Loaders removed from the reconstruction code (C.Cheshkov) + * * Revision 1.40 2007/08/07 14:12:03 kharlov * Quality assurance added (Yves Schutz) * @@ -45,7 +48,6 @@ class AliESDEvent ; class AliPHOSGeometry ; class AliPHOSClusterizer ; class AliPHOSTrackSegmentMaker ; -class AliPHOSQualAssDataMaker ; class AliPHOSPID : public TObject { @@ -69,8 +71,6 @@ class AliPHOSPID : public TObject { virtual const char * Version() const = 0; - AliPHOSQualAssDataMaker * GetQualAssDataMaker() const { return fQADM ; } - protected: AliPHOSGeometry * fGeom; //! Pointer to PHOS Geometry @@ -84,8 +84,6 @@ protected: private: - AliPHOSQualAssDataMaker * fQADM ; //!Quality Assurance Data Maker - ClassDef(AliPHOSPID,6) // Particle Identifier algorithm (base class) } ; diff --git a/PHOS/AliPHOSQualAssDataMaker.cxx b/PHOS/AliPHOSQualAssDataMaker.cxx index 767d8fe31e7..5ddd6b9f1cd 100644 --- a/PHOS/AliPHOSQualAssDataMaker.cxx +++ b/PHOS/AliPHOSQualAssDataMaker.cxx @@ -180,11 +180,10 @@ void AliPHOSQualAssDataMaker::InitTrackSegments() } //____________________________________________________________________________ -void AliPHOSQualAssDataMaker::MakeESDs() +void AliPHOSQualAssDataMaker::MakeESDs(AliESDEvent * esd) { // make QA data from ESDs - AliESDEvent * esd = dynamic_cast(fData) ; Int_t maxClu = esd->GetNumberOfPHOSClusters() ; Int_t index = 0, count = 0 ; for ( index = 0 ; index < maxClu; index++ ) { @@ -196,95 +195,128 @@ void AliPHOSQualAssDataMaker::MakeESDs() } //____________________________________________________________________________ -void AliPHOSQualAssDataMaker::MakeHits() +void AliPHOSQualAssDataMaker::MakeHits(TObject * data) { //make QA data from Hits - TClonesArray * hits = dynamic_cast(fData) ; - fhHitsMul->Fill(hits->GetEntriesFast()) ; - TIter next(hits) ; - AliPHOSHit * hit ; - while ( (hit = dynamic_cast(next())) ) { - fhHits->Fill( hit->GetEnergy()) ; - } -} + TClonesArray * hits = dynamic_cast(data) ; + if (!hits) { + AliError("Wrong type of hits container") ; + } else { + fhHitsMul->Fill(hits->GetEntriesFast()) ; + TIter next(hits) ; + AliPHOSHit * hit ; + while ( (hit = dynamic_cast(next())) ) { + fhHits->Fill( hit->GetEnergy()) ; + } + } +} //____________________________________________________________________________ -void AliPHOSQualAssDataMaker::MakeDigits() +void AliPHOSQualAssDataMaker::MakeDigits(TObject * data) { // makes data from Digits - TClonesArray * digits = dynamic_cast(fData) ; - fhDigitsMul->Fill(digits->GetEntriesFast()) ; - TIter next(digits) ; - AliPHOSDigit * digit ; - while ( (digit = dynamic_cast(next())) ) { - fhDigits->Fill( digit->GetEnergy()) ; - } + TClonesArray * digits = dynamic_cast(data) ; + if (!digits) { + AliError("Wrong type of digits container") ; + } else { + fhDigitsMul->Fill(digits->GetEntriesFast()) ; + TIter next(digits) ; + AliPHOSDigit * digit ; + while ( (digit = dynamic_cast(next())) ) { + fhDigits->Fill( digit->GetEnergy()) ; + } + } } //____________________________________________________________________________ -void AliPHOSQualAssDataMaker::MakeRecParticles() -{ - // makes data from RecParticles +// void AliPHOSQualAssDataMaker::MakeRecParticles(TTree * recpar) +// { +// // makes data from RecParticles - TClonesArray * recparticles = dynamic_cast(fData) ; - fhRecParticlesMul->Fill(recparticles->GetEntriesFast()) ; - TIter next(recparticles) ; - AliPHOSRecParticle * recparticle ; - while ( (recparticle = dynamic_cast(next())) ) { - fhRecParticles->Fill( recparticle->Energy()) ; - } -} +// TClonesArray * recparticles = dynamic_cast(fData) ; +// fhRecParticlesMul->Fill(recparticles->GetEntriesFast()) ; +// TIter next(recparticles) ; +// AliPHOSRecParticle * recparticle ; +// while ( (recparticle = dynamic_cast(next())) ) { +// fhRecParticles->Fill( recparticle->Energy()) ; +// } +// } //____________________________________________________________________________ -void AliPHOSQualAssDataMaker::MakeRecPoints() +void AliPHOSQualAssDataMaker::MakeRecPoints(TTree * clustersTree) { - // makes data from RecPoints - TObjArray * recpoints = dynamic_cast(fData) ; - TIter next(recpoints) ; - - if ( strcmp(fData->GetName(), "EMCRECPOINTS") == 0 ) { - fhEmcRecPointsMul->Fill(recpoints->GetEntriesFast()) ; + { + // makes data from RecPoints + TBranch *emcbranch = clustersTree->GetBranch("PHOSEmcRP"); + if (!emcbranch) { + AliError("can't get the branch with the PHOS EMC clusters !"); + return; + } + TObjArray * emcrecpoints = new TObjArray(100) ; + emcbranch->SetAddress(&emcrecpoints); + emcbranch->GetEntry(0); + + fhEmcRecPointsMul->Fill(emcrecpoints->GetEntriesFast()) ; + TIter next(emcrecpoints) ; AliPHOSEmcRecPoint * rp ; while ( (rp = dynamic_cast(next())) ) { fhEmcRecPoints->Fill( rp->GetEnergy()) ; } - } - else if ( strcmp(fData->GetName(), "CPVRECPOINTS") == 0 ) { - fhCpvRecPointsMul->Fill(recpoints->GetEntriesFast()) ; + emcrecpoints->Delete(); + delete emcrecpoints; + } + { + TBranch *cpvbranch = clustersTree->GetBranch("PHOSCpvRP"); + if (!cpvbranch) { + AliError("can't get the branch with the PHOS CPV clusters !"); + return; + } + TObjArray *cpvrecpoints = new TObjArray(100) ; + cpvbranch->SetAddress(&cpvrecpoints); + cpvbranch->GetEntry(0); + + fhCpvRecPointsMul->Fill(cpvrecpoints->GetEntriesFast()) ; + TIter next(cpvrecpoints) ; AliPHOSCpvRecPoint * rp ; while ( (rp = dynamic_cast(next())) ) { fhCpvRecPoints->Fill( rp->GetEnergy()) ; } - } + cpvrecpoints->Delete(); + delete cpvrecpoints; + } } //____________________________________________________________________________ -void AliPHOSQualAssDataMaker::MakeSDigits() +void AliPHOSQualAssDataMaker::MakeSDigits(TObject * data) { // makes data from SDigits - - TClonesArray * sdigits = dynamic_cast(fData) ; - fhSDigitsMul->Fill(sdigits->GetEntriesFast()) ; - TIter next(sdigits) ; - AliPHOSDigit * sdigit ; - while ( (sdigit = dynamic_cast(next())) ) { - fhSDigits->Fill( sdigit->GetEnergy()) ; - } + + TClonesArray * sdigits = dynamic_cast(data) ; + if (!sdigits) { + AliError("Wrong type of sdigits container") ; + } else { + fhSDigitsMul->Fill(sdigits->GetEntriesFast()) ; + TIter next(sdigits) ; + AliPHOSDigit * sdigit ; + while ( (sdigit = dynamic_cast(next())) ) { + fhSDigits->Fill( sdigit->GetEnergy()) ; + } + } } //____________________________________________________________________________ -void AliPHOSQualAssDataMaker::MakeTrackSegments() -{ - // makes data from TrackSegments +// void AliPHOSQualAssDataMaker::MakeTrackSegments(TTree * ts) +// { +// // makes data from TrackSegments - TClonesArray * tracksegments = dynamic_cast(fData) ; +// TClonesArray * tracksegments = dynamic_cast(fData) ; - fhTrackSegmentsMul->Fill(tracksegments->GetEntriesFast()) ; - TIter next(tracksegments) ; - AliPHOSTrackSegment * ts ; - while ( (ts = dynamic_cast(next())) ) { - fhTrackSegments->Fill( ts->GetCpvDistance()) ; - } -} +// fhTrackSegmentsMul->Fill(tracksegments->GetEntriesFast()) ; +// TIter next(tracksegments) ; +// AliPHOSTrackSegment * ts ; +// while ( (ts = dynamic_cast(next())) ) { +// fhTrackSegments->Fill( ts->GetCpvDistance()) ; +// } +// } diff --git a/PHOS/AliPHOSQualAssDataMaker.h b/PHOS/AliPHOSQualAssDataMaker.h index f08cc022e9d..9fa4078d161 100644 --- a/PHOS/AliPHOSQualAssDataMaker.h +++ b/PHOS/AliPHOSQualAssDataMaker.h @@ -38,13 +38,13 @@ private: virtual void InitRecPoints() ; virtual void InitTrackSegments() ; virtual void InitSDigits() ; - virtual void MakeESDs() ; - virtual void MakeHits() ; - virtual void MakeDigits() ; - virtual void MakeRecParticles() ; - virtual void MakeRecPoints() ; - virtual void MakeSDigits() ; - virtual void MakeTrackSegments() ; + virtual void MakeESDs(AliESDEvent * esd) ; + virtual void MakeHits(TObject * hits) ; + virtual void MakeDigits(TObject * digits) ; + // virtual void MakeRecParticles(TTree * recpar) ; + virtual void MakeRecPoints(TTree * recpo) ; + virtual void MakeSDigits(TObject * sigits) ; + //virtual void MakeTrackSegments(TTree *ts ) ; TH1F * fhHits ; //! hits energy histogram TH1I * fhHitsMul ; //! hits multiplicity histogram diff --git a/PHOS/AliPHOSReconstructor.cxx b/PHOS/AliPHOSReconstructor.cxx index edbe76b14e1..461e350a09d 100644 --- a/PHOS/AliPHOSReconstructor.cxx +++ b/PHOS/AliPHOSReconstructor.cxx @@ -27,7 +27,6 @@ // --- AliRoot header files --- #include "AliLog.h" -#include "AliPHOSQualAssDataMaker.h" #include "AliESDEvent.h" #include "AliESDCaloCluster.h" #include "AliPHOSReconstructor.h" @@ -107,10 +106,8 @@ void AliPHOSReconstructor::FillESD(TTree* digitsTree, TTree* clustersTree, // write tracks to the ESD AliPHOSTrackSegmentMaker *tsm = new AliPHOSTrackSegmentMakerv1(fGeom); - tsm->GetQualAssDataMaker()->Init(AliQualAss::kTRACKSEGMENTS) ; AliPHOSPID *pid = new AliPHOSPIDv1(fGeom); - pid->GetQualAssDataMaker()->Init(AliQualAss::kRECPARTICLES) ; - + // do current event; the loop over events is done by AliReconstruction::Run() tsm->SetESD(esd) ; tsm->SetInput(clustersTree); @@ -119,9 +116,6 @@ void AliPHOSReconstructor::FillESD(TTree* digitsTree, TTree* clustersTree, else tsm->Clusters2TrackSegments("") ; - tsm->GetQualAssDataMaker()->SetData(tsm->GetTrackSegments()) ; - tsm->GetQualAssDataMaker()->Exec(AliQualAss::kTRACKSEGMENTS) ; - pid->SetInput(clustersTree, tsm->GetTrackSegments()) ; pid->SetESD(esd) ; if ( Debug() ) @@ -129,14 +123,6 @@ void AliPHOSReconstructor::FillESD(TTree* digitsTree, TTree* clustersTree, else pid->TrackSegments2RecParticles("") ; - pid->GetQualAssDataMaker()->SetData(pid->GetRecParticles()) ; - pid->GetQualAssDataMaker()->Exec(AliQualAss::kRECPARTICLES) ; - - // PLEASE FIX IT. SHOULD GO TO ALIRECONSTRUCTION !! - // if ( eventNumber == gime->MaxEvent()-1 ) { - // fTSM->GetQualAssDataMaker()->Finish(AliQualAss::kTRACKSEGMENTS) ; - // fPID->GetQualAssDataMaker()->Finish(AliQualAss::kRECPARTICLES) ; - // } // This function creates AliESDtracks from AliPHOSRecParticles // and @@ -313,7 +299,7 @@ void AliPHOSReconstructor::FillESD(TTree* digitsTree, TTree* clustersTree, } } -AliTracker* AliPHOSReconstructor::CreateTracker(AliRunLoader* /* runLoader */) const +AliTracker* AliPHOSReconstructor::CreateTracker() const { // creates the PHOS tracker return new AliPHOSTracker(); diff --git a/PHOS/AliPHOSReconstructor.h b/PHOS/AliPHOSReconstructor.h index 550ce54c249..51775fc7a56 100644 --- a/PHOS/AliPHOSReconstructor.h +++ b/PHOS/AliPHOSReconstructor.h @@ -8,6 +8,9 @@ /* History of cvs commits: * * $Log$ + * Revision 1.13 2007/08/30 10:40:27 cvetan + * Minor + * * Revision 1.12 2007/08/28 12:55:08 policheh * Loaders removed from the reconstruction code (C.Cheshkov) * @@ -68,15 +71,12 @@ public: static void SetDebug() { fgDebug = kTRUE ; } static void ResetDebug() { fgDebug = kFALSE ; } static Bool_t Debug() { return fgDebug ; } - AliTracker *CreateTracker(AliRunLoader* runLoader) const; + AliTracker *CreateTracker() const; using AliReconstructor::FillESD; virtual void FillESD(TTree* digitsTree, TTree* clustersTree, AliESDEvent* esd) const; using AliReconstructor::Reconstruct; - virtual Bool_t HasLocalReconstruction() const {return kTRUE;}; virtual void Reconstruct(TTree* digitsTree, TTree* clustersTree) const; - // virtual void Reconstruct(AliRunLoader* runLoader) const ; - // virtual void Reconstruct(AliRunLoader* runLoader, AliRawReader * rawreader) const ; virtual Bool_t HasDigitConversion() const {return kTRUE;}; virtual void ConvertDigits(AliRawReader* rawReader, TTree* digitsTree) const; @@ -100,7 +100,7 @@ private: static AliPHOSRecoParam* fgkRecoParamCpv; // reconstruction parameters for EMC AliPHOSGeometry* fGeom; // pointer to the PHOS geometry - ClassDef(AliPHOSReconstructor,3) // PHOS Reconstruction class + ClassDef(AliPHOSReconstructor,4) // PHOS Reconstruction class }; diff --git a/PHOS/AliPHOSSDigitizer.cxx b/PHOS/AliPHOSSDigitizer.cxx index 1e5b0d5dcd1..5e079322cba 100644 --- a/PHOS/AliPHOSSDigitizer.cxx +++ b/PHOS/AliPHOSSDigitizer.cxx @@ -19,6 +19,9 @@ /* History of cvs commits: * * $Log$ + * Revision 1.51 2007/08/07 14:12:03 kharlov + * Quality assurance added (Yves Schutz) + * * Revision 1.50 2006/08/28 10:01:56 kharlov * Effective C++ warnings fixed (Timur Pocheptsov) * @@ -275,10 +278,8 @@ void AliPHOSSDigitizer::Exec(Option_t *option) // make Quality Assurance data - GetQualAssDataMaker()->SetData(hits) ; - GetQualAssDataMaker()->Exec(AliQualAss::kHITS) ; - GetQualAssDataMaker()->SetData(sdigits) ; - GetQualAssDataMaker()->Exec(AliQualAss::kSDIGITS) ; + GetQualAssDataMaker()->Exec(AliQualAss::kHITS, hits) ; + GetQualAssDataMaker()->Exec(AliQualAss::kSDIGITS, sdigits) ; //Now write SDigits diff --git a/PHOS/AliPHOSTrackSegmentMaker.cxx b/PHOS/AliPHOSTrackSegmentMaker.cxx index ac9ca683b9b..ccbd2f1b3e2 100644 --- a/PHOS/AliPHOSTrackSegmentMaker.cxx +++ b/PHOS/AliPHOSTrackSegmentMaker.cxx @@ -17,6 +17,9 @@ /* History of cvs commits: * * $Log$ + * Revision 1.29 2007/08/28 12:55:08 policheh + * Loaders removed from the reconstruction code (C.Cheshkov) + * * Revision 1.28 2007/08/07 14:12:03 kharlov * Quality assurance added (Yves Schutz) * @@ -46,7 +49,7 @@ // --- AliRoot header files --- #include "AliPHOSTrackSegmentMaker.h" -#include "AliPHOSQualAssDataMaker.h" +#include "AliLog.h" ClassImp( AliPHOSTrackSegmentMaker) @@ -55,7 +58,6 @@ ClassImp( AliPHOSTrackSegmentMaker) AliPHOSTrackSegmentMaker:: AliPHOSTrackSegmentMaker() : TObject(), fESD(0), - fQADM(0x0), fGeom(0), fEMCRecPoints(0), fCPVRecPoints(0) @@ -67,21 +69,17 @@ AliPHOSTrackSegmentMaker:: AliPHOSTrackSegmentMaker() : AliPHOSTrackSegmentMaker::AliPHOSTrackSegmentMaker(AliPHOSGeometry *geom): TObject(), fESD(0), - fQADM(0x0), fGeom(geom), fEMCRecPoints(0), fCPVRecPoints(0) { // ctor - fQADM = new AliPHOSQualAssDataMaker() ; //!Quality Assurance Data Maker - GetQualAssDataMaker()->Init(AliQualAss::kTRACKSEGMENTS) ; } //____________________________________________________________________________ AliPHOSTrackSegmentMaker::AliPHOSTrackSegmentMaker(const AliPHOSTrackSegmentMaker & tsmaker) : TObject(tsmaker), fESD(tsmaker.GetESD()), - fQADM(tsmaker.fQADM), fGeom(tsmaker.fGeom), fEMCRecPoints(tsmaker.fEMCRecPoints), fCPVRecPoints(tsmaker.fCPVRecPoints) @@ -95,7 +93,6 @@ AliPHOSTrackSegmentMaker::~AliPHOSTrackSegmentMaker() //Remove this from the parental task before destroying // if(AliPHOSGetter::Instance()->PhosLoader()) // AliPHOSGetter::Instance()->PhosLoader()->CleanTracker(); - delete fQADM ; if (fEMCRecPoints) { fEMCRecPoints->Delete(); delete fEMCRecPoints; diff --git a/PHOS/AliPHOSTrackSegmentMaker.h b/PHOS/AliPHOSTrackSegmentMaker.h index f21ef106bae..f4fa690a792 100644 --- a/PHOS/AliPHOSTrackSegmentMaker.h +++ b/PHOS/AliPHOSTrackSegmentMaker.h @@ -8,6 +8,9 @@ /* History of cvs commits: * * $Log$ + * Revision 1.43 2007/08/28 12:55:08 policheh + * Loaders removed from the reconstruction code (C.Cheshkov) + * * Revision 1.42 2007/08/07 14:12:03 kharlov * Quality assurance added (Yves Schutz) * @@ -39,7 +42,6 @@ class TTree; // --- AliRoot header files --- class AliPHOSGeometry ; class AliESDEvent ; -class AliPHOSQualAssDataMaker ; class AliPHOSTrackSegmentMaker : public TObject { @@ -62,14 +64,11 @@ public: AliESDEvent *GetESD() const {return fESD; } - AliPHOSQualAssDataMaker * GetQualAssDataMaker() const { return fQADM ; } - virtual TClonesArray * GetTrackSegments() const = 0; protected: AliESDEvent * fESD; //! ESD object - AliPHOSQualAssDataMaker * fQADM ; //!Quality Assurance Data Maker AliPHOSGeometry *fGeom; //! Pointer to the PHOS geometry TObjArray *fEMCRecPoints; // Array with the EMC clusters TObjArray *fCPVRecPoints; // Array with the CPV clusters diff --git a/PMD/AliPMDReconstructor.cxx b/PMD/AliPMDReconstructor.cxx index 5ab255e7ec4..145942848c6 100644 --- a/PMD/AliPMDReconstructor.cxx +++ b/PMD/AliPMDReconstructor.cxx @@ -21,7 +21,6 @@ #include "Riostream.h" #include "AliPMDReconstructor.h" -#include "AliRunLoader.h" #include "AliRun.h" #include "AliPMDClusterFinder.h" #include "AliPMDtracker.h" @@ -32,41 +31,6 @@ ClassImp(AliPMDReconstructor) -//_____________________________________________________________________________ -void AliPMDReconstructor::Reconstruct(AliRunLoader* runLoader) const -{ -// reconstruct clusters from digits file - - AliPMDClusterFinder *pmdClus = new AliPMDClusterFinder(runLoader); - pmdClus->Load(); - for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) - { - pmdClus->Digits2RecPoints(iEvent); - } - pmdClus->UnLoad(); - delete pmdClus; - -} -// ------------------------------------------------------------------------ // - -void AliPMDReconstructor::Reconstruct(AliRunLoader* runLoader, - AliRawReader *rawReader) const -{ -// reconstruct clusters from Raw Data - - AliPMDClusterFinder pmdClus(runLoader); - pmdClus.LoadClusters(); - - Int_t iEvent = 0; - while (rawReader->NextEvent()) { - pmdClus.Digits2RecPoints(iEvent,rawReader); - iEvent++; - } - pmdClus.UnLoadClusters(); - -} - - // ------------------------------------------------------------------------ // void AliPMDReconstructor::Reconstruct(AliRawReader *rawReader, @@ -90,23 +54,6 @@ void AliPMDReconstructor::Reconstruct(TTree *digitsTree, } -// ------------------------------------------------------------------------ // - -//void AliPMDReconstructor::FillESD(AliRunLoader* runLoader,AliESDEvent* esd) const -//{ -// AliLoader* loader = runLoader->GetLoader("PMDLoader"); -// if (!loader) { -// AliError("PMD loader not found"); -// return; -// } -// loader->LoadRecPoints("READ"); -// TTree *treeR = loader->TreeR(); -// AliPMDtracker pmdtracker; -// pmdtracker.LoadClusters(treeR); -// pmdtracker.Clusters2Tracks(esd); -// loader->UnloadRecPoints(); -//} - // ------------------------------------------------------------------------ // void AliPMDReconstructor::FillESD(AliRawReader* /*rawReader*/, TTree* clustersTree, AliESDEvent* esd) const diff --git a/PMD/AliPMDReconstructor.h b/PMD/AliPMDReconstructor.h index afdab35be39..7e32ddaf059 100644 --- a/PMD/AliPMDReconstructor.h +++ b/PMD/AliPMDReconstructor.h @@ -7,34 +7,19 @@ class AliPMDReconstructor: public AliReconstructor { public: - virtual void Init(AliRunLoader* /*runLoader*/) {;} - virtual void Reconstruct(AliRunLoader* runLoader) const; - virtual void Reconstruct(AliRunLoader* runLoader, - AliRawReader *rawReader) const; virtual void Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const; virtual void Reconstruct(TTree* digitsTree, TTree* clustersTree) const; - virtual Bool_t HasLocalReconstruction() const { return kTRUE; } - - //virtual void FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const; virtual void FillESD(AliRawReader* /*rawReader*/, TTree* clustersTree, AliESDEvent* esd) const; virtual void FillESD(TTree* /*digitsTree*/, TTree* clustersTree, AliESDEvent* esd) const; - virtual void FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const { - AliReconstructor::FillESD(runLoader,esd); - } - virtual void FillESD(AliRunLoader* runLoader, - AliRawReader* rawReader, AliESDEvent* esd) const { - AliReconstructor::FillESD(runLoader,rawReader,esd); - } - private: - ClassDef(AliPMDReconstructor, 4) // class for the PMD reconstruction + ClassDef(AliPMDReconstructor, 5) // class for the PMD reconstruction }; #endif diff --git a/STEER/AliQualAssDataMaker.cxx b/STEER/AliQualAssDataMaker.cxx index 348233aaa4f..9566dbf753a 100644 --- a/STEER/AliQualAssDataMaker.cxx +++ b/STEER/AliQualAssDataMaker.cxx @@ -26,12 +26,15 @@ // --- ROOT system --- #include #include +#include +#include // --- Standard library --- // --- AliRoot header files --- #include "AliLog.h" #include "AliQualAssDataMaker.h" +#include "AliESDEvent.h" ClassImp(AliQualAssDataMaker) @@ -42,8 +45,7 @@ TString AliQualAssDataMaker::fDetectorDirName("") ; AliQualAssDataMaker::AliQualAssDataMaker(const char * name, const char * title) : TNamed(name, title), fOutput(0x0), - fDetectorDir(0x0), - fData(0x0) + fDetectorDir(0x0) { // ctor TString tmp(GetName()) ; @@ -57,8 +59,7 @@ AliQualAssDataMaker::AliQualAssDataMaker(const char * name, const char * title) AliQualAssDataMaker::AliQualAssDataMaker(const AliQualAssDataMaker& qadm) : TNamed(qadm.GetName(), qadm.GetTitle()), fOutput(qadm.fOutput), - fDetectorDir(qadm.fDetectorDir), - fData(qadm.fData) + fDetectorDir(qadm.fDetectorDir) { //copy ctor fDetectorDirName = GetName() ; @@ -74,7 +75,7 @@ AliQualAssDataMaker& AliQualAssDataMaker::operator = (const AliQualAssDataMaker& } //____________________________________________________________________________ -void AliQualAssDataMaker::Exec(AliQualAss::TASKINDEX task) +void AliQualAssDataMaker::Exec(AliQualAss::TASKINDEX task, TObject * data) { // creates the quality assurance data for the various tasks (Hits, SDigits, Digits, ESDs) @@ -85,37 +86,54 @@ void AliQualAssDataMaker::Exec(AliQualAss::TASKINDEX task) switch (task) { case AliQualAss::kHITS: AliInfo("Processing Hits QA") ; - MakeHits() ; + MakeHits(data) ; break ; - case AliQualAss::kSDIGITS: + case AliQualAss::kSDIGITS: AliInfo("Processing SDigits QA") ; - MakeSDigits() ; + MakeSDigits(data) ; break ; - - case AliQualAss::kDIGITS: - AliInfo("Processing Digits QA") ; - MakeDigits() ; + + case AliQualAss::kDIGITS: + MakeDigits(data) ; break ; case AliQualAss::kRECPOINTS: - AliInfo("Processing RecPoints QA") ; - MakeRecPoints() ; + AliInfo("Processing RecPoints QA") ; + { + TTree * recpoints = dynamic_cast(data) ; + if (recpoints) + MakeRecPoints(recpoints) ; + else + AliError("Wrong type of recpoints container") ; + } break ; case AliQualAss::kTRACKSEGMENTS: - AliInfo("Processing Track Segments QA") ; - MakeTrackSegments() ; + AliInfo("Processing Track Segments QA: not existing anymore") ; +// TTree * ts = dynamic_cast(data) ; +// if (ts) +// MakeTrackSegments(ts) ; +// else +// AliError("Wrong type of track segments container") ; break ; - case AliQualAss::kRECPARTICLES: - AliInfo("Processing RecParticles QA") ; - MakeRecParticles() ; - break ; - + case AliQualAss::kRECPARTICLES: + AliInfo("Processing RecParticles QA: not existing anymore") ; +// TTree * recpar = dynamic_cast(data) ; +// if (recpar) +// MakeRecParticles(recpar) ; +// else +// AliError("Wrong type of recparticles container") ; + break ; + case AliQualAss::kESDS: AliInfo("Processing ESDs QA") ; - MakeESDs() ; + AliESDEvent * esd = dynamic_cast(data) ; + if (esd) + MakeESDs(esd) ; + else + AliError("Wrong type of esd container") ; break ; } } diff --git a/STEER/AliQualAssDataMaker.h b/STEER/AliQualAssDataMaker.h index 19611d1fa7d..1483df8f268 100644 --- a/STEER/AliQualAssDataMaker.h +++ b/STEER/AliQualAssDataMaker.h @@ -18,6 +18,9 @@ #include class TFile; class TDirectory; +class TObject; +class TTree; +class AliESDEvent; // --- Standard library --- @@ -33,12 +36,11 @@ public: AliQualAssDataMaker& operator = (const AliQualAssDataMaker& qadm) ; virtual ~AliQualAssDataMaker() {;} // dtor - virtual void Exec(AliQualAss::TASKINDEX) ; + virtual void Exec(AliQualAss::TASKINDEX, TObject * data) ; void Finish(AliQualAss::TASKINDEX task) const ; static const char * GetDetectorDirName() { return fDetectorDirName.Data() ; } void Init(AliQualAss::TASKINDEX) ; - void SetData(TObject * obj) { fData = obj ; } - + protected: virtual void InitDigits() {AliInfo("To ne implemented by detectors");} @@ -48,17 +50,16 @@ protected: virtual void InitRecPoints() {AliInfo("To ne implemented by detectors");} virtual void InitSDigits() {AliInfo("To ne implemented by detectors");} virtual void InitTrackSegments() {AliInfo("To ne implemented by detectors");} - virtual void MakeESDs() {AliInfo("To ne implemented by detectors");} - virtual void MakeHits() {AliInfo("To ne implemented by detectors");} - virtual void MakeDigits() {AliInfo("To ne implemented by detectors");} - virtual void MakeRecParticles() {AliInfo("To ne implemented by detectors");} - virtual void MakeRecPoints() {AliInfo("To ne implemented by detectors");} - virtual void MakeSDigits() {AliInfo("To ne implemented by detectors");} - virtual void MakeTrackSegments() {AliInfo("To ne implemented by detectors");} + virtual void MakeESDs(AliESDEvent * ) {AliInfo("To ne implemented by detectors");} + virtual void MakeHits(TObject * ) {AliInfo("To ne implemented by detectors");} + virtual void MakeDigits(TObject * ) {AliInfo("To ne implemented by detectors");} + // virtual void MakeRecParticles(TClonesArray * ) {AliInfo("To ne implemented by detectors");} + virtual void MakeRecPoints(TTree * ) {AliInfo("To ne implemented by detectors");} + virtual void MakeSDigits(TObject * ) {AliInfo("To ne implemented by detectors");} + //virtual void MakeTrackSegments(TTree * ) {AliInfo("To ne implemented by detectors");} TFile * fOutput ; //! output root file TDirectory * fDetectorDir ; //! directory for the given detector in the file - TObject * fData ; //! data container static TString fDetectorDirName ; //! detector directory name in the quality assurance data file ClassDef(AliQualAssDataMaker,1) // description diff --git a/STEER/AliReconstruction.cxx b/STEER/AliReconstruction.cxx index f98c6dd8d46..6e89804827a 100644 --- a/STEER/AliReconstruction.cxx +++ b/STEER/AliReconstruction.cxx @@ -574,7 +574,6 @@ Bool_t AliReconstruction::Run(const char* input) if (!gGeoManager) if (fStopOnError) return kFALSE; } - AliCDBManager* man = AliCDBManager::Instance(); if (!MisalignGeometry(fLoadAlignData)) if (fStopOnError) return kFALSE; // local reconstruction @@ -670,16 +669,6 @@ Bool_t AliReconstruction::Run(const char* input) if (fRawReader) fRawReader->RewindEvents(); TString detStr(fFillESD) ; -// initialises quality assurance for ESDs - for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { - if (!IsSelected(fgkDetectorName[iDet], detStr)) - continue; - AliQualAssDataMaker * qadm = GetQualAssDataMaker(iDet); - if (!qadm) - continue; - qadm->Init(AliQualAss::kESDS) ; - } - ProcInfo_t ProcInfo; gSystem->GetProcInfo(&ProcInfo); AliInfo(Form("Current memory usage %d %d", ProcInfo.fMemResident, ProcInfo.fMemVirtual)); @@ -867,8 +856,8 @@ Bool_t AliReconstruction::Run(const char* input) if (!IsSelected(fgkDetectorName[iDet], detStr)) continue; AliQualAssDataMaker * qadm = GetQualAssDataMaker(iDet); - if (!qadm) - continue; + if (!qadm) continue; + qadm->Finish(AliQualAss::kRECPOINTS); qadm->Finish(AliQualAss::kESDS) ; } @@ -919,49 +908,49 @@ Bool_t AliReconstruction::RunLocalReconstruction(const TString& detectors) AliCodeTimerAuto("") - AliCDBManager* man = AliCDBManager::Instance(); - Bool_t origCache = man->GetCacheFlag(); + // AliCDBManager* man = AliCDBManager::Instance(); +// Bool_t origCache = man->GetCacheFlag(); - TString detStr = detectors; - for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { - if (!IsSelected(fgkDetectorName[iDet], detStr)) continue; - AliReconstructor* reconstructor = GetReconstructor(iDet); - if (!reconstructor) continue; - if (reconstructor->HasLocalReconstruction()) continue; +// TString detStr = detectors; +// for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { +// if (!IsSelected(fgkDetectorName[iDet], detStr)) continue; +// AliReconstructor* reconstructor = GetReconstructor(iDet); +// if (!reconstructor) continue; +// if (reconstructor->HasLocalReconstruction()) continue; - AliCodeTimerStart(Form("running reconstruction for %s", fgkDetectorName[iDet])); - AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet])); +// AliCodeTimerStart(Form("running reconstruction for %s", fgkDetectorName[iDet])); +// AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet])); - AliCodeTimerStart(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet])); - AliInfo(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet])); +// AliCodeTimerStart(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet])); +// AliInfo(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet])); - man->SetCacheFlag(kTRUE); - TString calibPath = Form("%s/Calib/*", fgkDetectorName[iDet]); - man->GetAll(calibPath); // entries are cached! +// man->SetCacheFlag(kTRUE); +// TString calibPath = Form("%s/Calib/*", fgkDetectorName[iDet]); +// man->GetAll(calibPath); // entries are cached! - AliCodeTimerStop(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet])); +// AliCodeTimerStop(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet])); - if (fRawReader) { - fRawReader->RewindEvents(); - reconstructor->Reconstruct(fRunLoader, fRawReader); - } else { - reconstructor->Reconstruct(fRunLoader); - } +// if (fRawReader) { +// fRawReader->RewindEvents(); +// reconstructor->Reconstruct(fRunLoader, fRawReader); +// } else { +// reconstructor->Reconstruct(fRunLoader); +// } - AliCodeTimerStop(Form("running reconstruction for %s", fgkDetectorName[iDet])); +// AliCodeTimerStop(Form("running reconstruction for %s", fgkDetectorName[iDet])); - // unload calibration data - man->UnloadFromCache(calibPath); - //man->ClearCache(); - } +// // unload calibration data +// man->UnloadFromCache(calibPath); +// //man->ClearCache(); +// } - man->SetCacheFlag(origCache); +// man->SetCacheFlag(origCache); - if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) { - AliError(Form("the following detectors were not found: %s", - detStr.Data())); - if (fStopOnError) return kFALSE; - } +// if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) { +// AliError(Form("the following detectors were not found: %s", +// detStr.Data())); +// if (fStopOnError) return kFALSE; +// } return kTRUE; } @@ -979,6 +968,10 @@ Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors) AliReconstructor* reconstructor = GetReconstructor(iDet); if (!reconstructor) continue; AliLoader* loader = fLoader[iDet]; + if (!loader) { + AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet])); + continue; + } // conversion of digits if (fRawReader && reconstructor->HasDigitConversion()) { @@ -996,7 +989,6 @@ Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors) } // local reconstruction - if (!reconstructor->HasLocalReconstruction()) continue; AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet])); AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet])); loader->LoadRecPoints("update"); @@ -1016,6 +1008,15 @@ Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors) } loader->UnloadDigits(); } + + AliQualAssDataMaker * qadm = GetQualAssDataMaker(iDet); + if (qadm) { + AliCodeTimerStart(Form("running quality assurance data maker for %s", fgkDetectorName[iDet])); + AliInfo(Form("running quality assurance data maker for %s", fgkDetectorName[iDet])); + qadm->Exec(AliQualAss::kRECPOINTS, clustersTree) ; + AliCodeTimerStop(Form("running quality assurance data maker for %s", fgkDetectorName[iDet])); + } + loader->WriteRecPoints("OVERWRITE"); loader->UnloadRecPoints(); } @@ -1108,7 +1109,7 @@ Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd) TString detName = fgkDetectorName[iDet]; AliDebug(1, Form("%s HLT tracking", detName.Data())); reconstructor->SetOption(detName.Data()); - AliTracker *tracker = reconstructor->CreateTracker(fRunLoader); + AliTracker *tracker = reconstructor->CreateTracker(); if (!tracker) { AliWarning(Form("couldn't create a HLT tracker for %s", detName.Data())); if (fStopOnError) return kFALSE; @@ -1163,7 +1164,7 @@ Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd) TString detName = fgkDetectorName[iDet]; AliDebug(1, Form("%s tracking", detName.Data())); - AliTracker *tracker = reconstructor->CreateTracker(fRunLoader); + AliTracker *tracker = reconstructor->CreateTracker(); if (!tracker) { AliWarning(Form("couldn't create a tracker for %s", detName.Data())); return kFALSE; @@ -1211,8 +1212,11 @@ Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd) AliInfo("running tracking"); //Fill the ESD with the T0 info (will be used by the TOF) - if (fReconstructor[11]) - GetReconstructor(11)->FillESD(fRunLoader, esd); + if (fReconstructor[11] && fLoader[11]) { + fLoader[11]->LoadRecPoints("READ"); + TTree *treeR = fLoader[11]->TreeR(); + GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd); + } // pass 1: TPC + ITS inwards for (Int_t iDet = 1; iDet >= 0; iDet--) { @@ -1238,7 +1242,6 @@ Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd) } // preliminary PID in TPC needed by the ITS tracker if (iDet == 1) { - GetReconstructor(1)->FillESD(fRunLoader, esd); GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd); AliESDpid::MakePID(esd); } @@ -1277,7 +1280,6 @@ Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd) } // updated PID in TPC needed by the ITS tracker -MI if (iDet == 1) { - GetReconstructor(1)->FillESD(fRunLoader, esd); GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd); AliESDpid::MakePID(esd); } @@ -1367,7 +1369,7 @@ Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors) if (!ReadESD(esd, fgkDetectorName[iDet])) { AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet])); TTree* clustersTree = NULL; - if (reconstructor->HasLocalReconstruction() && fLoader[iDet]) { + if (fLoader[iDet]) { fLoader[iDet]->LoadRecPoints("read"); clustersTree = fLoader[iDet]->TreeR(); if (!clustersTree) { @@ -1392,15 +1394,10 @@ Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors) reconstructor->FillESD(digitsTree, clustersTree, esd); if (fLoader[iDet]) fLoader[iDet]->UnloadDigits(); } - if (reconstructor->HasLocalReconstruction() && fLoader[iDet]) { + if (fLoader[iDet]) { fLoader[iDet]->UnloadRecPoints(); } - if (fRawReader) { - reconstructor->FillESD(fRunLoader, fRawReader, esd); - } else { - reconstructor->FillESD(fRunLoader, esd); - } if (fCheckPointLevel > 2) WriteESD(esd, fgkDetectorName[iDet]); } } @@ -1648,7 +1645,7 @@ AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet) if (reconstructor) { TObject* obj = fOptions.FindObject(detName.Data()); if (obj) reconstructor->SetOption(obj->GetTitle()); - reconstructor->Init(fRunLoader); + reconstructor->Init(); fReconstructor[iDet] = reconstructor; } @@ -1702,7 +1699,7 @@ Bool_t AliReconstruction::CreateVertexer() fVertexer = NULL; AliReconstructor* itsReconstructor = GetReconstructor(0); if (itsReconstructor) { - fVertexer = itsReconstructor->CreateVertexer(fRunLoader); + fVertexer = itsReconstructor->CreateVertexer(); } if (!fVertexer) { AliWarning("couldn't create a vertexer for ITS"); @@ -1733,7 +1730,7 @@ Bool_t AliReconstruction::CreateTrackers(const TString& detectors) } - fTracker[iDet] = reconstructor->CreateTracker(fRunLoader); + fTracker[iDet] = reconstructor->CreateTracker(); if (!fTracker[iDet] && (iDet < 7)) { AliWarning(Form("couldn't create a tracker for %s", detName.Data())); if (fStopOnError) return kFALSE; @@ -2700,48 +2697,12 @@ AliQualAssDataMaker * AliReconstruction::GetQualAssDataMaker(Int_t iDet) qadm = (AliQualAssDataMaker *) pluginHandler->ExecPlugin(0); } if (qadm) { - // TObject* obj = fOptions.FindObject(detName.Data()); - // if (obj) reconstructor->SetOption(obj->GetTitle()); + AliInfo(Form("Initializing quality assurance data maker for %s", fgkDetectorName[iDet])); + qadm->Init(AliQualAss::kRECPOINTS); + qadm->Init(AliQualAss::kESDS) ; fQualAssDataMaker[iDet] = qadm; } - // get or create the loader - fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader"); - if (!fLoader[iDet]) { - AliConfig::Instance() - ->CreateDetectorFolders(fRunLoader->GetEventFolder(), - detName, detName); - // first check if a plugin is defined for the loader - pluginHandler = - pluginManager->FindHandler("AliLoader", detName); - // if not, add a plugin for it - if (!pluginHandler) { - TString loaderName = "Ali" + detName + "Loader"; - AliDebug(1, Form("defining plugin for %s", loaderName.Data())); - pluginManager->AddHandler("AliLoader", detName, - loaderName, detName + "base", - loaderName + "(const char*, TFolder*)"); - pluginHandler = pluginManager->FindHandler("AliLoader", detName); - } - if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) { - fLoader[iDet] = - (AliLoader*) pluginHandler->ExecPlugin(2, detName.Data(), - fRunLoader->GetEventFolder()); - } - if (!fLoader[iDet]) { // use default loader - fLoader[iDet] = new AliLoader(detName, fRunLoader->GetEventFolder()); - } - if (!fLoader[iDet]) { - AliWarning(Form("couldn't get loader for %s", detName.Data())); - if (fStopOnError) return NULL; - } else { - fRunLoader->AddLoader(fLoader[iDet]); - fRunLoader->CdGAFile(); - if (gFile && !gFile->IsWritable()) gFile->ReOpen("UPDATE"); - fRunLoader->Write(0, TObject::kOverwrite); - } - } - return qadm; } @@ -2761,8 +2722,7 @@ Bool_t AliReconstruction::RunQualAss(const char* detectors, AliESDEvent *& esd) AliCodeTimerStart(Form("running quality assurance data maker for %s", fgkDetectorName[iDet])); AliInfo(Form("running quality assurance data maker for %s", fgkDetectorName[iDet])); - qadm->SetData(esd) ; - qadm->Exec(AliQualAss::kESDS) ; + qadm->Exec(AliQualAss::kESDS, esd) ; AliCodeTimerStop(Form("running quality assurance data maker for %s", fgkDetectorName[iDet])); } diff --git a/STEER/AliReconstructor.cxx b/STEER/AliReconstructor.cxx index 3aa7c68eb59..a003f2ea044 100644 --- a/STEER/AliReconstructor.cxx +++ b/STEER/AliReconstructor.cxx @@ -70,24 +70,6 @@ void AliReconstructor::Reconstruct(AliRawReader* /*rawReader*/, AliError("local event reconstruction not implemented for raw data input"); } -//_____________________________________________________________________________ -void AliReconstructor::Reconstruct(AliRunLoader* /*runLoader*/) const -{ -// run the local reconstruction - - AliError("local reconstruction not implemented"); -} - -//_____________________________________________________________________________ -void AliReconstructor::Reconstruct(AliRunLoader* /*runLoader*/, - AliRawReader* /*rawReader*/) const -{ -// run the local reconstruction with raw data input - - AliError("local reconstruction not implemented for raw data input"); -} - - //_____________________________________________________________________________ void AliReconstructor::FillESD(TTree* /*digitsTree*/, TTree* /*clustersTree*/, AliESDEvent* /*esd*/) const @@ -107,26 +89,6 @@ void AliReconstructor::FillESD(AliRawReader* /*rawReader*/, FillESD((TTree*)NULL, clustersTree, esd); } -//_____________________________________________________________________________ -void AliReconstructor::FillESD(AliRunLoader* /*runLoader*/, - AliESDEvent* /*esd*/) const -{ -// fill the ESD. -// by default nothing is done - -} - -//_____________________________________________________________________________ -void AliReconstructor::FillESD(AliRunLoader* runLoader, - AliRawReader* /*rawReader*/, AliESDEvent* esd) const -{ -// fill the ESD in case of raw data input. -// by default the FillESD method for MC is called - - FillESD(runLoader, esd); -} - - //_____________________________________________________________________________ const char* AliReconstructor::GetDetectorName() const { diff --git a/STEER/AliReconstructor.h b/STEER/AliReconstructor.h index 7d62e5e54e5..518f8051506 100644 --- a/STEER/AliReconstructor.h +++ b/STEER/AliReconstructor.h @@ -15,7 +15,6 @@ #include class TTree; -class AliRunLoader; class AliRawReader; class AliVertexer; class AliTracker; @@ -27,30 +26,23 @@ public: AliReconstructor(): TObject(), fOption() {}; virtual ~AliReconstructor() {}; - virtual void Init(AliRunLoader* /*runLoader*/) {}; + virtual void Init() {}; virtual Bool_t HasDigitConversion() const {return kFALSE;}; virtual void ConvertDigits(AliRawReader* rawReader, TTree* digitsTree) const; - virtual Bool_t HasLocalReconstruction() const {return kFALSE;}; virtual void Reconstruct(TTree* digitsTree, TTree* clustersTree) const; virtual void Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const; - virtual void Reconstruct(AliRunLoader* runLoader) const; - virtual void Reconstruct(AliRunLoader* runLoader, - AliRawReader* rawReader) const; - virtual AliVertexer* CreateVertexer(AliRunLoader* /*runLoader*/) const + virtual AliVertexer* CreateVertexer() const {return NULL;} - virtual AliTracker* CreateTracker(AliRunLoader* /*runLoader*/) const + virtual AliTracker* CreateTracker() const {return NULL;} virtual void FillESD(TTree* digitsTree, TTree* clustersTree, AliESDEvent* esd) const; virtual void FillESD(AliRawReader* rawReader, TTree* clustersTree, AliESDEvent* esd) const; - virtual void FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const; - virtual void FillESD(AliRunLoader* runLoader, - AliRawReader* rawReader, AliESDEvent* esd) const; virtual const char* GetDetectorName() const; diff --git a/T0/AliT0Reconstructor.cxx b/T0/AliT0Reconstructor.cxx index e8836057e15..9ae8e7835dd 100644 --- a/T0/AliT0Reconstructor.cxx +++ b/T0/AliT0Reconstructor.cxx @@ -48,8 +48,11 @@ ClassImp(AliT0Reconstructor) AliT0Reconstructor:: AliT0Reconstructor(): AliReconstructor(), - fZposition(0) - + fZposition(0), + fParam(NULL), + fAmpLEDrec(), + fdZ_A(0), + fdZ_C(0) { AliDebug(1,"Start reconstructor "); @@ -67,8 +70,12 @@ ClassImp(AliT0Reconstructor) //____________________________________________________________________ AliT0Reconstructor::AliT0Reconstructor(const AliT0Reconstructor &r): - fZposition(0) - + AliReconstructor(r), + fZposition(0), + fParam(NULL), + fAmpLEDrec(), + fdZ_A(0), + fdZ_C(0) { // // AliT0Reconstructor copy constructor @@ -328,26 +335,16 @@ void AliT0Reconstructor::Reconstruct(AliRawReader* rawReader, TTree*recTree) con } //____________________________________________________________ -void AliT0Reconstructor::FillESD(AliRunLoader* runLoader, AliESDEvent *pESD) const +void AliT0Reconstructor::FillESD(TTree */*digitsTree*/, TTree *clustersTree, AliESDEvent *pESD) const { /*************************************************** Resonstruct digits to vertex position ****************************************************/ - - if (!runLoader) { - AliError("Reconstruct >> No run loader"); - return; - } - AliDebug(1,Form("Start FillESD T0")); - AliT0Loader* pStartLoader = (AliT0Loader*) runLoader->GetLoader("T0Loader"); - - pStartLoader->LoadRecPoints("READ"); - - TTree *treeR = pStartLoader->TreeR(); + TTree *treeR = clustersTree; AliT0RecPoint* frecpoints= new AliT0RecPoint (); if (!frecpoints) { @@ -381,8 +378,6 @@ void AliT0Reconstructor::FillESD(AliRunLoader* runLoader, AliESDEvent *pESD) con AliDebug(1,Form(" Z position %f cm, T0 %f ps",Zposition , timeStart)); - pStartLoader->UnloadRecPoints(); - } // vertex in 3 sigma diff --git a/T0/AliT0Reconstructor.h b/T0/AliT0Reconstructor.h index a26a2a0663f..5737da894d6 100644 --- a/T0/AliT0Reconstructor.h +++ b/T0/AliT0Reconstructor.h @@ -8,7 +8,6 @@ #include "AliReconstructor.h" #include "AliT0digit.h" #include "AliT0.h" -class AliRunLoader; class AliT0Reconstructor: public AliReconstructor { public: @@ -18,20 +17,13 @@ class AliT0Reconstructor: public AliReconstructor { AliT0Reconstructor& operator=(const AliT0Reconstructor&); - virtual void Reconstruct(TTree* fdigits, TTree * frecpoints) const; - // virtual void Reconstruct(TTree* , TTree * ) const {}; -// virtual void Reconstruct(TTree* , TTree * ) const {}; - - virtual void Reconstruct(AliRunLoader* , AliRawReader* ) const {}; - virtual void Reconstruct(AliRawReader* ) const {}; + virtual void Reconstruct(TTree* fdigits, TTree * frecpoints) const; virtual void Reconstruct(AliRawReader*rawReader , TTree* recTree) const; - virtual void Reconstruct(AliRunLoader* ) const {}; - virtual void FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const; - virtual void FillESD(AliRunLoader* , AliRawReader*, AliESDEvent* ) const {}; - virtual void FillESD( AliRawReader*, TTree*, AliESDEvent* ) const {}; - virtual void FillESD( TTree*, TTree*, AliESDEvent* ) const {}; - virtual Bool_t HasLocalReconstruction() const {return kTRUE;} + virtual void FillESD( AliRawReader*, TTree*clustersTree, AliESDEvent*esd ) const + {FillESD((TTree*)NULL,clustersTree,esd);} + virtual void FillESD( TTree*, TTree*, AliESDEvent* ) const; + virtual Bool_t HasDigitConversion() const {return kFALSE;} public: diff --git a/TOF/AliTOFReconstructor.cxx b/TOF/AliTOFReconstructor.cxx index 70bad529aeb..5a17ed0ffc6 100644 --- a/TOF/AliTOFReconstructor.cxx +++ b/TOF/AliTOFReconstructor.cxx @@ -25,7 +25,6 @@ #include "AliLog.h" #include "AliRawReader.h" -#include "AliRunLoader.h" #include "AliTOFClusterFinder.h" #include "AliTOFGeometry.h" @@ -92,40 +91,6 @@ AliTOFReconstructor::~AliTOFReconstructor() delete fTOFcalib; } -//_____________________________________________________________________________ - void AliTOFReconstructor::Reconstruct(AliRunLoader* runLoader) const -{ -// reconstruct clusters from digits - - AliTOFClusterFinder tofClus(runLoader, fTOFcalib); - tofClus.Load(); - for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) - { - AliDebug(2,Form("Local Event loop mode: Creating Recpoints from Digits, Event n. %i",iEvent)); - tofClus.Digits2RecPoints(iEvent); - } - tofClus.UnLoad(); - -} - -//_____________________________________________________________________________ -void AliTOFReconstructor::Reconstruct(AliRunLoader* runLoader, - AliRawReader *rawReader) const -{ -// reconstruct clusters from Raw Data - - AliTOFClusterFinder tofClus(runLoader, fTOFcalib); - tofClus.LoadClusters(); - Int_t iEvent = 0; - while (rawReader->NextEvent()) { - AliDebug(2,Form("Local Event loop mode: Creating Recpoints from Raw data, Event n. %i",iEvent)); - tofClus.Digits2RecPoints(iEvent,rawReader); - iEvent++; - } - tofClus.UnLoadClusters(); - -} - //_____________________________________________________________________________ void AliTOFReconstructor::Reconstruct(AliRawReader *rawReader, TTree *clustersTree) const @@ -160,7 +125,7 @@ void AliTOFReconstructor::Reconstruct(TTree *digitsTree, } //_____________________________________________________________________________ -AliTracker* AliTOFReconstructor::CreateTracker(AliRunLoader* /*runLoader*/) const +AliTracker* AliTOFReconstructor::CreateTracker() const { // create a TOF tracker @@ -171,37 +136,8 @@ AliTracker* AliTOFReconstructor::CreateTracker(AliRunLoader* /*runLoader*/) cons } //_____________________________________________________________________________ -void AliTOFReconstructor::FillESD(AliRunLoader* /*runLoader*/, - AliESDEvent* /*esd*/) const -{ -// nothing to be done - -} - -//_____________________________________________________________________________ -AliTOFGeometry* AliTOFReconstructor::GetTOFGeometry(AliRunLoader* runLoader) const +AliTOFGeometry* AliTOFReconstructor::GetTOFGeometry() const { -// get the TOF parameters - - AliTOFGeometry *tofGeom; - - runLoader->CdGAFile(); - TDirectory *savedir=gDirectory; - TFile *in=(TFile*)gFile; - if (!in->IsOpen()) { - AliWarning("Geometry file is not open default TOF geometry will be used"); - tofGeom = new AliTOFGeometryV5(); - } - else { - in->cd(); - tofGeom = (AliTOFGeometry*) in->Get("TOFgeometry"); - } - - savedir->cd(); - - if (!tofGeom) { - AliError("no TOF geometry available"); - return NULL; - } - return tofGeom; + // get the TOF geometry + return fTOFGeometry; } diff --git a/TOF/AliTOFReconstructor.h b/TOF/AliTOFReconstructor.h index b191bb23a54..34f42f19b43 100644 --- a/TOF/AliTOFReconstructor.h +++ b/TOF/AliTOFReconstructor.h @@ -18,7 +18,6 @@ class TTree; class AliESDEvent; class AliRawReader; -class AliRunLoader; class AliTOFGeometry; class AliTOFcalib; @@ -30,26 +29,24 @@ public: AliTOFReconstructor& operator=(const AliTOFReconstructor &source); // ass. op. virtual ~AliTOFReconstructor(); - virtual Bool_t HasLocalReconstruction() const { return kTRUE; } - virtual void Reconstruct(AliRunLoader* runLoader) const; - virtual void Reconstruct(AliRunLoader* runLoader, - AliRawReader* rawReader) const; virtual void Reconstruct(AliRawReader* rawReader, TTree* clusterTree) const; virtual void Reconstruct(TTree* digitsTree, TTree* clusterTree) const; + virtual void ConvertDigits(AliRawReader* reader, TTree* digitsTree) const; - virtual AliTracker* CreateTracker(AliRunLoader* runLoader) const; - virtual void FillESD(AliRunLoader*, AliRawReader*, AliESDEvent*) const { }; - virtual void FillESD(AliRawReader*, TTree*, AliESDEvent*) const { }; - virtual void FillESD(TTree*, TTree*, AliESDEvent*) const { }; - virtual void FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const; + + virtual AliTracker* CreateTracker() const; + + virtual void FillESD(AliRawReader*, TTree*clustersTree, AliESDEvent*esd) const + {FillESD((TTree*)NULL,clustersTree,esd);} + virtual void FillESD(TTree*, TTree*, AliESDEvent*) const {} private: AliTOFGeometry *fTOFGeometry; // pointer to TOF geometry AliTOFcalib *fTOFcalib; // pointer to TOF calib class - AliTOFGeometry* GetTOFGeometry(AliRunLoader* runLoader) const; + AliTOFGeometry* GetTOFGeometry() const; - ClassDef(AliTOFReconstructor, 1) // class for the TOF reconstruction + ClassDef(AliTOFReconstructor, 2) // class for the TOF reconstruction }; #endif diff --git a/TPC/AliTPCReconstructor.cxx b/TPC/AliTPCReconstructor.cxx index c59d414d353..780e09eb38c 100644 --- a/TPC/AliTPCReconstructor.cxx +++ b/TPC/AliTPCReconstructor.cxx @@ -67,46 +67,6 @@ AliTPCReconstructor::~AliTPCReconstructor() if (fClusterer) delete fClusterer; } -//_____________________________________________________________________________ -void AliTPCReconstructor::Reconstruct(AliRunLoader* runLoader) const -{ -// reconstruct clusters - - AliLoader* loader = runLoader->GetLoader("TPCLoader"); - if (!loader) { - Error("Reconstruct", "TPC loader not found"); - return; - } - loader->LoadRecPoints("recreate"); - loader->LoadDigits("read"); - - Int_t nEvents = runLoader->GetNumberOfEvents(); - - for (Int_t iEvent = 0; iEvent < nEvents; iEvent++) { - runLoader->GetEvent(iEvent); - - TTree* treeClusters = loader->TreeR(); - if (!treeClusters) { - loader->MakeTree("R"); - treeClusters = loader->TreeR(); - } - TTree* treeDigits = loader->TreeD(); - if (!treeDigits) { - Error("Reconstruct", "Can't get digits tree !"); - return; - } - - fClusterer->SetInput(treeDigits); - fClusterer->SetOutput(treeClusters); - fClusterer->Digits2Clusters(); - - loader->WriteRecPoints("OVERWRITE"); - } - - loader->UnloadRecPoints(); - loader->UnloadDigits(); -} - //_____________________________________________________________________________ void AliTPCReconstructor::Reconstruct(TTree* digitsTree, TTree* clustersTree) const { // single event local reconstruction @@ -116,42 +76,6 @@ void AliTPCReconstructor::Reconstruct(TTree* digitsTree, TTree* clustersTree) co fClusterer->Digits2Clusters(); } -//_____________________________________________________________________________ -void AliTPCReconstructor::Reconstruct(AliRunLoader* runLoader, - AliRawReader* rawReader) const -{ -// reconstruct clusters from raw data - - AliLoader* loader = runLoader->GetLoader("TPCLoader"); - if (!loader) { - Error("Reconstruct", "TPC loader not found"); - return; - } - loader->LoadRecPoints("recreate"); - - TString option = GetOption(); - if (option.Contains("OldRCUFormat")) - fClusterer->SetOldRCUFormat(kTRUE); - - Int_t iEvent = 0; - while (rawReader->NextEvent()) { - runLoader->GetEvent(iEvent++); - - TTree* treeClusters = loader->TreeR(); - if (!treeClusters) { - loader->MakeTree("R"); - treeClusters = loader->TreeR(); - } - - fClusterer->SetOutput(treeClusters); - fClusterer->Digits2Clusters(rawReader); - - loader->WriteRecPoints("OVERWRITE"); - } - - loader->UnloadRecPoints(); -} - //_____________________________________________________________________________ void AliTPCReconstructor::Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const { // single event local reconstruction @@ -165,7 +89,7 @@ void AliTPCReconstructor::Reconstruct(AliRawReader* rawReader, TTree* clustersTr } //_____________________________________________________________________________ -AliTracker* AliTPCReconstructor::CreateTracker(AliRunLoader* /* runLoader */) const +AliTracker* AliTPCReconstructor::CreateTracker() const { // create a TPC tracker @@ -179,7 +103,7 @@ AliTracker* AliTPCReconstructor::CreateTracker(AliRunLoader* /* runLoader */) co } //_____________________________________________________________________________ -void AliTPCReconstructor::FillESD(AliRunLoader* /*runLoader*/, +void AliTPCReconstructor::FillESD(TTree */*digitsTree*/, TTree */*clustersTree*/, AliESDEvent* esd) const { // make PID diff --git a/TPC/AliTPCReconstructor.h b/TPC/AliTPCReconstructor.h index c69c428b29c..df77a6d56fa 100644 --- a/TPC/AliTPCReconstructor.h +++ b/TPC/AliTPCReconstructor.h @@ -16,27 +16,16 @@ public: AliTPCReconstructor(); virtual ~AliTPCReconstructor(); - virtual Bool_t HasLocalReconstruction() const {return kTRUE;} - virtual void Reconstruct(AliRunLoader* runLoader) const; - virtual void Reconstruct(AliRunLoader* runLoader, - AliRawReader* rawReader) const; virtual void Reconstruct(TTree* digitsTree, TTree* clustersTree) const; virtual void Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const; - virtual AliTracker* CreateTracker(AliRunLoader* runLoader) const; - virtual void FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const; - virtual void FillESD(TTree* digitsTree, TTree* clustersTree, - AliESDEvent* esd) const { - AliReconstructor::FillESD(digitsTree,clustersTree,esd); - } - virtual void FillESD(AliRawReader* rawReader, TTree* clustersTree, - AliESDEvent* esd) const { - AliReconstructor::FillESD(rawReader,clustersTree,esd); - } - virtual void FillESD(AliRunLoader* runLoader, - AliRawReader* rawReader, AliESDEvent* esd) const { - AliReconstructor::FillESD(runLoader,rawReader,esd); - } + virtual AliTracker* CreateTracker() const; + + virtual void FillESD(TTree* /*digitsTree*/, TTree* /*clustersTree*/, + AliESDEvent* esd) const; + virtual void FillESD(AliRawReader* /*rawReader*/, TTree* /*clustersTree*/, + AliESDEvent* esd) const + {FillESD((TTree*)NULL,(TTree*)NULL,esd);} void SetRecoParam(AliTPCRecoParam * param){ fgkRecoParam = param;} static const AliTPCRecoParam* GetRecoParam(){ return fgkRecoParam;} diff --git a/VZERO/AliVZEROReconstructor.cxx b/VZERO/AliVZEROReconstructor.cxx index 3c881b3b819..1d345a8cc8c 100644 --- a/VZERO/AliVZEROReconstructor.cxx +++ b/VZERO/AliVZEROReconstructor.cxx @@ -61,7 +61,7 @@ AliVZEROReconstructor::~AliVZEROReconstructor() } //_____________________________________________________________________________ -void AliVZEROReconstructor::Init(AliRunLoader* /*runLoader*/) +void AliVZEROReconstructor::Init() { // initializer diff --git a/VZERO/AliVZEROReconstructor.h b/VZERO/AliVZEROReconstructor.h index 691c20e551b..eb252da8f08 100644 --- a/VZERO/AliVZEROReconstructor.h +++ b/VZERO/AliVZEROReconstructor.h @@ -25,21 +25,13 @@ class AliVZEROReconstructor: public AliReconstructor { public: AliVZEROReconstructor(); virtual ~AliVZEROReconstructor(); - virtual void Init(AliRunLoader* /*runLoader*/); - virtual void Reconstruct(AliRunLoader* /*runLoader*/) const { - AliError("Method not implemented"); return;}; + virtual void Init(); virtual void Reconstruct(AliRawReader* /*rawReader*/, TTree* /*clustersTree*/) const { AliError("Method not implemented"); return;}; - virtual void Reconstruct(AliRunLoader* /*runLoader*/, - AliRawReader* /*rawReader*/) const { - AliError("Method not implemented"); return;}; virtual void Reconstruct(TTree*, TTree*) const {return;}; - virtual void FillESD(AliRunLoader* /*runLoader*/, AliESDEvent* /*esd*/) const { - AliInfo("Method is not used"); return;}; - virtual void FillESD(TTree* digitsTree, TTree* /*clustersTree*/, AliESDEvent* esd) const; @@ -47,14 +39,9 @@ public: AliESDEvent* /*esd*/) const { AliError("Method not implemented"); return;}; - virtual void FillESD(AliRunLoader* /*runLoader*/, - AliRawReader* /*rawReader*/, AliESDEvent* /*esd*/) const { - AliInfo("Method is not used"); return;}; - virtual Bool_t HasDigitConversion() const { return kTRUE; } virtual void ConvertDigits(AliRawReader* rawReader, TTree* digitsTree) const; - virtual Bool_t HasLocalReconstruction() const { return kTRUE; } AliCDBStorage *SetStorage(const char* uri); AliVZEROCalibData *GetCalibData() const; -- 2.43.0