Important changes to the reconstructor classes. Complete elimination of the run-loade...
authorcvetan <cvetan@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 26 Sep 2007 14:22:18 +0000 (14:22 +0000)
committercvetan <cvetan@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 26 Sep 2007 14:22:18 +0000 (14:22 +0000)
48 files changed:
EMCAL/AliEMCALReconstructor.h
FMD/AliFMDReconstructor.cxx
FMD/AliFMDReconstructor.h
HLT/src/AliHLTReconstructor.cxx
HLT/src/AliHLTReconstructor.h
HMPID/AliHMPIDQualAssDataMaker.cxx
HMPID/AliHMPIDQualAssDataMaker.h
HMPID/AliHMPIDReconstructor.cxx
HMPID/AliHMPIDReconstructor.h
ITS/AliITSReconstructor.cxx
ITS/AliITSReconstructor.h
ITS/AliITSpidESD.h
ITS/AliITSpidESD1.h
ITS/AliITSpidESD2.cxx
ITS/AliITSpidESD2.h
MUON/AliMUONReconstructor.cxx
MUON/AliMUONReconstructor.h
MUON/AliMUONTracker.cxx
MUON/AliMUONTracker.h
PHOS/AliPHOSClusterizer.cxx
PHOS/AliPHOSClusterizer.h
PHOS/AliPHOSClusterizerv1.cxx
PHOS/AliPHOSClusterizerv2.cxx
PHOS/AliPHOSDigitizer.cxx
PHOS/AliPHOSPID.cxx
PHOS/AliPHOSPID.h
PHOS/AliPHOSQualAssDataMaker.cxx
PHOS/AliPHOSQualAssDataMaker.h
PHOS/AliPHOSReconstructor.cxx
PHOS/AliPHOSReconstructor.h
PHOS/AliPHOSSDigitizer.cxx
PHOS/AliPHOSTrackSegmentMaker.cxx
PHOS/AliPHOSTrackSegmentMaker.h
PMD/AliPMDReconstructor.cxx
PMD/AliPMDReconstructor.h
STEER/AliQualAssDataMaker.cxx
STEER/AliQualAssDataMaker.h
STEER/AliReconstruction.cxx
STEER/AliReconstructor.cxx
STEER/AliReconstructor.h
T0/AliT0Reconstructor.cxx
T0/AliT0Reconstructor.h
TOF/AliTOFReconstructor.cxx
TOF/AliTOFReconstructor.h
TPC/AliTPCReconstructor.cxx
TPC/AliTPCReconstructor.h
VZERO/AliVZEROReconstructor.cxx
VZERO/AliVZEROReconstructor.h

index 994f56a..77bf6fa 100644 (file)
@@ -41,9 +41,9 @@ public:
   using AliReconstructor::FillESD;
   virtual void FillESD(TTree* digitsTree, TTree* clustersTree, 
                       AliESDEvent* esd) const;
-  AliTracker*  CreateTracker         (AliRunLoader*                      )const{return new AliEMCALTracker;} 
+  AliTracker*  CreateTracker () const 
+  {return new AliEMCALTracker;} 
   using AliReconstructor::Reconstruct;
-  virtual Bool_t             HasLocalReconstruction() const {return kTRUE;};
   virtual void Reconstruct(TTree* digitsTree, TTree* clustersTree) const;
 
   virtual Bool_t             HasDigitConversion() const {return kTRUE;};
index 85c6dfe..fb9a17d 100644 (file)
@@ -35,8 +35,6 @@
 // #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
@@ -140,7 +138,7 @@ AliFMDReconstructor::~AliFMDReconstructor()
 
 //____________________________________________________________________
 void 
-AliFMDReconstructor::Init(AliRunLoader* /*runLoader*/) 
+AliFMDReconstructor::Init() 
 {
   // Initialize the reconstructor 
 
@@ -504,80 +502,6 @@ AliFMDReconstructor::FillESD(TTree*  /* digitsTree */,
   if (fDiagAll)   fDiagAll->Reset();
 }
 
-
-//____________________________________________________________________
-void 
-AliFMDReconstructor::Reconstruct(AliRawReader* reader,
-                                TTree* /* ctree */) const 
-{
-  // Cannot be used.  See member function with same name but with 2
-  // TTree arguments.   Make sure you do local reconstrucion 
-  AliFMDDebug(2, ("Calling FillESD with loader and tree"));
-#if 1
-  TClonesArray* array = new TClonesArray("AliFMDDigit");
-  // if (ctree) ctree->Branch("FMD", &array);
-  AliFMDRawReader rawRead(reader, 0);
-  rawRead.ReadAdcs(array);
-  // ctree->Fill();
-  // Question - how to get the digits in this case? 
-  ProcessDigits(array);
-  // Reconstruct(array, ctree);
-  array->Delete();
-  delete array;
-#else
-  AliError("MayNotUse");
-#endif
-}
-//____________________________________________________________________
-void 
-AliFMDReconstructor::Reconstruct(AliRunLoader*) const 
-{
-  // Cannot be used.  See member function with same name but with 2
-  // TTree arguments.   Make sure you do local reconstrucion 
-  AliFMDDebug(2, ("Calling FillESD with loader"));
-  AliError("MayNotUse");
-}
-//____________________________________________________________________
-void 
-AliFMDReconstructor::Reconstruct(AliRunLoader*, AliRawReader*) const 
-{
-  // Cannot be used.  See member function with same name but with 2
-  // TTree arguments.   Make sure you do local reconstrucion 
-  AliFMDDebug(2, ("Calling FillESD with loader and raw reader"));
-  AliError("MayNotUse");
-}
-//____________________________________________________________________
-void 
-AliFMDReconstructor::FillESD(AliRawReader*,TTree*,AliESDEvent* esd) const 
-{
-  // Cannot be used.  See member function with same name but with 2
-  // TTree arguments.   Make sure you do local reconstrucion 
-  AliFMDDebug(2, ("Calling FillESD with raw reader, tree, and ESD"));
-#if 1
-  FillESD((TTree*)0, (TTree*)0, esd);
-#else
-  AliError("MayNotUse");
-#endif
-}
-//____________________________________________________________________
-void 
-AliFMDReconstructor::FillESD(AliRunLoader*,AliESDEvent*) const
-{
-  // Cannot be used.  See member function with same name but with 2
-  // TTree arguments.   Make sure you do local reconstrucion 
-  AliFMDDebug(2, ("Calling FillESD with loader and ESD"));
-  AliError("MayNotUse");
-}
-//____________________________________________________________________
-void 
-AliFMDReconstructor::FillESD(AliRunLoader*,AliRawReader*,AliESDEvent*) const 
-{
-  // Cannot be used.  See member function with same name but with 2
-  // TTree arguments.   Make sure you do local reconstrucion 
-  AliFMDDebug(2, ("Calling FillESD with loader, raw reader, and ESD"));
-  AliError("MayNotUse");
-}
-
 //____________________________________________________________________
 //
 // EOF
index 6c5ca95..f93a204 100644 (file)
 # include <AliReconstructor.h>
 #endif
 
+#include "AliLog.h"
+
 //____________________________________________________________________
 class TTree;
 class TClonesArray;
 class AliFMDDigit;
 class AliRawReader;
-class AliRunLoader;
 class AliESDEvent;
 class AliESDFMD;
 class TH1;
@@ -60,7 +61,7 @@ public:
       initialized (meaning that the calibration parameters is read
       from CDB).
   */
-  virtual void   Init(AliRunLoader* /*runLoader*/);
+  virtual void   Init();
   /** Flag that we can convert raw data into digits. 
       @return always @c true */
   virtual Bool_t HasDigitConversion() const { return kTRUE; }
@@ -71,9 +72,6 @@ public:
       @param reader     Raw reader. 
       @param digitsTree Tree to store read digits in. */
   virtual void   ConvertDigits(AliRawReader* reader, TTree* digitsTree) const;
-  /** Flag that we can do one-event reconstruction. 
-      @return always @c true  */
-  virtual Bool_t HasLocalReconstruction() const { return kTRUE; }
   /** Reconstruct one event from the digits passed in @a digitsTree.
       The member function creates AliFMDRecPoint objects and stores
       them on the output tree @a clusterTree.  An FMD ESD object is
@@ -82,14 +80,8 @@ public:
       @param digitsTree  Tree holding the digits of this event
       @param clusterTree Tree to store AliFMDRecPoint objects in. */
   virtual void   Reconstruct(TTree* digitsTree, TTree* clusterTree) const;
-  /** Reconstruct one event from the raw data, via a digits read using
-      @a reader. The member function @e does @e not create
-      AliFMDRecPoint objects, and the read AliFMDDigit objects are not
-      stored. An FMD ESD object is created in parallel. 
-      @todo Make sure we get a vertex. 
-      @param reader      Raw data reader
-      @param clusterTree Tree to store AliFMDRecPoint objects in (not used). */
-  void Reconstruct(AliRawReader* reader, TTree* clusterTree) const;
+  virtual void   Reconstruct(AliRawReader *, TTree*) const
+  {AliError("Method is not used");}
   /** Put in the ESD data, the FMD ESD data.  The object created by
       the Reconstruct member function is copied to the ESD object. 
       @param digitsTree   Tree of digits for this event - not used
@@ -97,16 +89,10 @@ public:
       - not used. 
       @param esd ESD object to store data in. 
   */
+  virtual void   FillESD(AliRawReader*, TTree*clusterTree, AliESDEvent*esd) const
+  {FillESD((TTree*)NULL,clusterTree,esd);}
   virtual void   FillESD(TTree* digitsTree, TTree* clusterTree, 
                         AliESDEvent* esd) const;
-  /** Put in the ESD data, the FMD ESD data.  The object created by
-      the Reconstruct member function is copied to the ESD object. 
-      @param reader       Raw data reader - not used.
-      @param clusterTree  Tree of reconstructed points for this event
-                          - not used. 
-      @param esd          ESD object to store data in. */
-  void FillESD(AliRawReader* reader, TTree* clusterTree, 
-              AliESDEvent* esd) const;
   /** Not used */
   virtual void   SetESD(AliESDEvent* esd) { fESD = esd; }
   /** Set the noise factor 
@@ -207,18 +193,8 @@ protected:
   TH1*                  fDiagStep4;    // Diagnostics histogram
   TH1*                  fDiagAll;      // Diagnostics histogram
 private:
-  /** Hide base classes unused function */
-  void Reconstruct(AliRunLoader*) const;
-  /** Hide base classes unused function */
-  void Reconstruct(AliRunLoader*, AliRawReader*) const;
-  // /** Hide base classes unused function */
-  // void FillESD(AliRawReader*, TTree*, AliESDEvent*) const;
-  /** Hide base classes unused function */
-  void FillESD(AliRunLoader*, AliESDEvent*) const;
-  /** Hide base classes unused function */
-  void FillESD(AliRunLoader*, AliRawReader*, AliESDEvent*) const;
-  
-  ClassDef(AliFMDReconstructor, 2)  // class for the FMD reconstruction
+   
+  ClassDef(AliFMDReconstructor, 3)  // class for the FMD reconstruction
 }; 
 #endif
 //____________________________________________________________________
index f26c4bb..ef331b3 100644 (file)
@@ -12,9 +12,6 @@
 #include <TArrayF.h>
 #include <TObjString.h>
 
-#include <AliRunLoader.h>
-#include <AliHeader.h>
-#include <AliGenEventHeader.h>
 #include <AliESDEvent.h>
 #include <AliESDHLTtrack.h>
 
@@ -31,7 +28,6 @@
 #include "AliHLTTrackArray.h"
 
 #include "AliLog.h"
-#include "AliRun.h"
 #include "AliITS.h"
 #include "AliHLTITStracker.h"
 #include "AliHLTTPCtracker.h"
@@ -126,14 +122,9 @@ AliHLTReconstructor::~AliHLTReconstructor()
   fpSystem=NULL;
 }
 
-void AliHLTReconstructor::Init(AliRunLoader* runLoader)
+void AliHLTReconstructor::Init()
 {
   // init the reconstructor
-  if(!runLoader) {
-    AliError("Missing RunLoader! 0x0");
-    return;
-  }
-
   if (!fpSystem) fpSystem=new AliHLTSystem;
   if (!fpSystem) {
     AliError("can not create AliHLTSystem object");
@@ -188,258 +179,253 @@ void AliHLTReconstructor::Init(AliRunLoader* runLoader)
     AliError("error while loading HLT libraries");
     return;
   }
-  if (!fpSystem->CheckStatus(AliHLTSystem::kReady) &&
-      (fpSystem->Configure(runLoader))<0) {
-    AliError("error during HLT system configuration");
-    return;
-  }
-}
-
-void AliHLTReconstructor::Reconstruct(AliRunLoader* runLoader) const
-{
-  // reconstruction of simulated data
-  Reconstruct(runLoader, NULL);
+  // No run-loaders anymore...needs a fix
+//   if (!fpSystem->CheckStatus(AliHLTSystem::kReady) &&
+//       (fpSystem->Configure(runLoader))<0) {
+//     AliError("error during HLT system configuration");
+//     return;
+//   }
 }
 
