Major rewriting using VStores, and trying to implement all methods required by the...
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 17 Jun 2007 20:53:40 +0000 (20:53 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 17 Jun 2007 20:53:40 +0000 (20:53 +0000)
MUON/AliMUONReconstructor.cxx
MUON/AliMUONReconstructor.h

index 767c35f..ffa9619 100644 (file)
  **************************************************************************/
 /* $Id$ */
 
-//-----------------------------
-// Class AliMUONReconstructor  
-//-----------------------------
-// Class for the 
-// MUON track reconstruction
+/// \class AliMUONReconstructor
+///
+/// Implementation of AliReconstructor for MUON subsystem.
+///
+/// The behavior of the MUON reconstruction can be changed, besides
+/// the usual methods found in AliReconstruction (e.g. to disable tracking)
+/// by using AliReconstruction::SetOption("MUON",options)
+/// where options should be a space separated string.
+///
+/// Valid options are :
+///
+/// SAVEDIGITS : if you want to save in the TreeD the *calibrated* digits
+///     that are used for the clustering
+///
+/// SIMPLEFIT : use the AliMUONClusterFinderSimpleFit clusterizer
+///
+/// AZ : use the AliMUONClusterFinderAZ clusterizer (default)
+///
+/// PRECLUSTER : use only AliMUONPreClusterFinder. Only for debug as
+/// the produced clusters do not have a position, hence the tracking will not
+/// work
+///
+/// COG : use AliMUONClusterFinderCOG clusterizer. Not really a production
+/// option either, as center-of-gravity is generally not a good estimate
+/// of the cluster position...
+///
+/// NOCLUSTERING : bypass completely the clustering stage
+///
+/// NOSTATUSMAP : disable the computation and usage of the pad status map. Only
+/// for debug !
+///
+/// NOLOCALRECONSTRUCTION : for debug, to disable local reconstruction (and hence
+/// "recover" old behavior)
+///
+/// TRIGGERDISABLE : disable the treatment of MUON trigger
+///
+/// \author Laurent Aphecetche, Subatech
 
 #include "AliMUONReconstructor.h"
 
-#include "AliMUONConstants.h"
+#include "AliCDBManager.h"
+#include "AliLoader.h"
+#include "AliLog.h"
+#include "AliRunLoader.h"
 #include "AliMUONCalibrationData.h"
+#include "AliMUONClusterFinderCOG.h"
+#include "AliMUONClusterFinderMLEM.h"
+#include "AliMUONClusterFinderSimpleFit.h"
 #include "AliMUONClusterFinderAZ.h"
 #include "AliMUONClusterReconstructor.h"
-#include "AliMUONRecData.h"
+#include "AliMUONClusterStoreV1.h"
+#include "AliMUONConstants.h"
 #include "AliMUONDigitCalibrator.h"
-#include "AliMUONEventRecoCombi.h" 
 #include "AliMUONDigitMaker.h"
-#include "AliMUONTrack.h"
-#include "AliMUONTrackParam.h"
-#include "AliMUONTrackExtrap.h"
+#include "AliMUONDigitStoreV1.h"
+#include "AliMUONGeometryTransformer.h"
+#include "AliMUONPreClusterFinder.h"
 #include "AliMUONTracker.h"
-#include "AliMUONVTrackReconstructor.h"
-#include "AliMUONTrackReconstructor.h"
-#include "AliMUONTrackReconstructorK.h"
-#include "AliMUONTriggerTrack.h"
+#include "AliMUONVTrackStore.h"
 #include "AliMUONTriggerCircuit.h"
 #include "AliMUONTriggerCrateStore.h"
-#include "AliMUONSegFactory.h"
-#include "AliMUONSegmentation.h"
-#include "AliMUONPreClusterFinder.h"
-#include "AliMUONClusterFinderCOG.h"
-#include "AliMUONClusterFinderSimpleFit.h"
-#include "AliMUONClusterFinderMLEM.h"
-
-#include "AliESD.h"
-#include "AliESDMuonTrack.h"
-#include "AliLog.h"
+#include "AliMUONTriggerStoreV1.h"
+#include "AliMUONVClusterFinder.h"
 #include "AliRawReader.h"
-#include "AliRunLoader.h"
-#include "AliCDBManager.h"
-
-#include "TTask.h"
-#include "TStopwatch.h"
-#include "Riostream.h"
+#include "AliMUONStopwatchGroup.h"
+#include "AliMUONStopwatchGroupElement.h"
+#include <Riostream.h>
+#include <TClonesArray.h>
+#include <TString.h>
+#include <TTree.h>
 
 /// \cond CLASSIMP
 ClassImp(AliMUONReconstructor)
-/// \endcond
+/// \endcond 
 
 //_____________________________________________________________________________
-AliMUONReconstructor::AliMUONReconstructor()
-  : AliReconstructor(), 
-    fDigitMaker(new AliMUONDigitMaker()), 
-    fCalibrationData(0x0),
-    fCrateManager(new AliMUONTriggerCrateStore()),
-    fTriggerCircuit(new TClonesArray("AliMUONTriggerCircuit", 234)),
-    fTransformer(new AliMUONGeometryTransformer(kTRUE)),
-    fSegmentation(0x0),
-    fMUONData(new AliMUONRecData(0x0,"MUON","MUON"))
+AliMUONReconstructor::AliMUONReconstructor() : 
+AliReconstructor(),
+fCrateManager(0x0),
+fDigitMaker(0x0),
+fTransformer(new AliMUONGeometryTransformer(kTRUE)),
+fDigitStore(0x0),
+fTriggerCircuit(0x0),
+fCalibrationData(0x0),
+fDigitCalibrator(0x0),
+fClusterReconstructor(0x0),
+fClusterStore(0x0),
+fTriggerStore(0x0),
+fTrackStore(0x0),
+fTimers(new AliMUONStopwatchGroup)
 {
-/// Default constructor
+  /// normal ctor
+  fTransformer->ReadGeometryData("volpath.dat", "geometry.root");
+}
 
-    AliDebug(1,"");
-    // Crate manager
-    fCrateManager->ReadFromFile();
+//_____________________________________________________________________________
+AliMUONReconstructor::~AliMUONReconstructor()
+{
+  /// dtor
+  delete fDigitMaker;
+  delete fDigitStore;
+  delete fTransformer;
+  delete fCrateManager;
+  delete fTriggerCircuit;
+  delete fCalibrationData;
+  delete fDigitCalibrator;
+  delete fClusterReconstructor;
+  delete fClusterStore;
+  delete fTriggerStore;
+  delete fTrackStore;
+  AliInfo("Timers:");
+  fTimers->Print();
+  delete fTimers;
+}
 
-    // set to digit maker
-    fDigitMaker->SetCrateManager(fCrateManager);
+//_____________________________________________________________________________
+void
+AliMUONReconstructor::Calibrate(AliMUONVDigitStore& digitStore) const
+{
+  /// Calibrate the digitStore
+  if (!fDigitCalibrator)
+  {
+    CreateCalibrator();
+  }
+  AliMUONStopwatchGroupElement timer(fTimers,"MUON",Form("%s::Calibrate(AliMUONVDigitStore*)",fDigitCalibrator->ClassName()));
+  fDigitCalibrator->Calibrate(digitStore);  
+}
 
-    // transformater
-    fTransformer->ReadGeometryData("volpath.dat", "geometry.root");
-    
-    // create segmentation and pass it to EventRecoCombi
-    AliMUONSegFactory factory(fTransformer);
-    fSegmentation = factory.CreateSegmentation();
-    AliMUONEventRecoCombi::Instance(fSegmentation); 
-
-    // trigger circuit
-    for (Int_t i = 0; i < AliMUONConstants::NTriggerCircuit(); i++)  {
-      AliMUONTriggerCircuit* c = new AliMUONTriggerCircuit();
-      c->SetTransformer(fTransformer);
-      c->Init(i,*fCrateManager);
-      TClonesArray& circuit = *fTriggerCircuit;
-      new(circuit[circuit.GetEntriesFast()])AliMUONTriggerCircuit(*c);
-      delete c;
-    }
+//_____________________________________________________________________________
+void
+AliMUONReconstructor::Clusterize(const AliMUONVDigitStore& digitStore,
+                                 AliMUONVClusterStore& clusterStore) const
+{
+  /// Creates clusters from digits.
 
+  TString sopt(GetOption());
+  sopt.ToUpper();
+  if ( sopt.Contains("NOCLUSTERING") ) return;
+  
+  if  (!fClusterReconstructor)
+  {
+    CreateClusterReconstructor();
+  }
   
+  AliMUONStopwatchGroupElement timer(fTimers,"MUON",Form("%s::Digits2Clusters(const AliMUONVDigitStore&,AliMUONVClusterStore&)",
+                                                     fClusterReconstructor->ClassName()));
+  fClusterReconstructor->Digits2Clusters(digitStore,clusterStore);  
 }
 
 //_____________________________________________________________________________
-AliMUONReconstructor::~AliMUONReconstructor()
+AliMUONVClusterStore*
+AliMUONReconstructor::ClusterStore() const
 {
-/// Destructor
+  /// Return (and create if necessary) the cluster container
+  if (!fClusterStore) 
+  {
+    fClusterStore = new AliMUONClusterStoreV1;
+  }
+  return fClusterStore;
+}
 
-  AliDebug(1,"");
-  delete fCalibrationData;
-  delete fDigitMaker;
-  delete fCrateManager;
-  delete fTriggerCircuit;
-  delete fTransformer;
-  delete fSegmentation;
-  delete fMUONData;
+//_____________________________________________________________________________
+void
+AliMUONReconstructor::ConvertDigits(AliRawReader* rawReader, 
+                                    AliMUONVDigitStore* digitStore,
+                                    AliMUONVTriggerStore* triggerStore) const
+{
+  /// Convert raw data into digit and trigger stores
+  CreateDigitMaker();
+  AliMUONStopwatchGroupElement timer(fTimers,"MUON",Form("%s::Raw2Digits(AliRawReader*,AliMUONVDigitStore*,AliMUONVTriggerStore*)",
+                                                     fDigitMaker->ClassName()));
+  fDigitMaker->Raw2Digits(rawReader,digitStore,triggerStore);
+  Calibrate(*digitStore);
 }
 
 //_____________________________________________________________________________
-TTask* 
-AliMUONReconstructor::GetCalibrationTask() const
+void 
+AliMUONReconstructor::ConvertDigits(AliRawReader* rawReader, TTree* digitsTree) const
 {
-/// Create the calibration task(s). 
+   /// convert raw data into a digit tree
+
+  Bool_t alone = ( TriggerStore() == 0 );
   
-  //const AliRun* run = fRunLoader->GetAliRun();
-  //Int_t runNumber = run->GetRunNumber();     
-  Int_t runNumber = AliCDBManager::Instance()->GetRun();
-  AliInfo("Calibration will occur.");
-  fCalibrationData = new AliMUONCalibrationData(runNumber);
-  if ( !fCalibrationData->IsValid() )
-    {
-      AliError("Could not retrieve calibrations !");
-      delete fCalibrationData;
-      fCalibrationData = 0x0;
-      return 0x0;
-    }    
-  // Check that we get all the calibrations we'll need
-  if ( !fCalibrationData->Pedestals() ||
-       !fCalibrationData->Gains() ||
-       !fCalibrationData->HV() )
+  Bool_t ok = DigitStore()->Connect(*digitsTree,alone);
+  if ( TriggerStore() ) 
   {
-    AliFatal("Could not access all required calibration data");
+    ok = ok && TriggerStore()->Connect(*digitsTree,kFALSE);
   }
-  TTask* calibration = new TTask("MUONCalibrator","MUON Digit calibrator");
   
-  TString opt(GetOption());
-  opt.ToUpper();
-  Bool_t statusMap(kTRUE);
+  if (!ok)
+  {
+    AliError("Could not make branches on TreeD");
+  }
+  else
+  {
+    ConvertDigits(rawReader,DigitStore(),TriggerStore());
+    digitsTree->Fill();
+    DigitStore()->Clear();
+  }
+}
+
+//_____________________________________________________________________________
+AliMUONTriggerCrateStore*
+AliMUONReconstructor::CrateManager() const
+{
+  /// Return (and create if necessary) the trigger crate store
+  if (fCrateManager) return fCrateManager;
+  fCrateManager = new AliMUONTriggerCrateStore;
+  fCrateManager->ReadFromFile();
+  return fCrateManager;
+}
+
+//_____________________________________________________________________________
+void
+AliMUONReconstructor::CreateDigitMaker() const
+{
+  /// Create (and create if necessary) the digit maker
+  if (fDigitMaker) return;
+
+  AliMUONStopwatchGroupElement timer(fTimers,"MUON","AliMUONReconstructor::CreateDigitMaker()");
+
+  fDigitMaker = new AliMUONDigitMaker;
+  fDigitMaker->SetCrateManager(CrateManager());
+}
+
+//_____________________________________________________________________________
+void 
+AliMUONReconstructor::CreateTriggerCircuit() const
+{
+  /// Return (and create if necessary) the trigger circuit object
+  if (fTriggerCircuit) return;
+
+  AliMUONStopwatchGroupElement timer(fTimers,"MUON","AliMUONReconstructor::CreateTriggerCircuit()");
+
+  fTriggerCircuit = new TClonesArray("AliMUONTriggerCircuit", 234);
+  for (Int_t i = 0; i < AliMUONConstants::NTriggerCircuit(); i++)  
+  {
+    AliMUONTriggerCircuit c;
+    c.SetTransformer(fTransformer);
+    c.Init(i,*(CrateManager()));
+    TClonesArray& circuit = *fTriggerCircuit;
+    new(circuit[circuit.GetEntriesFast()]) AliMUONTriggerCircuit(c);  
+  }
+}
+
+//_____________________________________________________________________________
+AliTracker* 
+AliMUONReconstructor::CreateTracker(AliRunLoader* runLoader) const
+{
+  /// Create the MUONTracker object
+  /// The MUONTracker is passed the GetOption(), i.e. our own options
   
-  if ( strstr(opt,"NOSTATUSMAP") )
+  CreateTriggerCircuit();
+  CreateDigitMaker();
+  
+  AliLoader* loader = runLoader->GetDetectorLoader("MUON");
+  if (!loader)
   {
-    AliWarning("Disconnecting status map : SHOULD BE USED FOR DEBUG ONLY. NOT FOR PRODUCTION !!!");
-    statusMap = kFALSE; 
+    AliError("Cannot get MUONLoader, so cannot create MUONTracker");
+    return 0x0;
   }
-  calibration->Add(new AliMUONDigitCalibrator(fMUONData,fCalibrationData,statusMap));
-  return calibration;
+  AliMUONTracker* tracker = new AliMUONTracker(loader,fDigitMaker,fTransformer,fTriggerCircuit);
+  tracker->SetOption(GetOption());
+  
+  return tracker;
 }
 
 //_____________________________________________________________________________
-AliMUONClusterReconstructor*
+void
 AliMUONReconstructor::CreateClusterReconstructor() const
 {
-/// Create cluster reconstructor
+  /// Create cluster reconstructor, depending on GetOption()
+  
+  AliMUONStopwatchGroupElement timer(fTimers,"MUON","AliMUONReconstructor::CreateClusterReconstructor()");
 
+  AliDebug(1,"");
+  
   AliMUONVClusterFinder* clusterFinder(0x0);
   
   TString opt(GetOption());
@@ -190,444 +316,351 @@ AliMUONReconstructor::CreateClusterReconstructor() const
   {
     clusterFinder = new AliMUONClusterFinderMLEM(kFALSE);
   } 
+  else if ( strstr(opt,"AZ") )
+  {
+    clusterFinder = new AliMUONClusterFinderAZ;
+  }
+  else
+  {
+    clusterFinder = new AliMUONClusterFinderAZ;
+  }
   
-  if ( clusterFinder) 
+  if ( clusterFinder 
   {
     AliInfo(Form("Will use %s for clusterizing",clusterFinder->ClassName()));
   }
   
-  AliMUONClusterReconstructor* clusterReco = 
-    new AliMUONClusterReconstructor(fMUONData,clusterFinder,fTransformer);
-  return clusterReco;
+  fClusterReconstructor = new AliMUONClusterReconstructor(clusterFinder,fTransformer);
 }
 
 //_____________________________________________________________________________
-void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader) const
+void
+AliMUONReconstructor::CreateCalibrator() const
 {
-/// Reconstruct
-/// \todo add more
-
-  AliLoader* loader = runLoader->GetLoader("MUONLoader");
-  Int_t nEvents     = runLoader->GetNumberOfEvents();
-  Int_t evtNumber   = runLoader->GetEventNumber();
-
-  fMUONData->SetLoader(loader);
-
-// passing loader as argument.
-  AliMUONVTrackReconstructor* recoEvent;
-  if (strstr(GetOption(),"Original")) recoEvent = new AliMUONTrackReconstructor(fMUONData);
-  else if (strstr(GetOption(),"Combi")) recoEvent = new AliMUONTrackReconstructorK(fMUONData,"Combi");
-  else recoEvent = new AliMUONTrackReconstructorK(fMUONData,"Kalman");
+  /// Create the calibrator
   
-  recoEvent->SetTriggerCircuit(fTriggerCircuit);
-
-  AliMUONClusterReconstructor* recoCluster = CreateClusterReconstructor();
+  AliMUONStopwatchGroupElement timer(fTimers,"MUON","AliMUONReconstructor::CreateCalibrator()");
   
-  AliMUONClusterFinderVS *recModel = recoCluster->GetRecoModel();
+  Int_t runNumber = AliCDBManager::Instance()->GetRun();
 
-  if (!strstr(GetOption(),"VS")) {
-    recModel = (AliMUONClusterFinderVS*) new AliMUONClusterFinderAZ();
-    recoCluster->SetRecoModel(recModel);
+  AliInfo("Calibration will occur.");
+  
+  fCalibrationData = new AliMUONCalibrationData(runNumber);
+  if ( !fCalibrationData->IsValid() )
+  {
+    AliError("Could not retrieve calibrations !");
+    delete fCalibrationData;
+    fCalibrationData = 0x0;
+    return;
+  }    
+  
+  // Check that we get all the calibrations we'll need
+  if ( !fCalibrationData->Pedestals() ||
+       !fCalibrationData->Gains() ||
+       !fCalibrationData->HV() )
+  {
+    AliFatal("Could not access all required calibration data");
   }
-  recModel->SetGhostChi2Cut(10);
-  recModel->SetEventNumber(evtNumber);
-
-  loader->LoadDigits("READ");
-  loader->LoadRecPoints("RECREATE");
-  loader->LoadTracks("RECREATE");
   
-  TTask* calibration = GetCalibrationTask();
+  TString opt(GetOption());
+  opt.ToUpper();
+  Bool_t statusMap(kTRUE);
   
-  Int_t chBeg = (strstr(GetOption(),"Combi") ? 6 : 0);
+  if ( strstr(opt,"NOSTATUSMAP") )
+  {
+    AliWarning("Disconnecting status map : SHOULD BE USED FOR DEBUG ONLY. NOT FOR PRODUCTION !!!");
+    statusMap = kFALSE; 
+  }
+  fDigitCalibrator = new AliMUONDigitCalibrator(*fCalibrationData,statusMap);
+}
 
-  //   Loop over events              
-  for(Int_t ievent = 0; ievent < nEvents; ievent++) {
+//_____________________________________________________________________________
+AliMUONVDigitStore*
+AliMUONReconstructor::DigitStore() const
+{
+  /// Return (and create if necessary) the digit container
+  if (!fDigitStore) 
+  {
+    fDigitStore = new AliMUONDigitStoreV1;
+  }
+  return fDigitStore;
+}
 
-    AliDebug(1,Form("Event %d",ievent));
-    
-    runLoader->GetEvent(ievent);
-
-    //----------------------- digit2cluster & Trigger2Trigger -------------------
-    if (!loader->TreeR()) loader->MakeRecPointsContainer();
-     
-    // tracking branch
-    if (!strstr(GetOption(),"Combi")) {
-      fMUONData->MakeBranch("RC");
-      fMUONData->SetTreeAddress("D,RC");
-    } else {
-      fMUONData->SetTreeAddress("D");
-      fMUONData->SetTreeAddress("RCC");
-    }
-    // Important for avoiding a memory leak when reading digits ( to be investigated more in detail)
-    // In any case the reading of GLT is needed for the Trigger2Tigger method below
-    fMUONData->SetTreeAddress("GLT");
+//_____________________________________________________________________________
+void
+AliMUONReconstructor::FillTreeR(AliMUONVTriggerStore* triggerStore,
+                                AliMUONVClusterStore* clusterStore,
+                                TTree& clustersTree) const
+{
+  /// Write the trigger and cluster information into TreeR
+  
+  AliMUONStopwatchGroupElement timer(fTimers,"MUON","AliMUONReconstructor::FillTreeR()");
 
-    fMUONData->GetDigits();
-    
-    if ( calibration ) 
+  AliDebug(1,"");
+  
+  Bool_t ok(kFALSE);
+  if ( triggerStore ) 
+  {
+    Bool_t alone = ( clusterStore ? kFALSE : kTRUE );
+    ok = triggerStore->Connect(clustersTree,alone);
+    if (!ok)
     {
-      calibration->ExecuteTask();
-    }
-    
-    recoCluster->Digits2Clusters(chBeg); 
-    
-    if (strstr(GetOption(),"Combi")) {
-      // Combined cluster / track finder
-      AliMUONEventRecoCombi::Instance()->FillEvent(fMUONData, (AliMUONClusterFinderAZ*)recModel);
-      ((AliMUONClusterFinderAZ*) recModel)->SetReco(2); 
+      AliError("Could not create triggerStore branches in TreeR");
     }
-    else fMUONData->Fill("RC"); 
-
-    // trigger branch
-    fMUONData->MakeBranch("TC");
-    fMUONData->SetTreeAddress("TC");
-    recoCluster->Trigger2Trigger(); 
-    fMUONData->Fill("TC");
-
-    //AZ loader->WriteRecPoints("OVERWRITE");
-
-    //---------------------------- Track & TriggerTrack ---------------------
-    if (!loader->TreeT()) loader->MakeTracksContainer();
-
-    // trigger branch
-    fMUONData->MakeBranch("RL"); //trigger track
-    fMUONData->SetTreeAddress("RL");
-    recoEvent->EventReconstructTrigger();
-    fMUONData->Fill("RL");
-
-    // tracking branch
-    fMUONData->MakeBranch("RT"); //track
-    fMUONData->SetTreeAddress("RT");
-    recoEvent->EventReconstruct();
-    fMUONData->Fill("RT");
-
-    loader->WriteTracks("OVERWRITE"); 
-  
-    if (strstr(GetOption(),"Combi")) { 
-      // Combined cluster / track
-      ((AliMUONClusterFinderAZ*) recModel)->SetReco(1);
-      fMUONData->MakeBranch("RC");
-      fMUONData->SetTreeAddress("RC");
-      AliMUONEventRecoCombi::Instance()->FillRecP(fMUONData, (AliMUONTrackReconstructorK*)recoEvent); 
-      fMUONData->Fill("RC"); 
-    }
-    loader->WriteRecPoints("OVERWRITE"); 
-
-    //--------------------------- Resetting branches -----------------------
-    fMUONData->ResetDigits();
-    fMUONData->ResetRawClusters();
-    fMUONData->ResetTrigger();
-    fMUONData->ResetRecTracks();  
-    fMUONData->ResetRecTriggerTracks();
-
   }
-  loader->UnloadDigits();
-  loader->UnloadRecPoints();
-  loader->UnloadTracks();
-
-  delete recoCluster;
-  delete recoEvent;
-  delete calibration;
+  
+  if ( clusterStore ) 
+  {
+    Bool_t alone = ( triggerStore ? kFALSE : kTRUE );
+    ok = clusterStore->Connect(clustersTree,alone);
+    if (!ok)
+    {
+      AliError("Could not create triggerStore branches in TreeR");
+    }    
+  }
+  
+  if (ok) // at least one type of branches created successfully
+  {
+    clustersTree.Fill();
+  }
 }
 
 //_____________________________________________________________________________
-void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader, 
-                                       AliRawReader* rawReader) const
+Bool_t 
+AliMUONReconstructor::HasDigitConversion() const
 {
-/// Recontruct 
-/// \todo add more
-
-  //  AliLoader
-  AliLoader* loader = runLoader->GetLoader("MUONLoader");
-  Int_t evtNumber   = runLoader->GetEventNumber();
-  fMUONData->SetLoader(loader);
-
-  // passing loader as argument.
-  fDigitMaker->SetMUONData(fMUONData);
-
-  // disable trigger rawdata reading
-  if (strstr(GetOption(),"TriggerDisable"))
-      fDigitMaker->DisableTrigger();
-
-  AliMUONClusterReconstructor* recoCluster = CreateClusterReconstructor();
-
-  AliMUONClusterFinderVS *recModel = recoCluster->GetRecoModel();
+  /// We *do* have digit conversion, but we might advertise it only 
+  /// if we want to save the digits.
+  
+  TString opt(GetOption());
+  opt.ToUpper();
+  if ( opt.Contains("SAVEDIGITS" ) && !opt.Contains("NOLOCALRECONSTRUCTION") )
+  {
+    return kTRUE;
+  }
+  else
+  {
+    return kFALSE;
+  }
+}
 
-  if (!strstr(GetOption(),"VS")) 
+//_____________________________________________________________________________
+Bool_t 
+AliMUONReconstructor::HasLocalReconstruction() const
+{
+  /// Whether or not we have local reconstruction
+  TString opt(GetOption());
+  opt.ToUpper();
+  if ( opt.Contains("NOLOCALRECONSTRUCTION" ) )
   {
-    recModel = (AliMUONClusterFinderVS*) new AliMUONClusterFinderAZ();
-    recoCluster->SetRecoModel(recModel);
+    return kFALSE;
   }
-  recModel->SetGhostChi2Cut(10);
-  recModel->SetEventNumber(evtNumber);
+  else
+  {
+    return kTRUE;
+  }
+}
+
+//_____________________________________________________________________________
+void 
+AliMUONReconstructor::Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const
+{
+  /// This method is called by AliReconstruction if HasLocalReconstruction()==kTRUE AND
+  /// HasDigitConversion()==kFALSE
   
-  TTask* calibration = GetCalibrationTask();
+  if ( !clustersTree ) 
+  {
+    AliError("clustersTree is 0x0 !");
+    return;
+  }
   
-  loader->LoadRecPoints("RECREATE");
-  // Digits are not stored on disk and created on flight from rawdata.
-  // In order to write digits on disk the following line should be uncommented
-  // loader->LoadDigits("RECREATE"); 
+  if ( DigitStore() ) 
+  {
+    ConvertDigits(rawReader,DigitStore(),TriggerStore());
+    Clusterize(*(DigitStore()),*(ClusterStore()));
+  }
+    
+  FillTreeR(TriggerStore(),ClusterStore(),*clustersTree);
+}
 
-  //   Loop over events  
-  Int_t iEvent = 0;
-           
-  TStopwatch totalTimer;
-  TStopwatch rawTimer;
-  TStopwatch calibTimer;
-  TStopwatch clusterTimer;
+//_____________________________________________________________________________
+void 
+AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader) const
+{
+  /// Reconstruct simulated data
   
-  rawTimer.Start(kTRUE); rawTimer.Stop();
-  calibTimer.Start(kTRUE); calibTimer.Stop();
-  clusterTimer.Start(kTRUE); clusterTimer.Stop();
+  AliMUONStopwatchGroupElement timer(fTimers,"MUON","AliMUONReconstructor::Reconstruct(AliRunLoader*)");
   
-  totalTimer.Start(kTRUE);
+  AliLoader* loader = runLoader->GetDetectorLoader("MUON");
+  if (!loader) 
+  {
+    AliError("Could not get MUON loader");
+    return;
+  }
   
-  while (rawReader->NextEvent()) 
+  Int_t nEvents = runLoader->GetNumberOfEvents();
+  
+  for ( Int_t i = 0; i < nEvents; ++i ) 
   {
-    AliDebug(1,Form("Event %d",iEvent));
+    runLoader->GetEvent(i);
     
-    runLoader->GetEvent(iEvent++);
+    loader->LoadRecPoints("update");
+    loader->CleanRecPoints();
+    loader->MakeRecPointsContainer();
+    TTree* clustersTree = loader->TreeR();
     
-    //----------------------- raw2digits & raw2trigger-------------------
-    //  if (!loader->TreeD()) 
-    //  {
-    //    AliDebug(1,Form("Making Digit Container for event %d",iEvent));
-    //    loader->MakeDigitsContainer();
-    //  }
-    // Write digits from raw data on disk
-    if (strstr(GetOption(),"SAVEDIGITS")) {
-       if (!loader->TreeD())fMUONData->GetLoader()->MakeDigitsContainer();
-       fMUONData->MakeBranch("D,GLT");
-       fMUONData->SetTreeAddress("D,GLT");
-       AliInfo("Digits from raw data will be stored.");
-    }
-    else {
-       fMUONData->SetDataContainer("D, GLT");
-    }
-    rawTimer.Start(kFALSE);
-    fDigitMaker->Raw2Digits(rawReader);
-    rawTimer.Stop();
-    
-    if ( calibration )
-    {
-      calibTimer.Start(kFALSE);
-      calibration->ExecuteTask();
-      calibTimer.Stop();
-    }
-
-    // Write digits from raw data on disk
-    if (strstr(GetOption(),"SAVEDIGITS")) {
-       fMUONData->Fill("D,GLT");
-       loader->WriteDigits("OVERWRITE");
-    }
-    //----------------------- digit2cluster & Trigger2Trigger -------------------
-    clusterTimer.Start(kFALSE);
+    loader->LoadDigits("read");
+    TTree* digitsTree = loader->TreeD();
 
-    if (!loader->TreeR()) loader->MakeRecPointsContainer();
-    
-    // tracking branch
-    fMUONData->MakeBranch("RC");
-    fMUONData->SetTreeAddress("RC");
-    recoCluster->Digits2Clusters(); 
-    fMUONData->Fill("RC"); 
-
-    // trigger branch
-    fMUONData->MakeBranch("TC");
-    fMUONData->SetTreeAddress("TC");
-    fMUONData->Fill("TC");
+    Reconstruct(digitsTree,clustersTree);
     
+    loader->UnloadDigits();
     loader->WriteRecPoints("OVERWRITE");
-
-    clusterTimer.Stop();
-    
-    
-    //--------------------------- Resetting branches -----------------------
-    fMUONData->ResetDigits();
-    fMUONData->ResetRawClusters();
-    fMUONData->ResetTrigger();
+    loader->UnloadRecPoints();    
   }
-  
-  totalTimer.Stop();
-  
-  loader->UnloadRecPoints();
-  loader->UnloadDigits();
-  
-  delete recoCluster;
-  delete calibration;
-  
-  AliInfo(Form("Execution time for converting RAW data to digits in MUON : R:%.2fs C:%.2fs",
-               rawTimer.RealTime(),rawTimer.CpuTime()));
-  AliInfo(Form("Execution time for calibrating MUON : R:%.2fs C:%.2fs",
-               calibTimer.RealTime(),calibTimer.CpuTime()));
-  AliInfo(Form("Execution time for clusterizing MUON : R:%.2fs C:%.2fs",
-               clusterTimer.RealTime(),clusterTimer.CpuTime()));
-  AliInfo(Form("Total Execution time for Reconstruct(from raw) MUON : R:%.2fs C:%.2fs",
-               totalTimer.RealTime(),totalTimer.CpuTime()));
 }
 
 //_____________________________________________________________________________
-void AliMUONReconstructor::FillESD(AliRunLoader* runLoader, AliESD* esd) const
+void 
+AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader, AliRawReader* rawReader) const
 {
-/// Fill ESD
-/// \todo add more
-
-  TClonesArray* recTracksArray = 0;
-  TClonesArray* recTrigTracksArray = 0;
-  
-  AliLoader* loader = runLoader->GetLoader("MUONLoader");
-  loader->LoadTracks("READ");
-  fMUONData->SetLoader(loader);
-
-   // declaration  
-  Int_t iEvent;// nPart;
-  Int_t nTrackHits;// nPrimary;
-  Double_t fitFmin, chi2MatchTrigger;
-  Double_t xRec, yRec, zRec, bendingSlope, nonBendingSlope, inverseBendingMomentum;
-  Double_t xVtx, yVtx, zVtx, bendingSlopeAtVtx, nonBendingSlopeAtVtx, inverseBendingMomentumAtVtx;
-  Int_t localTrigger;
-  UShort_t hitsPatternInTrigCh;
-
-  // setting pointer for tracks, triggertracks & trackparam at vertex
-  AliMUONTrack* recTrack = 0;
-  AliMUONTrackParam trackParamAtVtx;
-  AliMUONTriggerTrack* recTriggerTrack = 0;
-
-  iEvent = runLoader->GetEventNumber(); 
-  runLoader->GetEvent(iEvent);
-
-  // Get vertex 
-  Double_t vertex[3] = {0};
-  const AliESDVertex *esdVert = esd->GetVertex(); 
-  if (esdVert->GetNContributors()) {
-    esdVert->GetXYZ(vertex);
-    AliDebug(1, "find vertex\n");
-  }
-  // setting ESD MUON class
-  AliESDMuonTrack* theESDTrack = new  AliESDMuonTrack() ;
-
-  //-------------------- trigger tracks-------------
-  Long_t trigPat = 0;
-  fMUONData->SetTreeAddress("RL");
-  fMUONData->GetRecTriggerTracks();
-  recTrigTracksArray = fMUONData->RecTriggerTracks();
-
-  // ready global trigger pattern from first track
-  if (recTrigTracksArray) 
-    recTriggerTrack = (AliMUONTriggerTrack*) recTrigTracksArray->First();
-  if (recTriggerTrack) trigPat = recTriggerTrack->GetGTPattern();
-
-  //printf(">>> Event %d Number of Recconstructed tracks %d \n",iEvent, nrectracks);
-  // -------------------- tracks-------------
-  fMUONData->SetTreeAddress("RT");
-  fMUONData->GetRecTracks();
-  recTracksArray = fMUONData->RecTracks();
-        
-  Int_t nRecTracks = 0;
-  if (recTracksArray)
-    nRecTracks = (Int_t) recTracksArray->GetEntriesFast(); //
-  
-  // loop over tracks
-  for (Int_t iRecTracks = 0; iRecTracks <  nRecTracks;  iRecTracks++) {
-
-    // reading info from tracks
-    recTrack = (AliMUONTrack*) recTracksArray->At(iRecTracks);
-    AliMUONTrackParam *trackParam = (AliMUONTrackParam*) (recTrack->GetTrackParamAtHit())->First();
-    trackParamAtVtx = *trackParam;
-   
-    // extrapolate to the vertex if available, else to (0,0,0)
-    if (esdVert->GetNContributors())
-      AliMUONTrackExtrap::ExtrapToVertex(&trackParamAtVtx, vertex[0],vertex[1],vertex[2]);
-    else
-      AliMUONTrackExtrap::ExtrapToVertex(&trackParamAtVtx, 0.,0.,0.);
+  /// This method is called by AliReconstruction if HasLocalReconstruction()==kFALSE
+  
+  AliMUONStopwatchGroupElement timer(fTimers,"MUON","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();
     
-    // Track parameters at first station
-    bendingSlope           = trackParam->GetBendingSlope();
-    nonBendingSlope        = trackParam->GetNonBendingSlope();
-    inverseBendingMomentum = trackParam->GetInverseBendingMomentum();
-    xRec = trackParam->GetNonBendingCoor();
-    yRec = trackParam->GetBendingCoor();
-    zRec = trackParam->GetZ();
+    loader->LoadDigits("update");
+    loader->CleanDigits();
+    loader->MakeDigitsContainer();
+    TTree* digitsTree = loader->TreeD();
+    ConvertDigits(rawReader, digitsTree);
+    loader->WriteDigits("OVERWRITE");
     
-    // Track parameters at vertex
-    bendingSlopeAtVtx           = trackParamAtVtx.GetBendingSlope();
-    nonBendingSlopeAtVtx        = trackParamAtVtx.GetNonBendingSlope();
-    inverseBendingMomentumAtVtx = trackParamAtVtx.GetInverseBendingMomentum();
-    xVtx = trackParamAtVtx.GetNonBendingCoor();
-    yVtx = trackParamAtVtx.GetBendingCoor();
-    zVtx = trackParamAtVtx.GetZ();
+    Reconstruct(digitsTree,clustersTree);
     
-    // Global info
-    nTrackHits       = recTrack->GetNTrackHits();
-    fitFmin          = recTrack->GetFitFMin();
-    localTrigger     = recTrack->GetLocalTrigger();
-    chi2MatchTrigger = recTrack->GetChi2MatchTrigger();
-    hitsPatternInTrigCh = recTrack->GetHitsPatternInTrigCh();
-
-    // setting data member of ESD MUON
-    // at first station
-    theESDTrack->SetInverseBendingMomentumUncorrected(inverseBendingMomentum);
-    theESDTrack->SetThetaXUncorrected(TMath::ATan(nonBendingSlope));
-    theESDTrack->SetThetaYUncorrected(TMath::ATan(bendingSlope));
-    theESDTrack->SetZUncorrected(zRec);
-    theESDTrack->SetBendingCoorUncorrected(yRec);
-    theESDTrack->SetNonBendingCoorUncorrected(xRec);
-    // at vertex
-    theESDTrack->SetInverseBendingMomentum(inverseBendingMomentumAtVtx);
-    theESDTrack->SetThetaX(TMath::ATan(nonBendingSlopeAtVtx));
-    theESDTrack->SetThetaY(TMath::ATan(bendingSlopeAtVtx));
-    theESDTrack->SetZ(zVtx);
-    theESDTrack->SetBendingCoor(yVtx);
-    theESDTrack->SetNonBendingCoor(xVtx);
-    // global info
-    theESDTrack->SetChi2(fitFmin);
-    theESDTrack->SetNHit(nTrackHits);
-    theESDTrack->SetLocalTrigger(localTrigger);
-    theESDTrack->SetChi2MatchTrigger(chi2MatchTrigger);
-    theESDTrack->SetHitsPatternInTrigCh(hitsPatternInTrigCh);
-
-    // storing ESD MUON Track into ESD Event 
-    if (nRecTracks != 0)  
-      esd->AddMuonTrack(theESDTrack);
-  } // end loop tracks
-
-  // reset muondata
-  fMUONData->ResetRecTracks();
-  fMUONData->ResetRecTriggerTracks();
-
-  //} // end loop on event  
-  loader->UnloadTracks(); 
-
-  delete theESDTrack;
+    loader->UnloadDigits();
+    loader->WriteRecPoints("OVERWRITE");
+    loader->UnloadRecPoints();    
+  }
 }
 
 //_____________________________________________________________________________
