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;};
// #include <AliLog.h> // ALILOG_H
// #include <AliRun.h> // 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
//____________________________________________________________________
void
-AliFMDReconstructor::Init(AliRunLoader* /*runLoader*/)
+AliFMDReconstructor::Init()
{
// Initialize the reconstructor
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
# include <AliReconstructor.h>
#endif
+#include "AliLog.h"
+
//____________________________________________________________________
class TTree;
class TClonesArray;
class AliFMDDigit;
class AliRawReader;
-class AliRunLoader;
class AliESDEvent;
class AliESDFMD;
class TH1;
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; }
@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
@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
- 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
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
//____________________________________________________________________
#include <TArrayF.h>
#include <TObjString.h>
-#include <AliRunLoader.h>
-#include <AliHeader.h>
-#include <AliGenEventHeader.h>
#include <AliESDEvent.h>
#include <AliESDHLTtrack.h>
#include "AliHLTTrackArray.h"
#include "AliLog.h"
-#include "AliRun.h"
#include "AliITS.h"
#include "AliHLTITStracker.h"
#include "AliHLTTPCtracker.h"
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");
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 "<<slice<<endl;
- hough->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 "<<slice<<endl;
+// hough->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; i<fTracks->GetNTracks(); 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; i<fTracks->GetNTracks(); 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; i<fTracks->GetNTracks(); 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; i<fTracks->GetNTracks(); 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
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);
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;}
// 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
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
}
//____________________________________________________________________________
-void AliHMPIDQualAssDataMaker::MakeHits()
+void AliHMPIDQualAssDataMaker::MakeHits(TObject * data)
{
//fills QA histos for Hits
- TClonesArray * hits = dynamic_cast<TClonesArray*>(fData) ;
- TIter next(hits);
- AliHMPIDHit * hit ;
- while ( hit = dynamic_cast<AliHMPIDHit *>(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<TClonesArray *>(data) ;
+ if (!hits){
+ AliError("Wrong type of hits container") ;
+ } else {
+ TIter next(hits);
+ AliHMPIDHit * hit ;
+ while ( (hit = dynamic_cast<AliHMPIDHit *>(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<TObjArray*>(fData);
- for(Int_t i =0; i< chambers->GetEntries(); i++)
- {
- TClonesArray * digits = dynamic_cast<TClonesArray*>(chambers->At(i));
- fhDigChEvt->Fill(i,digits->GetEntriesFast()/(48.*80.*6.));
- TIter next(digits);
- AliHMPIDDigit * digit;
- while ( (digit = dynamic_cast<AliHMPIDDigit *>(next())) ) {
- fhDigPcEvt->Fill(10.*i+digit->Pc(),1./(48.*80.));
- fhDigQ->Fill(digit->Q());
- }
- }
+ TObjArray *chambers = dynamic_cast<TObjArray*>(data);
+ if ( !chambers) {
+ AliError("Wrong type of digits container") ;
+ } else {
+ for(Int_t i =0; i< chambers->GetEntries(); i++)
+ {
+ TClonesArray * digits = dynamic_cast<TClonesArray*>(chambers->At(i));
+ fhDigChEvt->Fill(i,digits->GetEntriesFast()/(48.*80.*6.));
+ TIter next(digits);
+ AliHMPIDDigit * digit;
+ while ( (digit = dynamic_cast<AliHMPIDDigit *>(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<TClonesArray*>(fData) ;
- AliHMPIDDigit *ref = (AliHMPIDDigit *)sdigits->At(0);
- Float_t zero = ref->GetTrack(0);
- TIter next(sdigits) ;
- AliHMPIDDigit * sdigit ;
- while ( (sdigit = dynamic_cast<AliHMPIDDigit *>(next())) ) {
- fhSDigits->Fill(sdigit->Q()) ;
- if(zero == sdigit->GetTrack(0)) continue;
- else zero == sdigit->GetTrack(0);
- }
+ TClonesArray * sdigits = dynamic_cast<TClonesArray *>(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<AliHMPIDDigit *>(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<TObjArray*>(fData);
- for(Int_t i =0; i< chambers->GetEntries(); i++)
- {
- TClonesArray * clusters = dynamic_cast<TClonesArray*>(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<AliHMPIDCluster *>(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<AliESDEvent*>(fData) ;
for(Int_t iTrk = 0 ; iTrk < esd->GetNumberOfTracks() ; iTrk++){
AliESDtrack *pTrk = esd->GetTrack(iTrk) ;
fhCkovP->Fill(pTrk->GetP(),pTrk->GetHMPIDsignal());
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
#include <AliCDBManager.h> //ctor
#include <AliESDEvent.h> //FillEsd()
#include <AliRawReader.h> //Reconstruct() for raw digits
+#include "AliHMPIDRawStream.h" //ConvertDigits()
ClassImp(AliHMPIDReconstructor)
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
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
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
pTrk->SetHMPIDpid(pid);
}//ESD tracks loop
}//FillESD()
-//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#include <AliReconstructor.h> //base class
#include "AliHMPIDTracker.h" //CreateTracker()
#include "AliHMPIDDigit.h" //Dig2Clu(), UseDig()
-#include "AliHMPIDRawStream.h" //ConvertDigits()
#include <TMatrixF.h> //UseDig()
#include <TClonesArray.h> //UseDig()
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; //
#include "Riostream.h"
#include "AliITSReconstructor.h"
#include "AliRun.h"
-#include "AliRunLoader.h"
#include "AliRawReader.h"
#include "AliITSDetTypeRec.h"
#include "AliITSgeom.h"
}
//______________________________________________________________________
-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:
}
//_____________________________________________________________________________
-AliTracker* AliITSReconstructor::CreateTracker(AliRunLoader* runLoader)const
+AliTracker* AliITSReconstructor::CreateTracker() const
{
// create a ITS tracker
}
TString selectedPIDmethod = GetOption();
- AliITSLoader *loader = (AliITSLoader*)runLoader->GetLoader("ITSLoader");
- if (!loader) {
- Error("CreateTracker", "ITS loader not found");
- }
+ AliITSReconstructor* nc = const_cast<AliITSReconstructor*>(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
}
//_____________________________________________________________________________
-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");
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;}
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
//#include <Rtypes.h>
#include <TObject.h>
+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
// Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
//-------------------------------------------------------
#include "AliITSpidESD.h"
-
+#include "AliLog.h"
class AliITSpidESD1 : public AliITSpidESD {
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
//_________________________________________________________________________
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();
}
//______________________________________________________________________
AliITSpidESD2::AliITSpidESD2(const AliITSpidESD2 &ob) :AliITSpidESD(ob),
fTracker(ob.fTracker),
-fLoader(ob.fLoader),
fSp(ob.fSp)
{
// Copy constructor
}
//_________________________________________________________________________
-Int_t AliITSpidESD2::MakePID(AliESDEvent *event)
+Int_t AliITSpidESD2::MakePID(TTree *clustersTree, 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;
delete track;
}
fTracker->UnloadClusters();
- fLoader->UnloadRecPoints();
return 0;
}
// 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
#include "AliMUONReconstructor.h"
#include "AliCDBManager.h"
-#include "AliLoader.h"
#include "AliLog.h"
-#include "AliRunLoader.h"
#include "AliMUONCalibrationData.h"
#include "AliMUONClusterFinderCOG.h"
#include "AliMUONClusterFinderMLEM.h"
//_____________________________________________________________________________
AliTracker*
-AliMUONReconstructor::CreateTracker(AliRunLoader* runLoader) const
+AliMUONReconstructor::CreateTracker() const
{
/// Create the MUONTracker object
/// The MUONTracker is passed the GetOption(), i.e. our own options
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;
}
}
-//_____________________________________________________________________________
-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
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
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
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
#include "AliESDEvent.h"
#include "AliESDMuonTrack.h"
#include "AliESDVertex.h"
-#include "AliLoader.h"
#include "AliLog.h"
#include <Riostream.h>
//_____________________________________________________________________________
-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
/// 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");
class AliCluster;
class AliESDEvent;
-class AliLoader;
class AliMUONDigitMaker;
class AliMUONGeometryTransformer;
class AliMUONTrackHitPattern;
{
public:
- AliMUONTracker(AliLoader* loader,
- const AliMUONDigitMaker* digitMaker=0,
+ AliMUONTracker(const AliMUONDigitMaker* digitMaker=0,
const AliMUONGeometryTransformer* transformer=0,
const AliMUONTriggerCircuit* triggerCircuit=0,
AliMUONTriggerChamberEff* chamberEff=0);
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)
#include <TTree.h>
#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),
//____________________________________________________________________________
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;
/* 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)
*
class TTree;
class AliPHOSGeometry;
-class AliPHOSQualAssDataMaker ;
class AliPHOSClusterizer : public TObject {
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
/* 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)
*
#include "AliCDBStorage.h"
#include "AliCDBEntry.h"
#include "AliPHOSRecoParam.h"
-#include "AliPHOSQualAssDataMaker.h"
#include "AliPHOSCalibData.h"
#include "AliPHOSReconstructor.h"
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",
#include "AliPHOSRecCpvManager.h"
#include "AliPHOSRecEmcManager.h"
#include "AliPHOSGeometry.h"
-#include "AliPHOSQualAssDataMaker.h"
#include "AliPHOSDigit.h"
ClassImp(AliPHOSClusterizerv2)
// 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();
/* 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.
*
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() ;
#include "AliConfig.h"
#include "AliPHOSPID.h"
#include "AliPHOSGetter.h"
-#include "AliPHOSQualAssDataMaker.h"
ClassImp(AliPHOSPID)
fEMCRecPoints(NULL),
fCPVRecPoints(NULL),
fTrackSegments(NULL),
- fRecParticles(NULL),
- fQADM(0x0)
+ fRecParticles(NULL)
{
// ctor
}
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) ;
}
//____________________________________________________________________________
fEMCRecPoints(pid.fEMCRecPoints),
fCPVRecPoints(pid.fCPVRecPoints),
fTrackSegments(pid.fTrackSegments),
- fRecParticles(pid.fRecParticles),
- fQADM(pid.fQADM)
+ fRecParticles(pid.fRecParticles)
{
// Copy constructor
}
fCPVRecPoints->Delete();
delete fCPVRecPoints;
}
- delete fQADM ;
}
//____________________________________________________________________________
/* 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)
*
class AliPHOSGeometry ;
class AliPHOSClusterizer ;
class AliPHOSTrackSegmentMaker ;
-class AliPHOSQualAssDataMaker ;
class AliPHOSPID : public TObject {
virtual const char * Version() const = 0;
- AliPHOSQualAssDataMaker * GetQualAssDataMaker() const { return fQADM ; }
-
protected:
AliPHOSGeometry * fGeom; //! Pointer to PHOS Geometry
private:
- AliPHOSQualAssDataMaker * fQADM ; //!Quality Assurance Data Maker
-
ClassDef(AliPHOSPID,6) // Particle Identifier algorithm (base class)
} ;
}
//____________________________________________________________________________
-void AliPHOSQualAssDataMaker::MakeESDs()
+void AliPHOSQualAssDataMaker::MakeESDs(AliESDEvent * esd)
{
// make QA data from ESDs
- AliESDEvent * esd = dynamic_cast<AliESDEvent*>(fData) ;
Int_t maxClu = esd->GetNumberOfPHOSClusters() ;
Int_t index = 0, count = 0 ;
for ( index = 0 ; index < maxClu; index++ ) {
}
//____________________________________________________________________________
-void AliPHOSQualAssDataMaker::MakeHits()
+void AliPHOSQualAssDataMaker::MakeHits(TObject * data)
{
//make QA data from Hits
- TClonesArray * hits = dynamic_cast<TClonesArray*>(fData) ;
- fhHitsMul->Fill(hits->GetEntriesFast()) ;
- TIter next(hits) ;
- AliPHOSHit * hit ;
- while ( (hit = dynamic_cast<AliPHOSHit *>(next())) ) {
- fhHits->Fill( hit->GetEnergy()) ;
- }
-}
+ TClonesArray * hits = dynamic_cast<TClonesArray *>(data) ;
+ if (!hits) {
+ AliError("Wrong type of hits container") ;
+ } else {
+ fhHitsMul->Fill(hits->GetEntriesFast()) ;
+ TIter next(hits) ;
+ AliPHOSHit * hit ;
+ while ( (hit = dynamic_cast<AliPHOSHit *>(next())) ) {
+ fhHits->Fill( hit->GetEnergy()) ;
+ }
+ }
+}
//____________________________________________________________________________
-void AliPHOSQualAssDataMaker::MakeDigits()
+void AliPHOSQualAssDataMaker::MakeDigits(TObject * data)
{
// makes data from Digits
- TClonesArray * digits = dynamic_cast<TClonesArray*>(fData) ;
- fhDigitsMul->Fill(digits->GetEntriesFast()) ;
- TIter next(digits) ;
- AliPHOSDigit * digit ;
- while ( (digit = dynamic_cast<AliPHOSDigit *>(next())) ) {
- fhDigits->Fill( digit->GetEnergy()) ;
- }
+ TClonesArray * digits = dynamic_cast<TClonesArray *>(data) ;
+ if (!digits) {
+ AliError("Wrong type of digits container") ;
+ } else {
+ fhDigitsMul->Fill(digits->GetEntriesFast()) ;
+ TIter next(digits) ;
+ AliPHOSDigit * digit ;
+ while ( (digit = dynamic_cast<AliPHOSDigit *>(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<TClonesArray*>(fData) ;
- fhRecParticlesMul->Fill(recparticles->GetEntriesFast()) ;
- TIter next(recparticles) ;
- AliPHOSRecParticle * recparticle ;
- while ( (recparticle = dynamic_cast<AliPHOSRecParticle *>(next())) ) {
- fhRecParticles->Fill( recparticle->Energy()) ;
- }
-}
+// TClonesArray * recparticles = dynamic_cast<TClonesArray*>(fData) ;
+// fhRecParticlesMul->Fill(recparticles->GetEntriesFast()) ;
+// TIter next(recparticles) ;
+// AliPHOSRecParticle * recparticle ;
+// while ( (recparticle = dynamic_cast<AliPHOSRecParticle *>(next())) ) {
+// fhRecParticles->Fill( recparticle->Energy()) ;
+// }
+// }
//____________________________________________________________________________
-void AliPHOSQualAssDataMaker::MakeRecPoints()
+void AliPHOSQualAssDataMaker::MakeRecPoints(TTree * clustersTree)
{
- // makes data from RecPoints
- TObjArray * recpoints = dynamic_cast<TObjArray*>(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<AliPHOSEmcRecPoint *>(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<AliPHOSCpvRecPoint *>(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<TClonesArray*>(fData) ;
- fhSDigitsMul->Fill(sdigits->GetEntriesFast()) ;
- TIter next(sdigits) ;
- AliPHOSDigit * sdigit ;
- while ( (sdigit = dynamic_cast<AliPHOSDigit *>(next())) ) {
- fhSDigits->Fill( sdigit->GetEnergy()) ;
- }
+
+ TClonesArray * sdigits = dynamic_cast<TClonesArray *>(data) ;
+ if (!sdigits) {
+ AliError("Wrong type of sdigits container") ;
+ } else {
+ fhSDigitsMul->Fill(sdigits->GetEntriesFast()) ;
+ TIter next(sdigits) ;
+ AliPHOSDigit * sdigit ;
+ while ( (sdigit = dynamic_cast<AliPHOSDigit *>(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<TClonesArray*>(fData) ;
+// TClonesArray * tracksegments = dynamic_cast<TClonesArray*>(fData) ;
- fhTrackSegmentsMul->Fill(tracksegments->GetEntriesFast()) ;
- TIter next(tracksegments) ;
- AliPHOSTrackSegment * ts ;
- while ( (ts = dynamic_cast<AliPHOSTrackSegment *>(next())) ) {
- fhTrackSegments->Fill( ts->GetCpvDistance()) ;
- }
-}
+// fhTrackSegmentsMul->Fill(tracksegments->GetEntriesFast()) ;
+// TIter next(tracksegments) ;
+// AliPHOSTrackSegment * ts ;
+// while ( (ts = dynamic_cast<AliPHOSTrackSegment *>(next())) ) {
+// fhTrackSegments->Fill( ts->GetCpvDistance()) ;
+// }
+// }
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
// --- AliRoot header files ---
#include "AliLog.h"
-#include "AliPHOSQualAssDataMaker.h"
#include "AliESDEvent.h"
#include "AliESDCaloCluster.h"
#include "AliPHOSReconstructor.h"
// 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);
else
tsm->Clusters2TrackSegments("") ;
- tsm->GetQualAssDataMaker()->SetData(tsm->GetTrackSegments()) ;
- tsm->GetQualAssDataMaker()->Exec(AliQualAss::kTRACKSEGMENTS) ;
-
pid->SetInput(clustersTree, tsm->GetTrackSegments()) ;
pid->SetESD(esd) ;
if ( Debug() )
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
}
}
-AliTracker* AliPHOSReconstructor::CreateTracker(AliRunLoader* /* runLoader */) const
+AliTracker* AliPHOSReconstructor::CreateTracker() const
{
// creates the PHOS tracker
return new AliPHOSTracker();
/* 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)
*
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;
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
};
/* 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)
*
// 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
/* 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)
*
// --- AliRoot header files ---
#include "AliPHOSTrackSegmentMaker.h"
-#include "AliPHOSQualAssDataMaker.h"
+#include "AliLog.h"
ClassImp( AliPHOSTrackSegmentMaker)
AliPHOSTrackSegmentMaker:: AliPHOSTrackSegmentMaker() :
TObject(),
fESD(0),
- fQADM(0x0),
fGeom(0),
fEMCRecPoints(0),
fCPVRecPoints(0)
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)
//Remove this from the parental task before destroying
// if(AliPHOSGetter::Instance()->PhosLoader())
// AliPHOSGetter::Instance()->PhosLoader()->CleanTracker();
- delete fQADM ;
if (fEMCRecPoints) {
fEMCRecPoints->Delete();
delete fEMCRecPoints;
/* 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)
*
// --- AliRoot header files ---
class AliPHOSGeometry ;
class AliESDEvent ;
-class AliPHOSQualAssDataMaker ;
class AliPHOSTrackSegmentMaker : public TObject {
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
#include "Riostream.h"
#include "AliPMDReconstructor.h"
-#include "AliRunLoader.h"
#include "AliRun.h"
#include "AliPMDClusterFinder.h"
#include "AliPMDtracker.h"
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,
}
-// ------------------------------------------------------------------------ //
-
-//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
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
// --- ROOT system ---
#include <TSystem.h>
#include <TFile.h>
+#include <TClonesArray.h>
+#include <TTree.h>
// --- Standard library ---
// --- AliRoot header files ---
#include "AliLog.h"
#include "AliQualAssDataMaker.h"
+#include "AliESDEvent.h"
ClassImp(AliQualAssDataMaker)
AliQualAssDataMaker::AliQualAssDataMaker(const char * name, const char * title) :
TNamed(name, title),
fOutput(0x0),
- fDetectorDir(0x0),
- fData(0x0)
+ fDetectorDir(0x0)
{
// ctor
TString tmp(GetName()) ;
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() ;
}
//____________________________________________________________________________
-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)
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<TTree *>(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<TTree *>(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<TTree *>(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<AliESDEvent *>(data) ;
+ if (esd)
+ MakeESDs(esd) ;
+ else
+ AliError("Wrong type of esd container") ;
break ;
}
}
#include <TNamed.h>
class TFile;
class TDirectory;
+class TObject;
+class TTree;
+class AliESDEvent;
// --- Standard library ---
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");}
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
if (!gGeoManager) if (fStopOnError) return kFALSE;
}
- AliCDBManager* man = AliCDBManager::Instance();
if (!MisalignGeometry(fLoadAlignData)) if (fStopOnError) return kFALSE;
// local reconstruction
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));
if (!IsSelected(fgkDetectorName[iDet], detStr))
continue;
AliQualAssDataMaker * qadm = GetQualAssDataMaker(iDet);
- if (!qadm)
- continue;
+ if (!qadm) continue;
+ qadm->Finish(AliQualAss::kRECPOINTS);
qadm->Finish(AliQualAss::kESDS) ;
}
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;
}
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()) {
}
// 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");
}
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();
}
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;
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;
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--) {
}
// 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);
}
}
// 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);
}
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) {
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]);
}
}
if (reconstructor) {
TObject* obj = fOptions.FindObject(detName.Data());
if (obj) reconstructor->SetOption(obj->GetTitle());
- reconstructor->Init(fRunLoader);
+ reconstructor->Init();
fReconstructor[iDet] = reconstructor;
}
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");
}
- 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;
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;
}
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]));
}
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
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
{
#include <TString.h>
class TTree;
-class AliRunLoader;
class AliRawReader;
class AliVertexer;
class AliTracker;
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;
ClassImp(AliT0Reconstructor)
AliT0Reconstructor:: AliT0Reconstructor(): AliReconstructor(),
- fZposition(0)
-
+ fZposition(0),
+ fParam(NULL),
+ fAmpLEDrec(),
+ fdZ_A(0),
+ fdZ_C(0)
{
AliDebug(1,"Start reconstructor ");
//____________________________________________________________________
AliT0Reconstructor::AliT0Reconstructor(const AliT0Reconstructor &r):
- fZposition(0)
-
+ AliReconstructor(r),
+ fZposition(0),
+ fParam(NULL),
+ fAmpLEDrec(),
+ fdZ_A(0),
+ fdZ_C(0)
{
//
// AliT0Reconstructor copy constructor
}
//____________________________________________________________
-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) {
AliDebug(1,Form(" Z position %f cm, T0 %f ps",Zposition , timeStart));
- pStartLoader->UnloadRecPoints();
-
} // vertex in 3 sigma
#include "AliReconstructor.h"
#include "AliT0digit.h"
#include "AliT0.h"
-class AliRunLoader;
class AliT0Reconstructor: public AliReconstructor {
public:
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:
#include "AliLog.h"
#include "AliRawReader.h"
-#include "AliRunLoader.h"
#include "AliTOFClusterFinder.h"
#include "AliTOFGeometry.h"
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
}
//_____________________________________________________________________________
-AliTracker* AliTOFReconstructor::CreateTracker(AliRunLoader* /*runLoader*/) const
+AliTracker* AliTOFReconstructor::CreateTracker() const
{
// create a TOF tracker
}
//_____________________________________________________________________________
-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;
}
class AliESDEvent;
class AliRawReader;
-class AliRunLoader;
class AliTOFGeometry;
class AliTOFcalib;
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
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
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
}
//_____________________________________________________________________________
-AliTracker* AliTPCReconstructor::CreateTracker(AliRunLoader* /* runLoader */) const
+AliTracker* AliTPCReconstructor::CreateTracker() const
{
// create a TPC tracker
}
//_____________________________________________________________________________
-void AliTPCReconstructor::FillESD(AliRunLoader* /*runLoader*/,
+void AliTPCReconstructor::FillESD(TTree */*digitsTree*/, TTree */*clustersTree*/,
AliESDEvent* esd) const
{
// make PID
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;}
}
//_____________________________________________________________________________
-void AliVZEROReconstructor::Init(AliRunLoader* /*runLoader*/)
+void AliVZEROReconstructor::Init()
{
// initializer
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;
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;