-void AliHLTReconstructor::Reconstruct(AliRunLoader* runLoader, AliRawReader* rawReader) const 
-{
-  // reconstruction of real data if rawReader!=NULL
-  if(!runLoader) {
-    AliError("Missing RunLoader! 0x0");
-    return;
-  }
-
-  Int_t nEvents = runLoader->GetNumberOfEvents();
-  int iResult=0;
-
-  if (fpSystem) {
-    if (fpSystem->CheckStatus(AliHLTSystem::kError)) {
-      AliError("HLT system in error state");
-      return;
-    }
-    if ((iResult=fpSystem->Reconstruct(nEvents, runLoader, rawReader))>=0) {
-    }
-  }
-}
-
-void AliHLTReconstructor::ReconstructWithConformalMapping(AliRunLoader* runLoader,Int_t iEvent) const
-{
-  // reconstruct with conformal mapper
-  /*
-  AliLevel3 *fHLT = new AliLevel3(runLoader);
-  fHLT->Init("./", AliLevel3::kRunLoader, 1);
-
-  Int_t phiSegments = 50;
-  Int_t etaSegments = 100;
-  Int_t trackletlength = 3;
-  Int_t tracklength = 10;
-  Int_t rowscopetracklet = 2;
-  Int_t rowscopetrack = 10;
-  Double_t minPtFit = 0;
-  Double_t maxangle = 0.1745;
-  Double_t goodDist = 5;
-  Double_t maxphi = 0.1;
-  Double_t maxeta = 0.1;
-  Double_t hitChi2Cut = 20;
-  Double_t goodHitChi2 = 5;
-  Double_t trackChi2Cut = 10;
-  Double_t xyerror = -1;
-  Double_t zerror =  -1;
+// void AliHLTReconstructor::Reconstruct(AliRunLoader* runLoader, AliRawReader* rawReader) const 
+// {
+//   // reconstruction of real data if rawReader!=NULL
+//   if(!runLoader) {
+//     AliError("Missing RunLoader! 0x0");
+//     return;
+//   }
+
+//   Int_t nEvents = runLoader->GetNumberOfEvents();
+//   int iResult=0;
+
+//   if (fpSystem) {
+//     if (fpSystem->CheckStatus(AliHLTSystem::kError)) {
+//       AliError("HLT system in error state");
+//       return;
+//     }
+//     if ((iResult=fpSystem->Reconstruct(nEvents, runLoader, rawReader))>=0) {
+//     }
+//   }
+// }
+
+// void AliHLTReconstructor::ReconstructWithConformalMapping(AliRunLoader* runLoader,Int_t iEvent) const
+// {
+//   // reconstruct with conformal mapper
+//   /*
+//   AliLevel3 *fHLT = new AliLevel3(runLoader);
+//   fHLT->Init("./", AliLevel3::kRunLoader, 1);
+
+//   Int_t phiSegments = 50;
+//   Int_t etaSegments = 100;
+//   Int_t trackletlength = 3;
+//   Int_t tracklength = 10;
+//   Int_t rowscopetracklet = 2;
+//   Int_t rowscopetrack = 10;
+//   Double_t minPtFit = 0;
+//   Double_t maxangle = 0.1745;
+//   Double_t goodDist = 5;
+//   Double_t maxphi = 0.1;
+//   Double_t maxeta = 0.1;
+//   Double_t hitChi2Cut = 20;
+//   Double_t goodHitChi2 = 5;
+//   Double_t trackChi2Cut = 10;
+//   Double_t xyerror = -1;
+//   Double_t zerror =  -1;
   
-  fHLT->SetClusterFinderParam(xyerror,zerror,kTRUE);
-  fHLT->SetTrackerParam(phiSegments, etaSegments, 
-                       trackletlength, tracklength,
-                       rowscopetracklet, rowscopetrack,
-                       minPtFit, maxangle, goodDist, hitChi2Cut,
-                       goodHitChi2, trackChi2Cut, 50, maxphi, maxeta, kTRUE);
-  fHLT->SetTrackerParam(phiSegments, etaSegments, 
-                       trackletlength, tracklength,
-                       rowscopetracklet, rowscopetrack,
-                       minPtFit, maxangle, goodDist, hitChi2Cut,
-                       goodHitChi2, trackChi2Cut, 50, maxphi, maxeta, kFALSE);
-  fHLT->SetMergerParameters(2,3,0.003,0.1,0.05);
-  fHLT->DoMc();
-  fHLT->DoNonVertexTracking(); // 2 tracking passes, last without vertex contraint.
-  fHLT->WriteFiles("./hlt/");  
-  fHLT->ProcessEvent(0, 35, iEvent);
-  if(fDoBench){
-    char filename[256];
-    sprintf(filename, "confmap_%d",iEvent);
-    fHLT->DoBench(filename);
-  }
-
-  delete fHLT;
-  */
-}
-
-void AliHLTReconstructor::ReconstructWithHoughTransform(AliRunLoader* runLoader,Int_t iEvent) const
-{
-  //reconstruct with hough
-  //not used anymore, Hough tracking is moved out of the local
-  //reconstruction chain
-  Float_t ptmin = 0.1*AliHLTTransform::GetSolenoidField();
-
-  Float_t zvertex = 0;
-  TArrayF mcVertex(3); 
-  AliHeader * header = runLoader->GetHeader();
-  if (header) {
-    AliGenEventHeader * genHeader = header->GenEventHeader();
-    if (genHeader) genHeader->PrimaryVertex(mcVertex);
-  }
-  zvertex = mcVertex[2];
-
-  AliInfo(Form("Hough Transform will run with ptmin=%f and zvertex=%f", ptmin, zvertex));
-
-  AliHLTHough *hough = new AliHLTHough();
+//   fHLT->SetClusterFinderParam(xyerror,zerror,kTRUE);
+//   fHLT->SetTrackerParam(phiSegments, etaSegments, 
+//                     trackletlength, tracklength,
+//                     rowscopetracklet, rowscopetrack,
+//                     minPtFit, maxangle, goodDist, hitChi2Cut,
+//                     goodHitChi2, trackChi2Cut, 50, maxphi, maxeta, kTRUE);
+//   fHLT->SetTrackerParam(phiSegments, etaSegments, 
+//                     trackletlength, tracklength,
+//                     rowscopetracklet, rowscopetrack,
+//                     minPtFit, maxangle, goodDist, hitChi2Cut,
+//                     goodHitChi2, trackChi2Cut, 50, maxphi, maxeta, kFALSE);
+//   fHLT->SetMergerParameters(2,3,0.003,0.1,0.05);
+//   fHLT->DoMc();
+//   fHLT->DoNonVertexTracking(); // 2 tracking passes, last without vertex contraint.
+//   fHLT->WriteFiles("./hlt/");  
+//   fHLT->ProcessEvent(0, 35, iEvent);
+//   if(fDoBench){
+//     char filename[256];
+//     sprintf(filename, "confmap_%d",iEvent);
+//     fHLT->DoBench(filename);
+//   }
+
+//   delete fHLT;
+//   */
+// }
+
+// void AliHLTReconstructor::ReconstructWithHoughTransform(AliRunLoader* runLoader,Int_t iEvent) const
+// {
+//   //reconstruct with hough
+//   //not used anymore, Hough tracking is moved out of the local
+//   //reconstruction chain
+//   Float_t ptmin = 0.1*AliHLTTransform::GetSolenoidField();
+
+//   Float_t zvertex = 0;
+//   TArrayF mcVertex(3); 
+//   AliHeader * header = runLoader->GetHeader();
+//   if (header) {
+//     AliGenEventHeader * genHeader = header->GenEventHeader();
+//     if (genHeader) genHeader->PrimaryVertex(mcVertex);
+//   }
+//   zvertex = mcVertex[2];
+
+//   AliInfo(Form("Hough Transform will run with ptmin=%f and zvertex=%f", ptmin, zvertex));
+
+//   AliHLTHough *hough = new AliHLTHough();
     
-  hough->SetThreshold(4);
-  hough->CalcTransformerParams(ptmin);
-  hough->SetPeakThreshold(70,-1);
-  hough->SetRunLoader(runLoader);
-  hough->Init("./", kFALSE, 100, kFALSE,4,0,0,zvertex);
-  hough->SetAddHistograms();
-
-  for(Int_t slice=0; slice<=35; slice++)
-    {
-      //cout<<"Processing slice "<<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
index e60a8b1..de15477 100644 (file)
@@ -50,19 +50,11 @@ public:
   virtual ~AliHLTReconstructor();
 
   /** init the reconstructor */
-  void Init(AliRunLoader* runLoader);
-
-  /** reconstruct simulated MC data */
-  void Reconstruct(AliRunLoader* runLoader) const;
-  /** reconstruct data from RawReader */
-  void Reconstruct(AliRunLoader* runLoader, AliRawReader* rawReader) const;
+  void Init();
 
   /** create a tracker */
-// Deprecated and must be removed.
-//  AliTracker*  CreateTracker(AliRunLoader*) const;
-
-  /** fill esd for one event */
-  void FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const;
+  // Deprecated and must be removed.
+  //  AliTracker*  CreateTracker() const;
 
   virtual void         Reconstruct(TTree* digitsTree, TTree* clustersTree) const{
     AliReconstructor::Reconstruct(digitsTree,clustersTree);
@@ -79,10 +71,6 @@ public:
                               AliESDEvent* esd) const {
     AliReconstructor::FillESD(rawReader,clustersTree,esd);
   }
-  virtual void         FillESD(AliRunLoader* runLoader, 
-                              AliRawReader* rawReader, AliESDEvent* esd) const {
-    AliReconstructor:: FillESD(runLoader,rawReader,esd);
-  }
   void SetDoBench(Bool_t b){fDoBench=b;}
   void SetDoCleanup(Bool_t b){fDoCleanUp=b;}
   
@@ -90,10 +78,10 @@ public:
 //  virtual void         FillDHLTRecPoint(AliRawReader* rawReader, Int_t nofEvent, Int_t dcCut) const;
 
 private:
-  void ReconstructWithConformalMapping(AliRunLoader* runLoader,Int_t iEvent) const;
-  void ReconstructWithHoughTransform(AliRunLoader* runLoader,Int_t iEvent) const;
-  void FillESDforConformalMapping(AliESDEvent* esd,Int_t iEvent) const;
-  void FillESDforHoughTransform(AliESDEvent* esd,Int_t iEvent) const;
+/*   void ReconstructWithConformalMapping(AliRunLoader* runLoader,Int_t iEvent) const; */
+/*   void ReconstructWithHoughTransform(AliRunLoader* runLoader,Int_t iEvent) const; */
+/*   void FillESDforConformalMapping(AliESDEvent* esd,Int_t iEvent) const; */
+/*   void FillESDforHoughTransform(AliESDEvent* esd,Int_t iEvent) const; */
 
   Bool_t fDoHough;   //do the hough transform
   Bool_t fDoTracker; //do the standard conformal tracker
@@ -101,10 +89,8 @@ private:
   Bool_t fDoCleanUp; //delete tmp tracking files
 
   AliHLTSystem* fpSystem; //! HLT steering object
-  Int_t  fRecEvents;      //! number of reconstructed events
-  Int_t  fFilled;         //! number of event filled to ESD
 
-  ClassDef(AliHLTReconstructor, 1)   // class for the TPC reconstruction
+  ClassDef(AliHLTReconstructor, 2)   // class for the HLT reconstruction
 };
 
 typedef AliHLTReconstructor AliL3Reconstructor; // for backward compatibility
index 69f509d..fc9ba6a 100644 (file)
@@ -158,80 +158,97 @@ void AliHMPIDQualAssDataMaker::InitESDs()
 }
 
 //____________________________________________________________________________
-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());
index 1f86a04..10e256a 100644 (file)
@@ -42,11 +42,11 @@ private:
   virtual void   InitSDigits() ;   //book SDigits QA histo
   virtual void   InitRecPoints();  //book cluster QA histo
   virtual void   InitESDs() ;      //book ESD QA histo 
-  virtual void   MakeHits() ;      //Fill hit QA histo
-  virtual void   MakeDigits() ;    //Fill Digit QA histo
-  virtual void   MakeSDigits() ;   //Fill SDigit QA histo
-  virtual void   MakeRecPoints() ; //Fill cluster QA histo
-  virtual void   MakeESDs() ;      //Fill hit QA histo
+  virtual void   MakeHits(TObject * hits) ;       //Fill hit QA histo
+  virtual void   MakeDigits(TObject * digits) ;   //Fill Digit QA histo
+  virtual void   MakeSDigits(TObject * sdigits) ; //Fill SDigit QA histo
+  virtual void   MakeRecPoints(TTree * clusters)    ;  //Fill cluster QA histo
+  virtual void   MakeESDs(AliESDEvent * esd) ;         //Fill hit QA histo
 
   TH1F *fhHitQdc;                  // Hit Q distr
   TH2F *fhHitMap[7];               // Hit Q positions
index 80e9d55..4a4f076 100644 (file)
@@ -25,6 +25,7 @@
 #include <AliCDBManager.h>         //ctor
 #include <AliESDEvent.h>           //FillEsd()
 #include <AliRawReader.h>          //Reconstruct() for raw digits