-void AliMUONReconstructor::FillESD(AliRunLoader* runLoader, AliRawReader* /*rawReader*/, AliESD* esd) const
+void 
+AliMUONReconstructor::Reconstruct(TTree* digitsTree, TTree* clustersTree) const
 {
-/// Fill ESD
-/// \todo add more
+  /// This method is called by AliReconstruction if HasLocalReconstruction()==kTRUE
+  /// AND HasDigitConversion()==kTRUE
+  
+  AliDebug(1,"");
+  
+  if (!digitsTree || !clustersTree) 
+  {
+    AliError(Form("Tree is null : digitsTree=%p clustersTree=%p",
+                  digitsTree,clustersTree));
+    return;
+  }
 
-  // don't need rawReader ???
-  FillESD(runLoader, esd);
+  if (!fDigitStore)
+  {
+    fDigitStore = AliMUONVDigitStore::Create(*digitsTree);
+    if (!fDigitStore)
+    {
+      AliError(Form("Could not get DigitStore from %s",digitsTree->GetName()));
+    }
+    else
+    {
+      AliInfo(Form("Created %s from %s",fDigitStore->ClassName(),digitsTree->GetName()));
+    }
+  }
+  if (!fTriggerStore)
+  {
+    fTriggerStore = AliMUONVTriggerStore::Create(*digitsTree);
+    if (!fTriggerStore)
+    {
+      AliError(Form("Could not get TriggerStore from %s",digitsTree->GetName()));
+    }
+    else
+    {
+      AliInfo(Form("Created %s from %s",fTriggerStore->ClassName(),digitsTree->GetName()));
+    }
+  }
+  
+  if (!fTriggerStore && !fDigitStore)
+  {
+    AliError("No store at all. Nothing to do.");
+    return;
+  }
+  
+  // insure we start with empty stores
+  if ( fDigitStore ) 
+  {
+    fDigitStore->Clear(); 
+    Bool_t alone = ( fTriggerStore ? kFALSE : kTRUE );
+    Bool_t ok = fDigitStore->Connect(*digitsTree,alone);
+    if (!ok)
+    {
+      AliError("Could not connect digitStore to digitsTree");
+      return;
+    }
+  }
+  if ( fTriggerStore ) 
+  {
+    fTriggerStore->Clear();
+    Bool_t alone = ( fDigitStore ? kFALSE : kTRUE );
+    Bool_t ok = fTriggerStore->Connect(*digitsTree,alone);
+    if (!ok)
+    {
+      AliError("Could not connect triggerStore to digitsTree");
+      return;
+    }
+  }
+  
+  digitsTree->GetEvent(0);
+  
+  if ( fDigitStore ) 
+  {
+    Clusterize(*fDigitStore,*(ClusterStore()));
+  }
+    
+  FillTreeR(fTriggerStore,ClusterStore(),*clustersTree);
 }
 
 //_____________________________________________________________________________
-AliTracker* AliMUONReconstructor::CreateTracker(AliRunLoader* runLoader) const
+AliMUONVTriggerStore*
+AliMUONReconstructor::TriggerStore() const
 {
-  /// create tracker for MUON
-  /// go into the tracking framework finally (Ch.F)
-  AliLoader* loader = runLoader->GetLoader("MUONLoader");
-
-  fMUONData->SetLoader(loader);
-
-  AliMUONTracker* tracker = new AliMUONTracker();
-  tracker->SetMUONData(fMUONData);
-  tracker->SetTriggerCircuit(fTriggerCircuit);
-  tracker->SetOption(GetOption());
-
-  return tracker;
-
+  /// Return (and create if necessary and allowed) the trigger container
+  TString sopt(GetOption());
+  sopt.ToUpper();
+  
+  if (sopt.Contains("TRIGGERDISABLE"))
+  {
+    delete fTriggerStore;
+    fTriggerStore = 0x0;
+  }
+  else
+  {
+    if (!fTriggerStore)
+    {
+      fTriggerStore = new AliMUONTriggerStoreV1;
+    }
+  }
+  return fTriggerStore;
 }
index 6a4546d..ca65564 100644 (file)
 #ifndef ALIMUONRECONSTRUCTOR_H
 #define ALIMUONRECONSTRUCTOR_H