+#include "AliHMPIDRawStream.h"     //ConvertDigits()
 ClassImp(AliHMPIDReconstructor)
 
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
@@ -139,47 +140,6 @@ void AliHMPIDReconstructor::Reconstruct(TTree *pDigTree,TTree *pCluTree)const
   AliDebug(1,"Stop.");      
 }//Reconstruct(for simulated digits)
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-void AliHMPIDReconstructor::Reconstruct(AliRunLoader *pAL,AliRawReader* pRR)const
-{
-//Invoked  by AliReconstruction to convert raw digits from DDL files to clusters
-//Arguments: pAL - ALICE run loader pointer
-//           pRR - ALICE raw reader pointer
-//  Returns: none
-  AliLoader *pRL=pAL->GetDetectorLoader("HMPID");  AliHMPID *pRich=(AliHMPID*)pAL->GetAliRun()->GetDetector("HMPID");//get pointers for HMPID and HMPID loader
-
-  AliHMPIDDigit dig; //tmp digit, raw digit will be converted to it
-
-  TObjArray digLst; Int_t iDigCnt[7]; for(Int_t i=0;i<7;i++){digLst.AddAt(new TClonesArray("AliHMPIDDigit"),i); iDigCnt[i]=0;} //tmp list of digits for allchambers
-
-  Int_t iEvtN=0;
-  while(pRR->NextEvent()){//events loop
-    pAL->GetEvent(iEvtN++);
-    pRL->MakeTree("R");  pRich->MakeBranch("R");
-    
-    for(Int_t iCh=AliHMPIDParam::kMinCh;iCh<=AliHMPIDParam::kMaxCh;iCh++) {
-      AliHMPIDRawStream stream(pRR);
-      while(stream.Next())
-       {
-         UInt_t ddl=stream.GetDDLNumber(); //returns 0,1,2 ... 13  
-         if((UInt_t)(2*iCh)==ddl || (UInt_t)(2*iCh+1)==ddl) {
-         for(Int_t row = 1; row <=AliHMPIDRawStream::kNRows; row++){
-          for(Int_t dil = 1; dil <=AliHMPIDRawStream::kNDILOGICAdd; dil++){
-            for(Int_t pad = 0; pad < AliHMPIDRawStream::kNPadAdd; pad++){
-              if(stream.GetCharge(ddl,row,dil,pad) < 1) continue; 
-              AliHMPIDDigit dig(stream.GetPad(ddl,row,dil,pad),stream.GetCharge(ddl,row,dil,pad));
-              if(!IsDigSurvive(&dig)) continue;
-              new((*((TClonesArray*)digLst.At(iCh)))[iDigCnt[iCh]++]) AliHMPIDDigit(dig); //add this digit to the tmp list
-             }//pad
-            }//dil
-           }//row
-       }//while stream    
-    }//ch loop
-  }   
-  }
-         
-  pRL->UnloadRecPoints();
-}//Reconstruct raw data
-//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 void AliHMPIDReconstructor::ConvertDigits(AliRawReader *pRR,TTree *pDigTree)const
 {
 //Invoked  by AliReconstruction to convert raw digits from DDL files to digits
@@ -221,7 +181,7 @@ void AliHMPIDReconstructor::ConvertDigits(AliRawReader *pRR,TTree *pDigTree)cons
   AliDebug(1,"Stop.");
 }//Reconstruct digits from raw digits
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-void AliHMPIDReconstructor::FillESD(AliRunLoader *, AliESDEvent *pESD) const
+void AliHMPIDReconstructor::FillESD(TTree */*digitsTree*/, TTree */*clustersTree*/, AliESDEvent *pESD) const
 {
 // Calculates probability to be a electron-muon-pion-kaon-proton
 // from the given Cerenkov angle and momentum assuming no initial particle composition
@@ -259,4 +219,3 @@ void AliHMPIDReconstructor::FillESD(AliRunLoader *, AliESDEvent *pESD) const
     pTrk->SetHMPIDpid(pid);
   }//ESD tracks loop
 }//FillESD()
-//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
index 085a3bb..b29b0d1 100644 (file)
@@ -8,7 +8,6 @@
 #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()
@@ -22,13 +21,11 @@ public:
            AliHMPIDReconstructor();              
   virtual ~AliHMPIDReconstructor()                                  {delete fDig;delete fClu;delete [] fUserCut;}//dtor  
 //framework part  
-  AliTracker*  CreateTracker         (AliRunLoader*                      )const{return new AliHMPIDTracker;}            //from AliReconstructor for clusters->PID
+  AliTracker*  CreateTracker         () const {return new AliHMPIDTracker;}            //from AliReconstructor for clusters->PID
   void         ConvertDigits         (AliRawReader *pRR, TTree *pDigTree) const;                                        //from AliReconstruction for raw->digit
   Bool_t       HasDigitConversion()   const {return kTRUE;}                                                             //HMPID digits converted with ConvertDigits 
   void         Reconstruct           (TTree* digitsTree, TTree* clustersTree) const;                                    //from AliReconstruction for digit->cluster
-  void         Reconstruct           (AliRunLoader *pAL,AliRawReader* pRR)const;                                        //from AliReconstruction for raw->cluster with Digits on fly
-  Bool_t       HasLocalReconstruction() const {return kTRUE;}                                                           // HMPID has local reconstruction algorithm
-  void         FillESD               (AliRunLoader* pAL,AliESDEvent *pESD)const;                                        //calculate pid for HMPID
+  void         FillESD               (TTree* /*digitsTree*/, TTree* /*clustersTree*/, AliESDEvent *pESD)const;                                        //calculate pid for HMPID
   
   using AliReconstructor::FillESD;                                                                                      //
   using AliReconstructor::Reconstruct;                                                                                  // 
index ede20b8..13dcdb9 100644 (file)
@@ -24,7 +24,6 @@
 #include "Riostream.h"
 #include "AliITSReconstructor.h"
 #include "AliRun.h"
-#include "AliRunLoader.h"
 #include "AliRawReader.h"
 #include "AliITSDetTypeRec.h"
 #include "AliITSgeom.h"
@@ -84,13 +83,11 @@ AliITSReconstructor& AliITSReconstructor::operator=(const AliITSReconstructor&
 }
 
 //______________________________________________________________________