+
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
+* See cxx source for full Copyright notice                               */
 
-/* $Id$ */
-// Revision of includes 07/05/2004
+// $Id$
 
 /// \ingroup rec
 /// \class AliMUONReconstructor
-/// \brief Class for the MUON reconstruction
+/// \brief Implementation of AliReconstructor for MUON (both tracker and trigger)
+/// 
+// Author Laurent Aphecetche, Subatech
 
-#include "AliReconstructor.h"
+#ifndef ALIRECONSTRUCTOR_H
+#  include "AliReconstructor.h"
+#endif
 
-class AliMUONCalibrationData;
-class AliMUONRecData;
 class AliMUONDigitMaker;
-class AliMUONTriggerCrateStore;
+class AliMUONVDigitStore;
+class AliMUONVTriggerStore;
+
 class AliMUONGeometryTransformer;
-class AliTracker;
-class AliMUONClusterReconstructor;
-class AliMUONSegmentation;
 
-class TTask;
+class AliMUONTriggerCrateStore;
+class AliMUONTriggerCircuit;
 class TClonesArray;
+class AliMUONVTriggerStore;
 
-class AliMUONReconstructor: public AliReconstructor 
-{
-  public:
-    AliMUONReconstructor();
-    virtual ~AliMUONReconstructor();
-
-    /// Dummy implementation    
-    virtual void         Reconstruct(TTree* /*digitsTree*/, 
-                                    TTree* /*clustersTree*/) const {return;}
-    /// Dummy implementation    
-    virtual void         Reconstruct(AliRawReader* /*rawReader*/, 
-                                    TTree* /*clustersTree*/) const {return;}
-    virtual void         Reconstruct(AliRunLoader* runLoader) const;
-    virtual void         Reconstruct(AliRunLoader* runLoader, 
-                                   AliRawReader* rawReader) const;
-
-    /// Dummy implementation    
-    virtual void         FillESD(TTree* /*digitsTree*/, TTree* /*clustersTree*/, 
-                                AliESD* /*esd*/) const {return;}
-    /// Dummy implementation    
-    virtual void         FillESD(AliRawReader* /*rawReader*/, TTree* /*clustersTree*/, 
-                                AliESD* /*esd*/) const {return;}
-    virtual void         FillESD(AliRunLoader* runLoader, AliESD* esd) const;
-    virtual void         FillESD(AliRunLoader* runLoader, 
-                                AliRawReader* /*rawReader*/, AliESD* esd) const;
-
-    AliTracker*          CreateTracker(AliRunLoader* runLoader) const;
-    enum {kNone, kOriginal, kKalman, kCombi};
+class AliMUONDigitCalibrator;
+class AliMUONCalibrationData;
 
-private:
+class AliMUONClusterReconstructor;
+class AliMUONVClusterStore;
 
-    TTask* GetCalibrationTask() const;
-    AliMUONClusterReconstructor* CreateClusterReconstructor() const;
-    
-    /// Not implemented
-    AliMUONReconstructor(const AliMUONReconstructor& right);
-    /// Not implemented
-    AliMUONReconstructor&  operator = (const AliMUONReconstructor& right);
+class AliMUONTracker;
+class AliMUONVTrackStore;
 
-private:
-    AliMUONDigitMaker* fDigitMaker; //!< pointer to the digit maker class
+class AliMUONStopwatchGroup;
 
-    mutable AliMUONCalibrationData* fCalibrationData; //!< pointer to calibration data
+class AliMUONReconstructor : public AliReconstructor
+{
+public:
+  AliMUONReconstructor();
+  virtual ~AliMUONReconstructor();
+  
+  virtual Bool_t HasDigitConversion() const;
+
+  virtual void ConvertDigits(AliRawReader* rawReader, TTree* digitsTree) const;
+  
+  virtual Bool_t HasLocalReconstruction() const;
+  
+  virtual void Reconstruct(AliRunLoader* runLoader) const;
+  
+  virtual void Reconstruct(AliRunLoader* runLoader, AliRawReader* rawReader) const;
+
+  virtual void Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const;
+  
+  virtual void Reconstruct(TTree* digitsTree, TTree* clustersTree) const;
+  
+  virtual AliTracker* CreateTracker(AliRunLoader* runLoader) const;
     
-    AliMUONTriggerCrateStore* fCrateManager;     //!< Crate array
-
-    TClonesArray* fTriggerCircuit;   //!< trigger circuit
-    AliMUONGeometryTransformer* fTransformer; //!< pointer to transformation
-    AliMUONSegmentation*        fSegmentation; //!< pointer to segmentation
-
-    AliMUONRecData*             fMUONData;     //!< pointer to container
+private:
+  /// Not implemented
+  AliMUONReconstructor(const AliMUONReconstructor&);
+  /// Not implemented
+  AliMUONReconstructor& operator=(const AliMUONReconstructor&);
+  
+  void ConvertDigits(AliRawReader* rawReader, 
+                     AliMUONVDigitStore* digitStore,
+                     AliMUONVTriggerStore* triggerStore) const;
+  void Calibrate(AliMUONVDigitStore& digitStore) const;
+  void Clusterize(const AliMUONVDigitStore& digitStore, AliMUONVClusterStore& clusterStore) const;
+  AliMUONTriggerCrateStore* CrateManager() const;
+  void CreateCalibrator() const;
+  void CreateDigitMaker() const;
+  void CreateTriggerCircuit() const;
+  void CreateClusterReconstructor() const;
+  void FillTreeR(AliMUONVTriggerStore* triggerStore,
+                 AliMUONVClusterStore* clusterStore,
+                 TTree& clustersTree) const;
+  
+  AliMUONVDigitStore* DigitStore() const;
+  AliMUONVClusterStore* ClusterStore() const;
+  AliMUONVTriggerStore* TriggerStore() const;
 
-  ClassDef(AliMUONReconstructor, 0)   // class for the MUON reconstruction
+private:
+  mutable AliMUONTriggerCrateStore* fCrateManager; //!< Trigger Crate manager
+  mutable AliMUONDigitMaker* fDigitMaker; //!< Raw to Digits converter
+  AliMUONGeometryTransformer* fTransformer; //!< Geometry transformer (local<->global)
+  mutable AliMUONVDigitStore* fDigitStore; //!< Digit container
+  mutable TClonesArray* fTriggerCircuit; //!< Trigger Circuit
+  mutable AliMUONCalibrationData* fCalibrationData; //!< Calibration data
+  mutable AliMUONDigitCalibrator* fDigitCalibrator; //!<  Digit to calibrate digit converter
+  mutable AliMUONClusterReconstructor* fClusterReconstructor; //!<  Clusterizer
+  mutable AliMUONVClusterStore* fClusterStore; //!< Cluster container
+  mutable AliMUONVTriggerStore* fTriggerStore; //!< Trigger container
+  mutable AliMUONVTrackStore* fTrackStore; //!< Track container
+  AliMUONStopwatchGroup* fTimers; //!< Internal timers
+  
+  ClassDef(AliMUONReconstructor,1) // Implementation of AliReconstructor
 };
 
 #endif