-void AliITSReconstructor::Init(AliRunLoader */*runLoader*/) {
+void AliITSReconstructor::Init() {
     // Initalize this constructor bet getting/creating the objects
     // nesseary for a proper ITS reconstruction.
     // Inputs:
-    //    AliRunLoader *runLoader   Pointer to the run loader to allow
-    //                              the getting of files/folders data
-    //                              needed to do reconstruction
+    //   none.
     // Output:
     //   none.
     // Return:
@@ -132,7 +129,7 @@ void AliITSReconstructor::Reconstruct(AliRawReader* rawReader, TTree *clustersTr
 }
 
 //_____________________________________________________________________________
-AliTracker* AliITSReconstructor::CreateTracker(AliRunLoader* runLoader)const
+AliTracker* AliITSReconstructor::CreateTracker() const
 {
 // create a ITS tracker
 
@@ -155,23 +152,23 @@ AliTracker* AliITSReconstructor::CreateTracker(AliRunLoader* runLoader)const
   }
 
   TString selectedPIDmethod = GetOption();
-  AliITSLoader *loader = (AliITSLoader*)runLoader->GetLoader("ITSLoader");
-  if (!loader) {
-    Error("CreateTracker", "ITS loader not found");
-  }
+  AliITSReconstructor* nc = const_cast<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
 
@@ -199,23 +196,18 @@ AliVertexer* AliITSReconstructor::CreateVertexer(AliRunLoader* /*runLoader*/) co
 }
 
 //_____________________________________________________________________________
-void AliITSReconstructor::FillESD(AliRunLoader* runLoader, 
+void AliITSReconstructor::FillESD(TTree * /*digitsTree*/, TTree *clustersTree, 
                                  AliESDEvent* esd) const
 {
 // make PID, find V0s and cascade
-  AliITSLoader *loader = (AliITSLoader*)runLoader->GetLoader("ITSLoader");
-  AliITSpidESD *pidESD = 0;
-  TString selectedPIDmethod = GetOption();
-  if(selectedPIDmethod.Contains("LandauFitPID")){
-    Info("FillESD","ITS LandauFitPID option has been selected\n");
-    pidESD=loader->GetITSpid();
-  }
-  else{
-    Info("FillESD","ITS default PID\n");
-    pidESD=loader->GetITSpid();
-  }
-  if(pidESD!=0){
-    pidESD->MakePID(esd);
+  if(fItsPID!=0) {
+    TString selectedPIDmethod = GetOption();
+    if(selectedPIDmethod.Contains("LandauFitPID")){
+      fItsPID->MakePID(clustersTree,esd);
+    }
+    else{
+      fItsPID->MakePID(esd);
+    }
   }
   else {
     Error("FillESD","!! cannot do the PID !!\n");
index 99ab8ed..8a0bc1f 100644 (file)
@@ -25,31 +25,19 @@ public:
   virtual ~AliITSReconstructor();
   AliITSReconstructor(const AliITSReconstructor &ob); // copy constructor
   AliITSReconstructor& operator=(const AliITSReconstructor & ob); // ass. op.
-  virtual void Init(AliRunLoader* runLoader);
+  virtual void         Init();
   
-  virtual Bool_t       HasLocalReconstruction() const {return kTRUE;};
-
-  virtual void         Reconstruct(AliRunLoader* runLoader) const
-    {AliReconstructor::Reconstruct(runLoader);}
-  virtual void         Reconstruct(AliRunLoader* runLoader,
-                                  AliRawReader* rawReader) const
-    {AliReconstructor::Reconstruct(runLoader,rawReader);}
   virtual void         Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const;
   virtual void         Reconstruct(TTree* digitsTree, TTree* clustersTree) const;
 
-  virtual AliTracker*  CreateTracker(AliRunLoader* runLoader) const;
-  virtual AliVertexer* CreateVertexer(AliRunLoader* runLoader) const;
-  virtual void         FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const;
+  virtual AliTracker*  CreateTracker() const;
+  virtual AliVertexer* CreateVertexer() const;
 
-  virtual void         FillESD(TTree* digitsTree, TTree* clustersTree, 
-                                AliESDEvent* esd) const 
-    {AliReconstructor::FillESD(digitsTree, clustersTree, esd);}
-  virtual void         FillESD(AliRawReader* rawReader, TTree* clustersTree, 
+  virtual void         FillESD(TTree* /*digitsTree*/, TTree* clustersTree, 
+                              AliESDEvent* esd) const; 
+  virtual void         FillESD(AliRawReader* /*rawReader*/, TTree* clustersTree, 
                               AliESDEvent* esd) const
-    {AliReconstructor::FillESD(rawReader, clustersTree, esd);}
-  virtual void         FillESD(AliRunLoader* runLoader, 
-                              AliRawReader* rawReader, AliESDEvent* esd) const
-    {AliReconstructor::FillESD(runLoader,rawReader, esd);}
+  {FillESD((TTree*)NULL, clustersTree, esd);}
 
   void SetRecoParam(AliITSRecoParam * param){ fgkRecoParam = param;}
   static const AliITSRecoParam* GetRecoParam(){ return fgkRecoParam;}
@@ -59,7 +47,8 @@ private:
   static AliITSRecoParam *fgkRecoParam; // reconstruction parameters
   AliITSpidESD           *fItsPID;      // Pid for ITS
   AliITSDetTypeRec       *fDetTypeRec;  // reconstructor
-  ClassDef(AliITSReconstructor, 2)   // class for the ITS reconstruction
+
+  ClassDef(AliITSReconstructor, 3)   // class for the ITS reconstruction
 };
 
 #endif
index 1816a7b..4f83faf 100644 (file)
 //#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
index 8232a86..f18eb04 100755 (executable)
@@ -12,7 +12,7 @@
 //   Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch 
 //-------------------------------------------------------
 #include "AliITSpidESD.h"
-
+#include "AliLog.h"
 
 class AliITSpidESD1 : public AliITSpidESD {
 public:
@@ -20,6 +20,9 @@ public:
   AliITSpidESD1(Double_t *param);
   virtual ~AliITSpidESD1() {}
   virtual Int_t MakePID(AliESDEvent *event);
+  // This method is here because of the AliITSpidESD2 class...
+  virtual Int_t MakePID(TTree */*clustersTree*/, AliESDEvent */*event*/)
+  {AliError("Method should not be used!"); return 0;}
 
 private:
   Double_t fRes;          // relative dEdx resolution
index 0935236..6c24704 100644 (file)
@@ -40,20 +40,16 @@ ClassImp(AliITSpidESD2)
 //_________________________________________________________________________
   AliITSpidESD2::AliITSpidESD2():AliITSpidESD(),
 fTracker(0),
-fLoader(0),
 fSp(0)
 { //
   //  The main constructor
 }
 //_________________________________________________________________________
-AliITSpidESD2::AliITSpidESD2(AliITStrackerMI* tracker,AliITSLoader* loader):AliITSpidESD(),
-fTracker(0),
-fLoader(0),
+AliITSpidESD2::AliITSpidESD2(AliITStrackerMI* tracker):AliITSpidESD(),
+fTracker(tracker),
 fSp(0)
 { //
   //  The main constructor
-  fTracker=tracker;
-  fLoader=loader;
   fSp=new AliITSSteerPid();
   fSp->InitLayer();
 }
@@ -67,7 +63,6 @@ AliITSpidESD2::~AliITSpidESD2(){
 //______________________________________________________________________
 AliITSpidESD2::AliITSpidESD2(const AliITSpidESD2 &ob) :AliITSpidESD(ob),
 fTracker(ob.fTracker),
-fLoader(ob.fLoader),
 fSp(ob.fSp) 
 {
   // Copy constructor
@@ -83,7 +78,7 @@ AliITSpidESD2& AliITSpidESD2::operator=(const AliITSpidESD2& ob ){
 }
 
 //_________________________________________________________________________
-Int_t AliITSpidESD2::MakePID(AliESDEvent *event)
+Int_t AliITSpidESD2::MakePID(TTree *clustersTree, AliESDEvent *event)
 {
 
   //
@@ -91,9 +86,7 @@ Int_t AliITSpidESD2::MakePID(AliESDEvent *event)
   //
   Double_t xr,par[5];
   AliITStrackV2* track=0;
-  fLoader->LoadRecPoints();
-  TTree *cTree=fLoader->TreeR();
-  fTracker->LoadClusters(cTree);
+  fTracker->LoadClusters(clustersTree);
   printf("==== Landau Fit PID ITS ====== \n");
   Int_t ntrk=event->GetNumberOfTracks();
   Double_t momits;
@@ -165,6 +158,5 @@ Int_t AliITSpidESD2::MakePID(AliESDEvent *event)
     delete track;
   }
   fTracker->UnloadClusters();
-  fLoader->UnloadRecPoints();
   return 0;
 }
index a4a6a88..ff07be0 100755 (executable)
 // 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
index 092325c..6802680 100644 (file)
@@ -66,9 +66,7 @@
 #include "AliMUONReconstructor.h"
 
 #include "AliCDBManager.h"
-#include "AliLoader.h"
 #include "AliLog.h"
-#include "AliRunLoader.h"
 #include "AliMUONCalibrationData.h"
 #include "AliMUONClusterFinderCOG.h"
 #include "AliMUONClusterFinderMLEM.h"
@@ -298,7 +296,7 @@ AliMUONReconstructor::CreateTriggerChamberEff() const
 
 //_____________________________________________________________________________
 AliTracker* 
-AliMUONReconstructor::CreateTracker(AliRunLoader* runLoader) const
+AliMUONReconstructor::CreateTracker() const
 {
   /// Create the MUONTracker object
   /// The MUONTracker is passed the GetOption(), i.e. our own options
@@ -307,13 +305,7 @@ AliMUONReconstructor::CreateTracker(AliRunLoader* runLoader) const
   CreateDigitMaker();
   CreateTriggerChamberEff();
   
-  AliLoader* loader = runLoader->GetDetectorLoader("MUON");
-  if (!loader)
-  {
-    AliError("Cannot get MUONLoader, so cannot create MUONTracker");
-    return 0x0;
-  }
-  AliMUONTracker* tracker = new AliMUONTracker(loader,fDigitMaker,fTransformer,fTriggerCircuit,fTrigChamberEff);
+  AliMUONTracker* tracker = new AliMUONTracker(fDigitMaker,fTransformer,fTriggerCircuit,fTrigChamberEff);
   tracker->SetOption(GetOption());
   
   return tracker;
@@ -524,23 +516,6 @@ AliMUONReconstructor::HasDigitConversion() const
 }
 
 //_____________________________________________________________________________
-Bool_t 
-AliMUONReconstructor::HasLocalReconstruction() const
-{
-  /// Whether or not we have local reconstruction
-  TString opt(GetOption());
-  opt.ToUpper();
-  if ( opt.Contains("NOLOCALRECONSTRUCTION" ) )
-  {
-    return kFALSE;
-  }
-  else
-  {
-    return kTRUE;
-  }
-}
-
-//_____________________________________________________________________________
 void 
 AliMUONReconstructor::Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const
 {
@@ -561,84 +536,6 @@ AliMUONReconstructor::Reconstruct(AliRawReader* rawReader, TTree* 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
 {
   /// This method is called by AliReconstruction if HasLocalReconstruction()==kTRUE
index c6d2db7..56ea533 100644 (file)
@@ -48,17 +48,11 @@ public:
 
   virtual void ConvertDigits(AliRawReader* rawReader, TTree* digitsTree) const;
   
-  virtual Bool_t HasLocalReconstruction() const;
-  
-  virtual void Reconstruct(AliRunLoader* runLoader) const;
-  
-  virtual void Reconstruct(AliRunLoader* runLoader, AliRawReader* rawReader) const;
-
   virtual void Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const;
   
   virtual void Reconstruct(TTree* digitsTree, TTree* clustersTree) const;
   
-  virtual AliTracker* CreateTracker(AliRunLoader* runLoader) const;
+  virtual AliTracker* CreateTracker() const;
     
 private:
   /// Not implemented
@@ -99,7 +93,7 @@ private:
   mutable AliMUONVTrackStore* fTrackStore; //!< Track container
   mutable AliMUONTriggerChamberEff* fTrigChamberEff; //!< pointer to trigger chamber efficiency class
   
-  ClassDef(AliMUONReconstructor,2) // Implementation of AliReconstructor
+  ClassDef(AliMUONReconstructor,3) // Implementation of AliReconstructor
 };
 
 #endif
index 5937010..caf0493 100644 (file)
@@ -44,7 +44,6 @@
 #include "AliESDEvent.h"
 #include "AliESDMuonTrack.h"
 #include "AliESDVertex.h"
-#include "AliLoader.h"
 #include "AliLog.h"
 
 #include <Riostream.h>
@@ -56,13 +55,11 @@ ClassImp(AliMUONTracker)
 
 
 //_____________________________________________________________________________
-AliMUONTracker::AliMUONTracker(AliLoader* loader,
-                               const AliMUONDigitMaker* digitMaker,
+AliMUONTracker::AliMUONTracker(const AliMUONDigitMaker* digitMaker,
                                const AliMUONGeometryTransformer* transformer,
                                const AliMUONTriggerCircuit* triggerCircuit,
                               AliMUONTriggerChamberEff* chamberEff)
 : AliTracker(),
-  fLoader(loader),
   fDigitMaker(digitMaker), // not owner
   fTransformer(transformer), // not owner
   fTriggerCircuit(triggerCircuit), // not owner
@@ -127,14 +124,9 @@ AliMUONTracker::Clusters2Tracks(AliESDEvent* esd)
   /// the TreeT and the ESD
   
   Int_t rv(0);
-  
-  TTree* tracksTree = fLoader->TreeT();
-  
-  if (!tracksTree)
-  {
-    AliError("Cannot get TreeT");
-    rv=1;
-  }
+  TTree *tracksTree = new TTree;
   if (!fClusterStore)
   {
     AliError("ClusterStore is NULL");
index 4f8e35f..74b009d 100644 (file)
@@ -14,7 +14,6 @@
 
 class AliCluster;
 class AliESDEvent;
-class AliLoader;
 class AliMUONDigitMaker;
 class AliMUONGeometryTransformer;
 class AliMUONTrackHitPattern;
@@ -29,8 +28,7 @@ class AliMUONTracker : public AliTracker
 {
  public:
 
-  AliMUONTracker(AliLoader* loader,
-                 const AliMUONDigitMaker* digitMaker=0,
+  AliMUONTracker(const AliMUONDigitMaker* digitMaker=0,
                  const AliMUONGeometryTransformer* transformer=0,
                  const AliMUONTriggerCircuit* triggerCircuit=0,
                 AliMUONTriggerChamberEff* chamberEff=0);
@@ -65,7 +63,6 @@ private:
   void FillESD(AliMUONVTrackStore& trackStore, AliESDEvent* esd) const;
 
 private:
-  AliLoader* fLoader; //!< loader to get access to trees
   const AliMUONDigitMaker* fDigitMaker; //!< digit maker (not owner)
   const AliMUONGeometryTransformer* fTransformer; //!< geometry transformer (not owner)
   const AliMUONTriggerCircuit* fTriggerCircuit;                //!< trigger circuit (not owner)
index 70b322f..381624b 100644 (file)
 #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),
@@ -43,23 +42,19 @@ AliPHOSClusterizer::AliPHOSClusterizer():
 //____________________________________________________________________________
 AliPHOSClusterizer::AliPHOSClusterizer(AliPHOSGeometry *geom):
   fGeom(geom),
-  fQADM(0),
   fDigitsArr(0),
   fTreeR(0),
   fEMCRecPoints(0),
   fCPVRecPoints(0)
 {
   // ctor
-  fQADM = new AliPHOSQualAssDataMaker() ;  
-  //initiaizes the quality assurance data maker
-  fQADM ->Init(AliQualAss::kRECPOINTS) ;    
 }
 
 //____________________________________________________________________________
 AliPHOSClusterizer::~AliPHOSClusterizer()
 {
   // dtor
-  delete fQADM ; 
   if (fDigitsArr) {
     fDigitsArr->Delete();
     delete fDigitsArr;
index 9176f20..0260a3e 100644 (file)
@@ -6,6 +6,9 @@
 /* History of cvs commits:
  *
  * $Log$
+ * Revision 1.42  2007/08/28 12:55:07  policheh
+ * Loaders removed from the reconstruction code (C.Cheshkov)
+ *
  * Revision 1.41  2007/08/07 14:12:03  kharlov
  * Quality assurance added (Yves Schutz)
  *
@@ -33,7 +36,6 @@
 class TTree;
 
 class AliPHOSGeometry;
-class AliPHOSQualAssDataMaker ; 
 
 class AliPHOSClusterizer : public TObject {
 
@@ -70,10 +72,8 @@ public:
   virtual void SetOutput(TTree *clustersTree);
 
 protected:
-  AliPHOSQualAssDataMaker * GetQualAssDataMaker() const { return fQADM ; } 
 
   AliPHOSGeometry *fGeom; // Pointer to PHOS geometry
-  AliPHOSQualAssDataMaker * fQADM ; //!Quality Assurance Data Maker
   TClonesArray *fDigitsArr; // Array with input digits
   TTree *fTreeR; // Tree with output clusters
   TObjArray *fEMCRecPoints; // Array with EMC clusters
index 2147a60..f9179a8 100644 (file)
@@ -18,6 +18,9 @@
 /* History of cvs commits:
  *
  * $Log$
+ * Revision 1.114  2007/09/06 16:06:44  kharlov
+ * Absence of sorting results in loose of all unfolded clusters
+ *
  * Revision 1.113  2007/08/28 12:55:07  policheh
  * Loaders removed from the reconstruction code (C.Cheshkov)
  *
 #include "AliCDBStorage.h"
 #include "AliCDBEntry.h"
 #include "AliPHOSRecoParam.h"
-#include "AliPHOSQualAssDataMaker.h" 
 #include "AliPHOSCalibData.h"
 #include "AliPHOSReconstructor.h"
 
@@ -298,24 +300,11 @@ void AliPHOSClusterizerv1::Digits2Clusters(Option_t *option)
   if(fToUnfold)             
     MakeUnfolding();
 
-    //makes the quality assurance data
-  if (GetQualAssDataMaker()) {
-    GetQualAssDataMaker()->SetData(fEMCRecPoints) ; 
-    GetQualAssDataMaker()->Exec(AliQualAss::kRECPOINTS) ; 
-    GetQualAssDataMaker()->SetData(fCPVRecPoints) ; 
-    GetQualAssDataMaker()->Exec(AliQualAss::kRECPOINTS) ; 
-  }
-
   WriteRecPoints();
 
   if(strstr(option,"deb"))  
     PrintRecPoints(option) ;
 
-  // PLEASE FIX BY MOVING IT TO ALIRECONSTRUCTION !!!
-  //Write the quality assurance data only after the last event 
-  //  if (GetQualAssDataMaker() && fEventCounter == gime->MaxEvent()) 
-  //    GetQualAssDataMaker()->Finish(AliQualAss::kRECPOINTS) ;
-
   if(strstr(option,"tim")){
     gBenchmark->Stop("PHOSClusterizer");
     AliInfo(Form("took %f seconds for Clusterizing\n",
index 61d9ccb..e774731 100644 (file)
@@ -33,7 +33,6 @@
 #include "AliPHOSRecCpvManager.h"
 #include "AliPHOSRecEmcManager.h"
 #include "AliPHOSGeometry.h"
-#include "AliPHOSQualAssDataMaker.h" 
 #include "AliPHOSDigit.h"
 
 ClassImp(AliPHOSClusterizerv2)
@@ -168,11 +167,6 @@ void AliPHOSClusterizerv2::Digits2Clusters(Option_t* option)
 //      nOldEmc, 
 //      gime->EmcRecPoints()->GetEntries(), emcRecPoints->GetEntries() )); 
     
-//     GetQualAssDataMaker()->Init(AliQualAss::kRECPOINTS) ;    
-//     GetQualAssDataMaker()->SetData(gime->EmcRecPoints()) ; 
-//     GetQualAssDataMaker()->Exec(AliQualAss::kRECPOINTS) ; 
-//     GetQualAssDataMaker()->SetData(gime->CpvRecPoints()) ; 
-//     GetQualAssDataMaker()->Exec(AliQualAss::kRECPOINTS) ; 
 
 //     WriteRecPoints();
 
index 3f10835..e776cc0 100644 (file)
@@ -18,6 +18,9 @@
 /* History of cvs commits:
  *
  * $Log$
+ * Revision 1.97  2007/08/07 14:12:03  kharlov
+ * Quality assurance added (Yves Schutz)
+ *
  * Revision 1.96  2007/04/28 10:43:36  policheh
  * Dead channels simulation: digit energy sets to 0.
  *
@@ -625,8 +628,7 @@ void AliPHOSDigitizer::Exec(Option_t *option)
     Digitize(ievent) ; //Add prepared SDigits to digits and add the noise
 
     //makes the quality assurance data
-    GetQualAssDataMaker()->SetData(gime->Digits()) ; 
-    GetQualAssDataMaker()->Exec(AliQualAss::kDIGITS) ; 
+    GetQualAssDataMaker()->Exec(AliQualAss::kDIGITS, gime->Digits()) ; 
                                   
     WriteDigits() ;
 
index f9e1843..d1bf115 100644 (file)
@@ -34,7 +34,6 @@
 #include "AliConfig.h"
 #include "AliPHOSPID.h"
 #include "AliPHOSGetter.h"
-#include "AliPHOSQualAssDataMaker.h" 
 
 ClassImp(AliPHOSPID)
 
@@ -46,8 +45,7 @@ AliPHOSPID::AliPHOSPID():
   fEMCRecPoints(NULL),
   fCPVRecPoints(NULL),
   fTrackSegments(NULL),
-  fRecParticles(NULL),
-  fQADM(0x0)
+  fRecParticles(NULL)
 {
   // ctor
 }
@@ -61,15 +59,12 @@ AliPHOSPID::AliPHOSPID(AliPHOSGeometry *geom):
   fEMCRecPoints(NULL),
   fCPVRecPoints(NULL),
   fTrackSegments(NULL),
-  fRecParticles(NULL),
-  fQADM(0x0)
+  fRecParticles(NULL)
 {
   // ctor
   fRecParticles = new TClonesArray("AliPHOSRecParticle",100) ;
   fRecParticles->SetName("RECPARTICLES");
 
-  fQADM = new  AliPHOSQualAssDataMaker() ; //!Quality Assurance Data Maker
-  GetQualAssDataMaker()->Init(AliQualAss::kRECPARTICLES) ;    
 }
 
 //____________________________________________________________________________
@@ -80,8 +75,7 @@ AliPHOSPID::AliPHOSPID(const AliPHOSPID & pid) :
   fEMCRecPoints(pid.fEMCRecPoints),
   fCPVRecPoints(pid.fCPVRecPoints),
   fTrackSegments(pid.fTrackSegments),
-  fRecParticles(pid.fRecParticles),
-  fQADM(pid.fQADM)
+  fRecParticles(pid.fRecParticles)
 {
   // Copy constructor
 }
@@ -98,7 +92,6 @@ AliPHOSPID::~AliPHOSPID()
     fCPVRecPoints->Delete();
     delete fCPVRecPoints;
   }
-  delete fQADM ; 
 }
 
 //____________________________________________________________________________
index 1db79ad..f1e5351 100644 (file)
@@ -8,6 +8,9 @@
 /* History of cvs commits:
  *
  * $Log$
+ * Revision 1.41  2007/08/28 12:55:08  policheh
+ * Loaders removed from the reconstruction code (C.Cheshkov)
+ *
  * Revision 1.40  2007/08/07 14:12:03  kharlov
  * Quality assurance added (Yves Schutz)
  *
@@ -45,7 +48,6 @@ class AliESDEvent ;
 class AliPHOSGeometry ;
 class AliPHOSClusterizer ;
 class AliPHOSTrackSegmentMaker ;
-class AliPHOSQualAssDataMaker ; 
 
 class AliPHOSPID : public TObject {
 
@@ -69,8 +71,6 @@ class AliPHOSPID : public TObject {
 
   virtual const char * Version() const = 0;
 
-  AliPHOSQualAssDataMaker * GetQualAssDataMaker() const { return fQADM ; } 
-
 protected:
 
   AliPHOSGeometry * fGeom;    //! Pointer to PHOS Geometry
@@ -84,8 +84,6 @@ protected:
 
 private: 
 
-  AliPHOSQualAssDataMaker * fQADM ; //!Quality Assurance Data Maker
-
   ClassDef(AliPHOSPID,6)  // Particle Identifier algorithm (base class)
 
 } ;
index 767d8fe..5ddd6b9 100644 (file)
@@ -180,11 +180,10 @@ void AliPHOSQualAssDataMaker::InitTrackSegments()
 }
 
 //____________________________________________________________________________
-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++ ) {
@@ -196,95 +195,128 @@ void AliPHOSQualAssDataMaker::MakeESDs()
 }
 
 //____________________________________________________________________________
-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()) ;
+//   } 
+// }
index f08cc02..9fa4078 100644 (file)
@@ -38,13 +38,13 @@ private:
   virtual void   InitRecPoints() ; 
   virtual void   InitTrackSegments() ; 
   virtual void   InitSDigits() ; 
-  virtual void   MakeESDs() ;
-  virtual void   MakeHits() ;
-  virtual void   MakeDigits() ; 
-  virtual void   MakeRecParticles() ; 
-  virtual void   MakeRecPoints() ; 
-  virtual void   MakeSDigits() ; 
-  virtual void   MakeTrackSegments() ; 
+  virtual void   MakeESDs(AliESDEvent * esd) ;
+  virtual void   MakeHits(TObject * hits) ;
+  virtual void   MakeDigits(TObject * digits) ; 
+  // virtual void   MakeRecParticles(TTree * recpar) ; 
+  virtual void   MakeRecPoints(TTree * recpo) ; 
+  virtual void   MakeSDigits(TObject * sigits) ; 
+  //virtual void   MakeTrackSegments(TTree *ts ) ; 
   
   TH1F  * fhHits ;            //! hits energy histogram
   TH1I  * fhHitsMul ;         //! hits multiplicity histogram
index edbe76b..461e350 100644 (file)
@@ -27,7 +27,6 @@
 
 // --- AliRoot header files ---
 #include "AliLog.h"
-#include "AliPHOSQualAssDataMaker.h"
 #include "AliESDEvent.h"
 #include "AliESDCaloCluster.h"
 #include "AliPHOSReconstructor.h"
@@ -107,10 +106,8 @@ void AliPHOSReconstructor::FillESD(TTree* digitsTree, TTree* clustersTree,
   // write tracks to the ESD
 
   AliPHOSTrackSegmentMaker *tsm = new AliPHOSTrackSegmentMakerv1(fGeom);
-  tsm->GetQualAssDataMaker()->Init(AliQualAss::kTRACKSEGMENTS) ; 
   AliPHOSPID *pid = new AliPHOSPIDv1(fGeom);
-  pid->GetQualAssDataMaker()->Init(AliQualAss::kRECPARTICLES) ;    
-
   // do current event; the loop over events is done by AliReconstruction::Run()
   tsm->SetESD(esd) ; 
   tsm->SetInput(clustersTree);
@@ -119,9 +116,6 @@ void AliPHOSReconstructor::FillESD(TTree* digitsTree, TTree* clustersTree,
   else 
     tsm->Clusters2TrackSegments("") ;
   
-  tsm->GetQualAssDataMaker()->SetData(tsm->GetTrackSegments()) ; 
-  tsm->GetQualAssDataMaker()->Exec(AliQualAss::kTRACKSEGMENTS) ; 
-
   pid->SetInput(clustersTree, tsm->GetTrackSegments()) ; 
   pid->SetESD(esd) ; 
   if ( Debug() ) 
@@ -129,14 +123,6 @@ void AliPHOSReconstructor::FillESD(TTree* digitsTree, TTree* clustersTree,
   else 
     pid->TrackSegments2RecParticles("") ;
 
-  pid->GetQualAssDataMaker()->SetData(pid->GetRecParticles()) ; 
-  pid->GetQualAssDataMaker()->Exec(AliQualAss::kRECPARTICLES) ; 
-  
-  // PLEASE FIX IT. SHOULD GO TO ALIRECONSTRUCTION !!
-  //  if ( eventNumber == gime->MaxEvent()-1 ) {
-  //   fTSM->GetQualAssDataMaker()->Finish(AliQualAss::kTRACKSEGMENTS) ; 
-  //   fPID->GetQualAssDataMaker()->Finish(AliQualAss::kRECPARTICLES) ; 
-  //  }
        
   // This function creates AliESDtracks from AliPHOSRecParticles
   //         and
@@ -313,7 +299,7 @@ void AliPHOSReconstructor::FillESD(TTree* digitsTree, TTree* clustersTree,
   }  
 }
 
-AliTracker* AliPHOSReconstructor::CreateTracker(AliRunLoader* /* runLoader */) const
+AliTracker* AliPHOSReconstructor::CreateTracker() const
 {
   // creates the PHOS tracker
   return new AliPHOSTracker();
index 550ce54..51775fc 100644 (file)
@@ -8,6 +8,9 @@
 /* History of cvs commits:
  *
  * $Log$
+ * Revision 1.13  2007/08/30 10:40:27  cvetan
+ * Minor
+ *
  * Revision 1.12  2007/08/28 12:55:08  policheh
  * Loaders removed from the reconstruction code (C.Cheshkov)
  *
@@ -68,15 +71,12 @@ public:
   static void                SetDebug()   { fgDebug = kTRUE ; }
   static void                ResetDebug() { fgDebug = kFALSE ; }
   static Bool_t              Debug() { return fgDebug ; }
-  AliTracker *CreateTracker(AliRunLoader* runLoader) const;
+  AliTracker *CreateTracker() const;
   using AliReconstructor::FillESD;
   virtual void               FillESD(TTree* digitsTree, TTree* clustersTree, 
                                     AliESDEvent* esd) const;
   using AliReconstructor::Reconstruct;
-  virtual Bool_t             HasLocalReconstruction() const {return kTRUE;};
   virtual void               Reconstruct(TTree* digitsTree, TTree* clustersTree) const;
-  //  virtual void               Reconstruct(AliRunLoader* runLoader) const ;
-  //  virtual void               Reconstruct(AliRunLoader* runLoader, AliRawReader * rawreader) const ;
 
   virtual Bool_t             HasDigitConversion() const {return kTRUE;};
   virtual void               ConvertDigits(AliRawReader* rawReader, TTree* digitsTree) const;
@@ -100,7 +100,7 @@ private:
   static AliPHOSRecoParam*   fgkRecoParamCpv; // reconstruction parameters for EMC
   AliPHOSGeometry*           fGeom;           // pointer to the PHOS geometry
 
-  ClassDef(AliPHOSReconstructor,3)  // PHOS Reconstruction class
+  ClassDef(AliPHOSReconstructor,4)  // PHOS Reconstruction class
 
 }; 
 
index 1e5b0d5..5e07932 100644 (file)
@@ -19,6 +19,9 @@
 /* History of cvs commits:
  *
  * $Log$
+ * Revision 1.51  2007/08/07 14:12:03  kharlov
+ * Quality assurance added (Yves Schutz)
+ *
  * Revision 1.50  2006/08/28 10:01:56  kharlov
  * Effective C++ warnings fixed (Timur Pocheptsov)
  *
@@ -275,10 +278,8 @@ void AliPHOSSDigitizer::Exec(Option_t *option)
 
     // make Quality Assurance data
 
-    GetQualAssDataMaker()->SetData(hits) ; 
-    GetQualAssDataMaker()->Exec(AliQualAss::kHITS) ; 
-    GetQualAssDataMaker()->SetData(sdigits) ; 
-    GetQualAssDataMaker()->Exec(AliQualAss::kSDIGITS) ; 
+    GetQualAssDataMaker()->Exec(AliQualAss::kHITS, hits) ; 
+    GetQualAssDataMaker()->Exec(AliQualAss::kSDIGITS, sdigits) ; 
 
 
     //Now write SDigits
index ac9ca68..ccbd2f1 100644 (file)
@@ -17,6 +17,9 @@
 /* History of cvs commits:
  *
  * $Log$
+ * Revision 1.29  2007/08/28 12:55:08  policheh
+ * Loaders removed from the reconstruction code (C.Cheshkov)
+ *
  * Revision 1.28  2007/08/07 14:12:03  kharlov
  * Quality assurance added (Yves Schutz)
  *
@@ -46,7 +49,7 @@
 
 // --- AliRoot header files ---
 #include "AliPHOSTrackSegmentMaker.h"
-#include "AliPHOSQualAssDataMaker.h" 
+#include "AliLog.h"
 
 ClassImp( AliPHOSTrackSegmentMaker) 
 
@@ -55,7 +58,6 @@ ClassImp( AliPHOSTrackSegmentMaker)
 AliPHOSTrackSegmentMaker:: AliPHOSTrackSegmentMaker() : 
   TObject(),
   fESD(0), 
-  fQADM(0x0),
   fGeom(0),
   fEMCRecPoints(0),
   fCPVRecPoints(0)
@@ -67,21 +69,17 @@ AliPHOSTrackSegmentMaker:: AliPHOSTrackSegmentMaker() :
 AliPHOSTrackSegmentMaker::AliPHOSTrackSegmentMaker(AliPHOSGeometry *geom):
   TObject(),
   fESD(0), 
-  fQADM(0x0),
   fGeom(geom),
   fEMCRecPoints(0),
   fCPVRecPoints(0)
 {
   // ctor
-  fQADM = new  AliPHOSQualAssDataMaker() ; //!Quality Assurance Data Maker
-  GetQualAssDataMaker()->Init(AliQualAss::kTRACKSEGMENTS) ; 
 }
 
 //____________________________________________________________________________
 AliPHOSTrackSegmentMaker::AliPHOSTrackSegmentMaker(const AliPHOSTrackSegmentMaker & tsmaker) :
   TObject(tsmaker),
   fESD(tsmaker.GetESD()), 
-  fQADM(tsmaker.fQADM),
   fGeom(tsmaker.fGeom),
   fEMCRecPoints(tsmaker.fEMCRecPoints),
   fCPVRecPoints(tsmaker.fCPVRecPoints)
@@ -95,7 +93,6 @@ AliPHOSTrackSegmentMaker::~AliPHOSTrackSegmentMaker()
  //Remove this from the parental task before destroying
   //  if(AliPHOSGetter::Instance()->PhosLoader())
   //    AliPHOSGetter::Instance()->PhosLoader()->CleanTracker();
-  delete fQADM ; 
   if (fEMCRecPoints) {
     fEMCRecPoints->Delete();
     delete fEMCRecPoints;
index f21ef10..f4fa690 100644 (file)
@@ -8,6 +8,9 @@
 /* History of cvs commits:
  *
  * $Log$
+ * Revision 1.43  2007/08/28 12:55:08  policheh
+ * Loaders removed from the reconstruction code (C.Cheshkov)
+ *
  * Revision 1.42  2007/08/07 14:12:03  kharlov
  * Quality assurance added (Yves Schutz)
  *
@@ -39,7 +42,6 @@ class TTree;
 // --- AliRoot header files ---
 class AliPHOSGeometry ;
 class AliESDEvent ;
-class AliPHOSQualAssDataMaker ; 
 
 class  AliPHOSTrackSegmentMaker : public TObject {
 
@@ -62,14 +64,11 @@ public:
 
   AliESDEvent *GetESD()             const {return fESD;            }
 
-  AliPHOSQualAssDataMaker * GetQualAssDataMaker() const { return fQADM ; } 
-
   virtual TClonesArray * GetTrackSegments() const = 0;
 
 protected:
 
   AliESDEvent * fESD;              //! ESD object
-  AliPHOSQualAssDataMaker * fQADM ; //!Quality Assurance Data Maker
   AliPHOSGeometry *fGeom;           //! Pointer to the PHOS geometry
   TObjArray *fEMCRecPoints;         //  Array with the EMC clusters
   TObjArray *fCPVRecPoints;         //  Array with the CPV clusters
index 5ab255e..1459428 100644 (file)
@@ -21,7 +21,6 @@
 
 #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,
@@ -91,23 +55,6 @@ void AliPMDReconstructor::Reconstruct(TTree *digitsTree,
 }
 
 // ------------------------------------------------------------------------ //
-
-//void AliPMDReconstructor::FillESD(AliRunLoader* runLoader,AliESDEvent* esd) const
-//{
-//  AliLoader* loader = runLoader->GetLoader("PMDLoader");
-//  if (!loader) {
-//    AliError("PMD loader not found");
-//    return;
-//  }
-//  loader->LoadRecPoints("READ");
-//  TTree *treeR = loader->TreeR();
-//  AliPMDtracker pmdtracker;
-//  pmdtracker.LoadClusters(treeR);
-//  pmdtracker.Clusters2Tracks(esd);
-//  loader->UnloadRecPoints();
-//}
-
-// ------------------------------------------------------------------------ //
 void AliPMDReconstructor::FillESD(AliRawReader* /*rawReader*/,
                                  TTree* clustersTree, AliESDEvent* esd) const
 {
index afdab35..7e32dda 100644 (file)
@@ -7,34 +7,19 @@
 
 class AliPMDReconstructor: public AliReconstructor {
 public:
-  virtual void   Init(AliRunLoader* /*runLoader*/) {;}
-  virtual void   Reconstruct(AliRunLoader* runLoader) const;
-  virtual void   Reconstruct(AliRunLoader* runLoader,
-                            AliRawReader *rawReader) const;
   virtual void   Reconstruct(AliRawReader* rawReader,
                             TTree* clustersTree) const;
   virtual void   Reconstruct(TTree* digitsTree, TTree* clustersTree) const;
 
-  virtual Bool_t HasLocalReconstruction() const { return kTRUE; }
-
-  //virtual void   FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const;
   virtual void   FillESD(AliRawReader* /*rawReader*/, TTree* clustersTree, 
                         AliESDEvent* esd) const;
 
   virtual void   FillESD(TTree* /*digitsTree*/, TTree* clustersTree, 
                         AliESDEvent* esd) const;
 
-  virtual void   FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const {
-    AliReconstructor::FillESD(runLoader,esd);
-  }
-  virtual void   FillESD(AliRunLoader* runLoader, 
-                        AliRawReader* rawReader, AliESDEvent* esd) const {
-    AliReconstructor::FillESD(runLoader,rawReader,esd);
-  }
 private:
 
-  ClassDef(AliPMDReconstructor, 4)   // class for the PMD reconstruction
+  ClassDef(AliPMDReconstructor, 5)   // class for the PMD reconstruction
 };
 
 #endif
index 348233a..9566dbf 100644 (file)
 // --- 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)
   
@@ -42,8 +45,7 @@ TString AliQualAssDataMaker::fDetectorDirName("") ;
 AliQualAssDataMaker::AliQualAssDataMaker(const char * name, const char * title) : 
   TNamed(name, title), 
   fOutput(0x0),
-  fDetectorDir(0x0), 
-  fData(0x0)
+  fDetectorDir(0x0)
 {
   // ctor
   TString tmp(GetName()) ; 
@@ -57,8 +59,7 @@ AliQualAssDataMaker::AliQualAssDataMaker(const char * name, const char * title)
 AliQualAssDataMaker::AliQualAssDataMaker(const AliQualAssDataMaker& qadm) :
   TNamed(qadm.GetName(), qadm.GetTitle()),
   fOutput(qadm.fOutput),
-  fDetectorDir(qadm.fDetectorDir),
-  fData(qadm.fData)
+  fDetectorDir(qadm.fDetectorDir)
 {
   //copy ctor
   fDetectorDirName = GetName() ; 
@@ -74,7 +75,7 @@ AliQualAssDataMaker& AliQualAssDataMaker::operator = (const AliQualAssDataMaker&
 }
 
 //____________________________________________________________________________
-void AliQualAssDataMaker::Exec(AliQualAss::TASKINDEX task) 
+void AliQualAssDataMaker::Exec(AliQualAss::TASKINDEX task, TObject * data) 
 { 
   // creates the quality assurance data for the various tasks (Hits, SDigits, Digits, ESDs)
  
@@ -85,37 +86,54 @@ void AliQualAssDataMaker::Exec(AliQualAss::TASKINDEX task)
   switch (task) { 
   case AliQualAss::kHITS:
     AliInfo("Processing Hits QA") ; 
-    MakeHits() ;
+    MakeHits(data) ;
     break ; 
 
-   case AliQualAss::kSDIGITS:
+  case AliQualAss::kSDIGITS:
     AliInfo("Processing SDigits QA") ; 
-       MakeSDigits() ;
+    MakeSDigits(data) ;
     break ; 
-
-   case AliQualAss::kDIGITS:
-    AliInfo("Processing Digits QA") ; 
-    MakeDigits() ;
+    
+  case AliQualAss::kDIGITS:
+    MakeDigits(data) ;
     break ;  
  
    case AliQualAss::kRECPOINTS:
-    AliInfo("Processing RecPoints QA") ; 
-    MakeRecPoints() ;
+     AliInfo("Processing RecPoints QA") ; 
+     {
+       TTree * recpoints = dynamic_cast<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 ;  
   }    
 }
index 19611d1..1483df8 100644 (file)
@@ -18,6 +18,9 @@
 #include <TNamed.h>  
 class TFile;  
 class TDirectory;
+class TObject; 
+class TTree; 
+class AliESDEvent;
 
 // --- Standard library ---
 
@@ -33,12 +36,11 @@ public:
   AliQualAssDataMaker& operator = (const AliQualAssDataMaker& qadm) ;
   virtual ~AliQualAssDataMaker() {;} // dtor
   
-  virtual void        Exec(AliQualAss::TASKINDEX) ;
+  virtual void        Exec(AliQualAss::TASKINDEX, TObject * data) ;
   void                Finish(AliQualAss::TASKINDEX task) const ; 
   static const char * GetDetectorDirName() { return fDetectorDirName.Data() ; }
   void                Init(AliQualAss::TASKINDEX) ;
-  void                SetData(TObject * obj)     { fData = obj ; }     
-
 protected: 
 
   virtual void   InitDigits()        {AliInfo("To ne implemented by detectors");}
@@ -48,17 +50,16 @@ protected:
   virtual void   InitRecPoints()     {AliInfo("To ne implemented by detectors");}
   virtual void   InitSDigits()       {AliInfo("To ne implemented by detectors");}
   virtual void   InitTrackSegments() {AliInfo("To ne implemented by detectors");}
-  virtual void   MakeESDs()          {AliInfo("To ne implemented by detectors");} 
-  virtual void   MakeHits()          {AliInfo("To ne implemented by detectors");} 
-  virtual void   MakeDigits()        {AliInfo("To ne implemented by detectors");} 
-  virtual void   MakeRecParticles() {AliInfo("To ne implemented by detectors");} 
-  virtual void   MakeRecPoints()     {AliInfo("To ne implemented by detectors");} 
-  virtual void   MakeSDigits()       {AliInfo("To ne implemented by detectors");} 
-  virtual void   MakeTrackSegments() {AliInfo("To ne implemented by detectors");} 
+  virtual void   MakeESDs(AliESDEvent * )          {AliInfo("To ne implemented by detectors");} 
+  virtual void   MakeHits(TObject * )              {AliInfo("To ne implemented by detectors");} 
+  virtual void   MakeDigits(TObject * )            {AliInfo("To ne implemented by detectors");} 
+  //  virtual void   MakeRecParticles(TClonesArray * ) {AliInfo("To ne implemented by detectors");} 
+  virtual void   MakeRecPoints(TTree * )           {AliInfo("To ne implemented by detectors");} 
+  virtual void   MakeSDigits(TObject * )           {AliInfo("To ne implemented by detectors");} 
+  //virtual void   MakeTrackSegments(TTree * )       {AliInfo("To ne implemented by detectors");} 
 
   TFile *       fOutput ;      //! output root file
   TDirectory *  fDetectorDir ; //! directory for the given detector in the file
-  TObject *     fData ;        //! data container 
   static TString fDetectorDirName ; //! detector directory name in the quality assurance data file
   ClassDef(AliQualAssDataMaker,1)  // description 
 
index f98c6dd..6e89804 100644 (file)
@@ -574,7 +574,6 @@ Bool_t AliReconstruction::Run(const char* input)
     if (!gGeoManager) if (fStopOnError) return kFALSE;
   }
 
-  AliCDBManager* man = AliCDBManager::Instance();
   if (!MisalignGeometry(fLoadAlignData)) if (fStopOnError) return kFALSE;
 
   // local reconstruction
@@ -670,16 +669,6 @@ Bool_t AliReconstruction::Run(const char* input)
   if (fRawReader) fRawReader->RewindEvents();
    TString detStr(fFillESD) ; 
 
-// initialises quality assurance for ESDs
-   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
-    if (!IsSelected(fgkDetectorName[iDet], detStr)) 
-     continue;
-    AliQualAssDataMaker * qadm = GetQualAssDataMaker(iDet);
-    if (!qadm) 
-     continue;
-    qadm->Init(AliQualAss::kESDS) ; 
-    }
-  
   ProcInfo_t ProcInfo;
   gSystem->GetProcInfo(&ProcInfo);
   AliInfo(Form("Current memory usage %d %d", ProcInfo.fMemResident, ProcInfo.fMemVirtual));
@@ -867,8 +856,8 @@ Bool_t AliReconstruction::Run(const char* input)
        if (!IsSelected(fgkDetectorName[iDet], detStr)) 
                continue;
     AliQualAssDataMaker * qadm = GetQualAssDataMaker(iDet);
-    if (!qadm) 
-               continue;
+    if (!qadm) continue;
+    qadm->Finish(AliQualAss::kRECPOINTS);
     qadm->Finish(AliQualAss::kESDS) ; 
   }
 
@@ -919,49 +908,49 @@ Bool_t AliReconstruction::RunLocalReconstruction(const TString& detectors)
 
   AliCodeTimerAuto("")
 
-  AliCDBManager* man = AliCDBManager::Instance();
-  Bool_t origCache = man->GetCacheFlag();
+ //  AliCDBManager* man = AliCDBManager::Instance();
+//   Bool_t origCache = man->GetCacheFlag();
 
-  TString detStr = detectors;
-  for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
-    if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
-    AliReconstructor* reconstructor = GetReconstructor(iDet);
-    if (!reconstructor) continue;
-    if (reconstructor->HasLocalReconstruction()) continue;
+//   TString detStr = detectors;
+//   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+//     if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
+//     AliReconstructor* reconstructor = GetReconstructor(iDet);
+//     if (!reconstructor) continue;
+//     if (reconstructor->HasLocalReconstruction()) continue;
 
-    AliCodeTimerStart(Form("running reconstruction for %s", fgkDetectorName[iDet]));
-    AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
+//     AliCodeTimerStart(Form("running reconstruction for %s", fgkDetectorName[iDet]));
+//     AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
     
-    AliCodeTimerStart(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));                          
-    AliInfo(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
+//     AliCodeTimerStart(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));                          
+//     AliInfo(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
 
-    man->SetCacheFlag(kTRUE);
-    TString calibPath = Form("%s/Calib/*", fgkDetectorName[iDet]);
-    man->GetAll(calibPath); // entries are cached!
+//     man->SetCacheFlag(kTRUE);
+//     TString calibPath = Form("%s/Calib/*", fgkDetectorName[iDet]);
+//     man->GetAll(calibPath); // entries are cached!
 
-    AliCodeTimerStop(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
+//     AliCodeTimerStop(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
      
-    if (fRawReader) {
-      fRawReader->RewindEvents();
-      reconstructor->Reconstruct(fRunLoader, fRawReader);
-    } else {
-      reconstructor->Reconstruct(fRunLoader);
-    }
+//     if (fRawReader) {
+//       fRawReader->RewindEvents();
+//       reconstructor->Reconstruct(fRunLoader, fRawReader);
+//     } else {
+//       reconstructor->Reconstruct(fRunLoader);
+//     }
      
-     AliCodeTimerStop(Form("running reconstruction for %s", fgkDetectorName[iDet]));
+//      AliCodeTimerStop(Form("running reconstruction for %s", fgkDetectorName[iDet]));
 
-    // unload calibration data
-    man->UnloadFromCache(calibPath);
-    //man->ClearCache();
-  }
+//     // unload calibration data
+//     man->UnloadFromCache(calibPath);
+//     //man->ClearCache();
+//   }
 
-  man->SetCacheFlag(origCache);
+//   man->SetCacheFlag(origCache);
 
-  if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
-    AliError(Form("the following detectors were not found: %s",
-                  detStr.Data()));
-    if (fStopOnError) return kFALSE;
-  }
+//   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
+//     AliError(Form("the following detectors were not found: %s",
+//                   detStr.Data()));
+//     if (fStopOnError) return kFALSE;
+//   }
 
   return kTRUE;
 }
@@ -979,6 +968,10 @@ Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
     AliReconstructor* reconstructor = GetReconstructor(iDet);
     if (!reconstructor) continue;
     AliLoader* loader = fLoader[iDet];
+    if (!loader) {
+      AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet]));
+      continue;
+    }
 
     // conversion of digits
     if (fRawReader && reconstructor->HasDigitConversion()) {
@@ -996,7 +989,6 @@ Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
     }
 
     // local reconstruction
-    if (!reconstructor->HasLocalReconstruction()) continue;
     AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
     AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]));
     loader->LoadRecPoints("update");
@@ -1016,6 +1008,15 @@ Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
       }
       loader->UnloadDigits();
     }
+
+    AliQualAssDataMaker * qadm = GetQualAssDataMaker(iDet);
+    if (qadm) {
+      AliCodeTimerStart(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
+      AliInfo(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
+      qadm->Exec(AliQualAss::kRECPOINTS, clustersTree) ; 
+      AliCodeTimerStop(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
+    }
+
     loader->WriteRecPoints("OVERWRITE");
     loader->UnloadRecPoints();
   }
@@ -1108,7 +1109,7 @@ Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd)
     TString detName = fgkDetectorName[iDet];
     AliDebug(1, Form("%s HLT tracking", detName.Data()));
     reconstructor->SetOption(detName.Data());
-    AliTracker *tracker = reconstructor->CreateTracker(fRunLoader);
+    AliTracker *tracker = reconstructor->CreateTracker();
     if (!tracker) {
       AliWarning(Form("couldn't create a HLT tracker for %s", detName.Data()));
       if (fStopOnError) return kFALSE;
@@ -1163,7 +1164,7 @@ Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
   
   TString detName = fgkDetectorName[iDet];
   AliDebug(1, Form("%s tracking", detName.Data()));
-  AliTracker *tracker =  reconstructor->CreateTracker(fRunLoader);
+  AliTracker *tracker =  reconstructor->CreateTracker();
   if (!tracker) {
     AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
     return kFALSE;
@@ -1211,8 +1212,11 @@ Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd)
   AliInfo("running tracking");
 
   //Fill the ESD with the T0 info (will be used by the TOF) 
-  if (fReconstructor[11])
-      GetReconstructor(11)->FillESD(fRunLoader, esd);
+  if (fReconstructor[11] && fLoader[11]) {
+    fLoader[11]->LoadRecPoints("READ");
+    TTree *treeR = fLoader[11]->TreeR();
+    GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd);
+  }
 
   // pass 1: TPC + ITS inwards
   for (Int_t iDet = 1; iDet >= 0; iDet--) {
@@ -1238,7 +1242,6 @@ Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd)
     }
     // preliminary PID in TPC needed by the ITS tracker
     if (iDet == 1) {
-      GetReconstructor(1)->FillESD(fRunLoader, esd);
       GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
       AliESDpid::MakePID(esd);
     }
@@ -1277,7 +1280,6 @@ Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd)
     }
     // updated PID in TPC needed by the ITS tracker -MI
     if (iDet == 1) {
-      GetReconstructor(1)->FillESD(fRunLoader, esd);
       GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
       AliESDpid::MakePID(esd);
     }
@@ -1367,7 +1369,7 @@ Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors)
     if (!ReadESD(esd, fgkDetectorName[iDet])) {
       AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
       TTree* clustersTree = NULL;
-      if (reconstructor->HasLocalReconstruction() && fLoader[iDet]) {
+      if (fLoader[iDet]) {
        fLoader[iDet]->LoadRecPoints("read");
        clustersTree = fLoader[iDet]->TreeR();
        if (!clustersTree) {
@@ -1392,15 +1394,10 @@ Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors)
        reconstructor->FillESD(digitsTree, clustersTree, esd);
        if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
       }
-      if (reconstructor->HasLocalReconstruction() && fLoader[iDet]) {
+      if (fLoader[iDet]) {
        fLoader[iDet]->UnloadRecPoints();
       }
 
-      if (fRawReader) {
-        reconstructor->FillESD(fRunLoader, fRawReader, esd);
-      } else {
-        reconstructor->FillESD(fRunLoader, esd);
-      }
       if (fCheckPointLevel > 2) WriteESD(esd, fgkDetectorName[iDet]);
     }
   }
@@ -1648,7 +1645,7 @@ AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet)
   if (reconstructor) {
     TObject* obj = fOptions.FindObject(detName.Data());
     if (obj) reconstructor->SetOption(obj->GetTitle());
-    reconstructor->Init(fRunLoader);
+    reconstructor->Init();
     fReconstructor[iDet] = reconstructor;
   }
 
@@ -1702,7 +1699,7 @@ Bool_t AliReconstruction::CreateVertexer()
   fVertexer = NULL;
   AliReconstructor* itsReconstructor = GetReconstructor(0);
   if (itsReconstructor) {
-    fVertexer = itsReconstructor->CreateVertexer(fRunLoader);
+    fVertexer = itsReconstructor->CreateVertexer();
   }
   if (!fVertexer) {
     AliWarning("couldn't create a vertexer for ITS");
@@ -1733,7 +1730,7 @@ Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
     }
 
 
-    fTracker[iDet] = reconstructor->CreateTracker(fRunLoader);
+    fTracker[iDet] = reconstructor->CreateTracker();
     if (!fTracker[iDet] && (iDet < 7)) {
       AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
       if (fStopOnError) return kFALSE;
@@ -2700,48 +2697,12 @@ AliQualAssDataMaker * AliReconstruction::GetQualAssDataMaker(Int_t iDet)
     qadm = (AliQualAssDataMaker *) pluginHandler->ExecPlugin(0);
   }
   if (qadm) {
-    // TObject* obj = fOptions.FindObject(detName.Data());
-    //     if (obj) reconstructor->SetOption(obj->GetTitle());
+    AliInfo(Form("Initializing quality assurance data maker for %s", fgkDetectorName[iDet]));
+    qadm->Init(AliQualAss::kRECPOINTS);
+    qadm->Init(AliQualAss::kESDS) ; 
     fQualAssDataMaker[iDet] = qadm;
   }
 
-  // get or create the loader
-  fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
-  if (!fLoader[iDet]) {
-    AliConfig::Instance()
-       ->CreateDetectorFolders(fRunLoader->GetEventFolder(), 
-                               detName, detName);
-    // first check if a plugin is defined for the loader
-    pluginHandler = 
-      pluginManager->FindHandler("AliLoader", detName);
-    // if not, add a plugin for it
-    if (!pluginHandler) {
-      TString loaderName = "Ali" + detName + "Loader";
-      AliDebug(1, Form("defining plugin for %s", loaderName.Data()));
-      pluginManager->AddHandler("AliLoader", detName, 
-                               loaderName, detName + "base", 
-                               loaderName + "(const char*, TFolder*)");
-      pluginHandler = pluginManager->FindHandler("AliLoader", detName);
-    }
-    if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
-      fLoader[iDet] = 
-       (AliLoader*) pluginHandler->ExecPlugin(2, detName.Data(), 
-                                              fRunLoader->GetEventFolder());
-    }
-    if (!fLoader[iDet]) {   // use default loader
-      fLoader[iDet] = new AliLoader(detName, fRunLoader->GetEventFolder());
-    }
-    if (!fLoader[iDet]) {
-      AliWarning(Form("couldn't get loader for %s", detName.Data()));
-      if (fStopOnError) return NULL;
-    } else {
-      fRunLoader->AddLoader(fLoader[iDet]);
-      fRunLoader->CdGAFile();
-      if (gFile && !gFile->IsWritable()) gFile->ReOpen("UPDATE");
-      fRunLoader->Write(0, TObject::kOverwrite);
-    }
-  }
-      
   return qadm;
 }
 
@@ -2761,8 +2722,7 @@ Bool_t AliReconstruction::RunQualAss(const char* detectors, AliESDEvent *& esd)
    AliCodeTimerStart(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
    AliInfo(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
     
-   qadm->SetData(esd) ; 
-   qadm->Exec(AliQualAss::kESDS) ; 
+   qadm->Exec(AliQualAss::kESDS, esd) ; 
 
    AliCodeTimerStop(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
  }
index 3aa7c68..a003f2e 100644 (file)
@@ -71,24 +71,6 @@ void AliReconstructor::Reconstruct(AliRawReader* /*rawReader*/,
 }
 
 //_____________________________________________________________________________
-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
 {
@@ -108,26 +90,6 @@ void AliReconstructor::FillESD(AliRawReader* /*rawReader*/,
 }
 
 //_____________________________________________________________________________
-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
 {
 // get the name of the detector
index 7d62e5e..518f805 100644 (file)
@@ -15,7 +15,6 @@
 #include <TString.h>
 
 class TTree;
-class AliRunLoader;
 class AliRawReader;
 class AliVertexer;
 class AliTracker;
@@ -27,30 +26,23 @@ public:
   AliReconstructor(): TObject(), fOption() {};
   virtual ~AliReconstructor() {};
 
-  virtual void         Init(AliRunLoader* /*runLoader*/) {};
+  virtual void         Init() {};
 
   virtual Bool_t       HasDigitConversion() const {return kFALSE;};
   virtual void         ConvertDigits(AliRawReader* rawReader, TTree* digitsTree) const;
 
-  virtual Bool_t       HasLocalReconstruction() const {return kFALSE;};
   virtual void         Reconstruct(TTree* digitsTree, TTree* clustersTree) const;
   virtual void         Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const;
-  virtual void         Reconstruct(AliRunLoader* runLoader) const;
-  virtual void         Reconstruct(AliRunLoader* runLoader, 
-                                  AliRawReader* rawReader) const;
 
-  virtual AliVertexer* CreateVertexer(AliRunLoader* /*runLoader*/) const 
+  virtual AliVertexer* CreateVertexer() const 
     {return NULL;}
-  virtual AliTracker*  CreateTracker(AliRunLoader* /*runLoader*/) const 
+  virtual AliTracker*  CreateTracker() const 
     {return NULL;}
 
   virtual void         FillESD(TTree* digitsTree, TTree* clustersTree, 
                               AliESDEvent* esd) const;
   virtual void         FillESD(AliRawReader* rawReader, TTree* clustersTree, 
                               AliESDEvent* esd) const;
-  virtual void         FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const;
-  virtual void         FillESD(AliRunLoader* runLoader, 
-                              AliRawReader* rawReader, AliESDEvent* esd) const;
 
   virtual const char*  GetDetectorName() const;
 
index e883605..9ae8e78 100644 (file)
 ClassImp(AliT0Reconstructor)
 
   AliT0Reconstructor:: AliT0Reconstructor(): AliReconstructor(),
-                                            fZposition(0)
-
+  fZposition(0),
+  fParam(NULL),
+  fAmpLEDrec(),
+  fdZ_A(0),
+  fdZ_C(0)
 {
  AliDebug(1,"Start reconstructor ");
   
@@ -67,8 +70,12 @@ ClassImp(AliT0Reconstructor)
 //____________________________________________________________________
 
 AliT0Reconstructor::AliT0Reconstructor(const AliT0Reconstructor &r):
-  fZposition(0)
-  
+  AliReconstructor(r),
+  fZposition(0),
+  fParam(NULL),
+  fAmpLEDrec(),
+  fdZ_A(0),
+  fdZ_C(0)
 {
   //
   // AliT0Reconstructor copy constructor
@@ -328,26 +335,16 @@ void AliT0Reconstructor::Reconstruct(AliRawReader* rawReader, TTree*recTree) con
 }
 //____________________________________________________________
 
-void AliT0Reconstructor::FillESD(AliRunLoader* runLoader, AliESDEvent *pESD) const
+void AliT0Reconstructor::FillESD(TTree */*digitsTree*/, TTree *clustersTree, AliESDEvent *pESD) const
 {
 
   /***************************************************
   Resonstruct digits to vertex position
   ****************************************************/
   
-  
-  if (!runLoader) {
-    AliError("Reconstruct >> No run loader");
-    return;
-  }
-  
   AliDebug(1,Form("Start FillESD T0"));
 
-  AliT0Loader* pStartLoader = (AliT0Loader*) runLoader->GetLoader("T0Loader");
-  pStartLoader->LoadRecPoints("READ");
-
-  TTree *treeR = pStartLoader->TreeR();
+  TTree *treeR = clustersTree;
   
    AliT0RecPoint* frecpoints= new AliT0RecPoint ();
     if (!frecpoints) {
@@ -381,8 +378,6 @@ void AliT0Reconstructor::FillESD(AliRunLoader* runLoader, AliESDEvent *pESD) con
  
     AliDebug(1,Form(" Z position %f cm,  T0  %f ps",Zposition , timeStart));
 
-    pStartLoader->UnloadRecPoints();
-   
 } // vertex in 3 sigma
 
 
index a26a2a0..5737da8 100644 (file)
@@ -8,7 +8,6 @@
 #include "AliReconstructor.h"
 #include "AliT0digit.h"
 #include "AliT0.h"
-class AliRunLoader;
 
 class AliT0Reconstructor: public AliReconstructor {
  public:
@@ -18,20 +17,13 @@ class AliT0Reconstructor: public AliReconstructor {
   AliT0Reconstructor& operator=(const AliT0Reconstructor&); 
 
 
-   virtual  void   Reconstruct(TTree* fdigits, TTree * frecpoints) const;
-  //   virtual  void   Reconstruct(TTree* , TTree * ) const {};
-//  virtual  void   Reconstruct(TTree* , TTree * ) const {};
-  virtual  void   Reconstruct(AliRunLoader* , AliRawReader*   ) const {};
-  virtual  void   Reconstruct(AliRawReader* ) const {};
+  virtual  void   Reconstruct(TTree* fdigits, TTree * frecpoints) const;
   virtual  void   Reconstruct(AliRawReader*rawReader , TTree* recTree) const;
-  virtual  void   Reconstruct(AliRunLoader* ) const  {};
   
-  virtual void         FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const;
-  virtual void         FillESD(AliRunLoader* , AliRawReader*, AliESDEvent* ) const  {};
-  virtual void         FillESD(  AliRawReader*,  TTree*, AliESDEvent* ) const  {};
-  virtual void         FillESD( TTree*,  TTree*, AliESDEvent* ) const  {};
-  virtual Bool_t       HasLocalReconstruction() const {return kTRUE;}
+  virtual void         FillESD( AliRawReader*,  TTree*clustersTree, AliESDEvent*esd ) const
+  {FillESD((TTree*)NULL,clustersTree,esd);}
+  virtual void         FillESD( TTree*,  TTree*, AliESDEvent* ) const;
+
   virtual Bool_t       HasDigitConversion() const {return kFALSE;}
  public:
  
index 70bad52..5a17ed0 100644 (file)
@@ -25,7 +25,6 @@
 
 #include "AliLog.h"
 #include "AliRawReader.h"
-#include "AliRunLoader.h"
 
 #include "AliTOFClusterFinder.h"
 #include "AliTOFGeometry.h"
@@ -93,40 +92,6 @@ AliTOFReconstructor::~AliTOFReconstructor()
 }
 
 //_____________________________________________________________________________
-  void AliTOFReconstructor::Reconstruct(AliRunLoader* runLoader) const
-{
-// reconstruct clusters from digits
-
-  AliTOFClusterFinder tofClus(runLoader, fTOFcalib);
-  tofClus.Load();
-  for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++)
-    {
-      AliDebug(2,Form("Local Event loop mode: Creating Recpoints from Digits, Event n. %i",iEvent)); 
-      tofClus.Digits2RecPoints(iEvent);
-    }
-  tofClus.UnLoad();
-
-}
-
-//_____________________________________________________________________________
-void AliTOFReconstructor::Reconstruct(AliRunLoader* runLoader,
-                                      AliRawReader *rawReader) const
-{
-// reconstruct clusters from Raw Data
-
-  AliTOFClusterFinder tofClus(runLoader, fTOFcalib);
-  tofClus.LoadClusters();
-  Int_t iEvent = 0;
-  while (rawReader->NextEvent()) {
-    AliDebug(2,Form("Local Event loop mode: Creating Recpoints from Raw data, Event n. %i",iEvent)); 
-    tofClus.Digits2RecPoints(iEvent,rawReader);
-    iEvent++;
-  }
-  tofClus.UnLoadClusters();
-
-}
-
-//_____________________________________________________________________________
 void AliTOFReconstructor::Reconstruct(AliRawReader *rawReader,
                                       TTree *clustersTree) const
 {
@@ -160,7 +125,7 @@ void AliTOFReconstructor::Reconstruct(TTree *digitsTree,
 }
 
 //_____________________________________________________________________________
-AliTracker* AliTOFReconstructor::CreateTracker(AliRunLoader* /*runLoader*/) const
+AliTracker* AliTOFReconstructor::CreateTracker() const
 {
 // create a TOF tracker
 
@@ -171,37 +136,8 @@ AliTracker* AliTOFReconstructor::CreateTracker(AliRunLoader* /*runLoader*/) cons
 }
 
 //_____________________________________________________________________________
-void AliTOFReconstructor::FillESD(AliRunLoader* /*runLoader*/, 
-                                 AliESDEvent* /*esd*/) const
-{
-// nothing to be done
-
-}
-
-//_____________________________________________________________________________
-AliTOFGeometry* AliTOFReconstructor::GetTOFGeometry(AliRunLoader* runLoader) const
+AliTOFGeometry* AliTOFReconstructor::GetTOFGeometry() const
 {
-// get the TOF parameters
-
-  AliTOFGeometry *tofGeom;
-
-  runLoader->CdGAFile();
-  TDirectory *savedir=gDirectory; 
-  TFile *in=(TFile*)gFile;  
-  if (!in->IsOpen()) {
-    AliWarning("Geometry file is not open default  TOF geometry will be used");
-    tofGeom = new AliTOFGeometryV5();
-  }
-  else {
-    in->cd();  
-    tofGeom = (AliTOFGeometry*) in->Get("TOFgeometry");
-  }
-
-  savedir->cd();  
-
-  if (!tofGeom) {
-    AliError("no TOF geometry available");
-    return NULL;
-  }
-  return tofGeom;
+  // get the TOF geometry
+  return fTOFGeometry;
 }
index b191bb2..34f42f1 100644 (file)
@@ -18,7 +18,6 @@ class TTree;
 
 class AliESDEvent;
 class AliRawReader;
-class AliRunLoader;
 
 class AliTOFGeometry;
 class AliTOFcalib;
@@ -30,26 +29,24 @@ public:
   AliTOFReconstructor& operator=(const AliTOFReconstructor &source); // ass. op.
   virtual ~AliTOFReconstructor();
 
-  virtual Bool_t       HasLocalReconstruction() const { return kTRUE; }
-  virtual void         Reconstruct(AliRunLoader* runLoader) const;
-  virtual void         Reconstruct(AliRunLoader* runLoader,
-                                  AliRawReader* rawReader) const;
   virtual void         Reconstruct(AliRawReader* rawReader,
                                   TTree* clusterTree) const;
   virtual void         Reconstruct(TTree* digitsTree, TTree* clusterTree) const;
+
   virtual void         ConvertDigits(AliRawReader* reader, TTree* digitsTree) const;
-  virtual AliTracker*  CreateTracker(AliRunLoader* runLoader) const;
-  virtual void         FillESD(AliRunLoader*, AliRawReader*, AliESDEvent*) const { };
-  virtual void         FillESD(AliRawReader*, TTree*, AliESDEvent*) const { };
-  virtual void         FillESD(TTree*, TTree*, AliESDEvent*) const { };
-  virtual void         FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const;
+
+  virtual AliTracker*  CreateTracker() const;
+
+  virtual void         FillESD(AliRawReader*, TTree*clustersTree, AliESDEvent*esd) const
+  {FillESD((TTree*)NULL,clustersTree,esd);}
+  virtual void         FillESD(TTree*, TTree*, AliESDEvent*) const {}
 
 private:
   AliTOFGeometry *fTOFGeometry; // pointer to TOF geometry
   AliTOFcalib    *fTOFcalib;    // pointer to TOF calib class
-  AliTOFGeometry*      GetTOFGeometry(AliRunLoader* runLoader) const;
+  AliTOFGeometry*      GetTOFGeometry() const;
 
-  ClassDef(AliTOFReconstructor, 1)   // class for the TOF reconstruction
+  ClassDef(AliTOFReconstructor, 2)   // class for the TOF reconstruction
 };
 
 #endif
index c59d414..780e09e 100644 (file)
@@ -68,46 +68,6 @@ AliTPCReconstructor::~AliTPCReconstructor()
 }
 
 //_____________________________________________________________________________
-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
   // of TPC data
@@ -117,42 +77,6 @@ void AliTPCReconstructor::Reconstruct(TTree* digitsTree, TTree* clustersTree) co
 }
 
 //_____________________________________________________________________________
-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
   // of TPC data starting from raw data
@@ -165,7 +89,7 @@ void AliTPCReconstructor::Reconstruct(AliRawReader* rawReader, TTree* clustersTr
 }
 
 //_____________________________________________________________________________
-AliTracker* AliTPCReconstructor::CreateTracker(AliRunLoader* /* runLoader */) const
+AliTracker* AliTPCReconstructor::CreateTracker() const
 {
 // create a TPC tracker
 
@@ -179,7 +103,7 @@ AliTracker* AliTPCReconstructor::CreateTracker(AliRunLoader* /* runLoader */) co
 }
 
 //_____________________________________________________________________________
-void AliTPCReconstructor::FillESD(AliRunLoader* /*runLoader*/, 
+void AliTPCReconstructor::FillESD(TTree */*digitsTree*/, TTree */*clustersTree*/,
                                  AliESDEvent* esd) const
 {
 // make PID
index c69c428..df77a6d 100644 (file)
@@ -16,27 +16,16 @@ public:
   AliTPCReconstructor();
   virtual ~AliTPCReconstructor();
 
-  virtual Bool_t       HasLocalReconstruction() const {return kTRUE;}
-  virtual void         Reconstruct(AliRunLoader* runLoader) const;
-  virtual void         Reconstruct(AliRunLoader* runLoader,
-                                  AliRawReader* rawReader) const;
   virtual void         Reconstruct(TTree* digitsTree, TTree* clustersTree) const;
   virtual void         Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const;
 
-  virtual AliTracker*  CreateTracker(AliRunLoader* runLoader) const;
-  virtual void         FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const;
-  virtual void         FillESD(TTree* digitsTree, TTree* clustersTree, 
-                              AliESDEvent* esd) const {
-    AliReconstructor::FillESD(digitsTree,clustersTree,esd);
-  }
-  virtual void         FillESD(AliRawReader* rawReader, TTree* clustersTree, 
-                              AliESDEvent* esd) const {
-    AliReconstructor::FillESD(rawReader,clustersTree,esd);
-  }
-  virtual void         FillESD(AliRunLoader* runLoader, 
-                              AliRawReader* rawReader, AliESDEvent* esd) const {
-    AliReconstructor::FillESD(runLoader,rawReader,esd);
-  }
+  virtual AliTracker*  CreateTracker() const;
+
+  virtual void         FillESD(TTree* /*digitsTree*/, TTree* /*clustersTree*/, 
+                              AliESDEvent* esd) const;
+  virtual void         FillESD(AliRawReader* /*rawReader*/, TTree* /*clustersTree*/, 
+                              AliESDEvent* esd) const
+  {FillESD((TTree*)NULL,(TTree*)NULL,esd);}
 
   void SetRecoParam(AliTPCRecoParam * param){ fgkRecoParam = param;}
   static const AliTPCRecoParam* GetRecoParam(){ return fgkRecoParam;}
index 3c881b3..1d345a8 100644 (file)
@@ -61,7 +61,7 @@ AliVZEROReconstructor::~AliVZEROReconstructor()
 }
 
 //_____________________________________________________________________________
-void AliVZEROReconstructor::Init(AliRunLoader* /*runLoader*/)
+void AliVZEROReconstructor::Init()
 {
 // initializer
 
index 691c20e..eb252da 100644 (file)
@@ -25,21 +25,13 @@ class AliVZEROReconstructor: public AliReconstructor {
 public:
   AliVZEROReconstructor();
   virtual ~AliVZEROReconstructor();
-  virtual void   Init(AliRunLoader* /*runLoader*/);
-  virtual void   Reconstruct(AliRunLoader* /*runLoader*/) const {
-    AliError("Method not implemented"); return;};
+  virtual void   Init();
   
   virtual void   Reconstruct(AliRawReader* /*rawReader*/, 
                             TTree* /*clustersTree*/) const {
     AliError("Method not implemented"); return;};
-  virtual void   Reconstruct(AliRunLoader* /*runLoader*/, 
-                             AliRawReader* /*rawReader*/) const {
-    AliError("Method not implemented"); return;};
   virtual void   Reconstruct(TTree*, TTree*) const {return;};
   
-  virtual void   FillESD(AliRunLoader* /*runLoader*/, AliESDEvent* /*esd*/) const {
-    AliInfo("Method is not used"); return;};
-  
   virtual void   FillESD(TTree* digitsTree, TTree* /*clustersTree*/, 
                         AliESDEvent* esd) const;
 
@@ -47,14 +39,9 @@ public:
                         AliESDEvent* /*esd*/) const {
     AliError("Method not implemented"); return;};
   
-  virtual void   FillESD(AliRunLoader* /*runLoader*/, 
-                        AliRawReader* /*rawReader*/, AliESDEvent* /*esd*/) const {
-    AliInfo("Method is not used"); return;};
-  
   virtual Bool_t HasDigitConversion() const { return kTRUE; }
   virtual void   ConvertDigits(AliRawReader* rawReader,
                               TTree* digitsTree) const;
-  virtual Bool_t HasLocalReconstruction() const { return kTRUE; }
 
   AliCDBStorage     *SetStorage(const char* uri);
   AliVZEROCalibData *GetCalibData() const;