Updated for separation of simulation and reconstruction classes

(namely AliMUONData class)

diff --git a/MUON/AliMUONCheck.cxx b/MUON/AliMUONCheck.cxx
index d5ad904c5bef452eb0960e191004dd235f78d414..422c723324f5668dde1eafaea4d5c3bca514ec01 100644 (file)
--- a/MUON/AliMUONCheck.cxx
+++ b/MUON/AliMUONCheck.cxx
@@ -29,7 +29,8 @@
 /// \author Frederic Yermia, INFN Torino
 
 #include "AliMUONCheck.h"
-#include "AliMUONData.h"
+#include "AliMUONSimData.h"
+#include "AliMUONRecData.h"
 #include "AliMUONDigit.h"
 #include "AliMUONConstants.h"
 #include "AliMUONTrack.h"
@@ -60,6 +61,7 @@
 /// \cond CLASSIMP
 ClassImp(AliMUONCheck)
 /// \endcond
+
 AliMUONCheck::AliMUONCheck(const char* galiceFile, const char* esdFile,Int_t firstEvent, Int_t lastEvent,const char* outDir) 
 : TObject(),
   fFileName(galiceFile),
@@ -70,8 +72,8 @@ AliMUONCheck::AliMUONCheck(const char* galiceFile, const char* esdFile,Int_t fir
   fLastEvent(lastEvent),
   fRunLoader(0x0),
   fRunLoaderSim(0x0),
-  fData(0x0),
-  fDataSim(0x0),
+  fRecData(0x0),
+  fSimData(0x0),
   fTree(0)
 {
   /// ctor
@@ -86,7 +88,7 @@ AliMUONCheck::AliMUONCheck(const char* galiceFile, const char* esdFile,Int_t fir
     fLoader = fRunLoader->GetLoader("MUONLoader");
     if ( fLoader )
     {
-      fData = new AliMUONData(fLoader,"MUON","MUON");
+      fRecData = new AliMUONRecData(fLoader,"MUON","MUON");
     }
     else
     {
@@ -104,7 +106,7 @@ AliMUONCheck::AliMUONCheck(const char* galiceFile, const char* esdFile,Int_t fir
     fLoaderSim = fRunLoaderSim->GetLoader("MUONLoader");
     if ( fLoaderSim )
     {
-      fDataSim = new AliMUONData(fLoaderSim,"MUON","MUON");
+      fSimData = new AliMUONSimData(fLoaderSim,"MUON","MUON");
     }
     else
     {
@@ -129,8 +131,8 @@ AliMUONCheck::AliMUONCheck(const char* galiceFile, const char* galiceFileSim, co
   fLastEvent(lastEvent),
   fRunLoader(0x0),
   fRunLoaderSim(0x0),
-  fData(0x0),
-  fDataSim(0x0),
+  fRecData(0x0),
+  fSimData(0x0),
   fTree(0)
 {
   /// ctor
@@ -145,7 +147,7 @@ AliMUONCheck::AliMUONCheck(const char* galiceFile, const char* galiceFileSim, co
     fLoader = fRunLoader->GetLoader("MUONLoader");
     if ( fLoader )
     {
-      fData = new AliMUONData(fLoader,"MUON","MUON");
+      fRecData = new AliMUONRecData(fLoader,"MUON","MUON");
     }
     else
     {
@@ -163,7 +165,7 @@ AliMUONCheck::AliMUONCheck(const char* galiceFile, const char* galiceFileSim, co
     fLoaderSim = fRunLoaderSim->GetLoader("MUONLoader");
     if ( fLoaderSim )
     {
-      fDataSim = new AliMUONData(fLoaderSim,"MUON","MUON");
+      fSimData = new AliMUONSimData(fLoaderSim,"MUON","MUON");
     }
     else
     {
@@ -185,9 +187,9 @@ AliMUONCheck::~AliMUONCheck()
   fRunLoader->UnloadAll();
   fRunLoaderSim->UnloadAll();
   delete fRunLoader;
-  delete fData;
+  delete fRecData;
   delete fRunLoaderSim;
-  delete fDataSim;
+  delete fSimData;
 }
 
 //_____________________________________________________________________________
@@ -951,9 +953,9 @@ AliMUONCheck::CheckRecTracks () const
   for (Int_t ievent=fFirstEvent; ievent<endOfLoop; ievent++) {
     fRunLoader->GetEvent(ievent);
     
-    fData->SetTreeAddress("RT");
-    fData->GetRecTracks();
-    TClonesArray* recTracks = fData->RecTracks();
+    fRecData->SetTreeAddress("RT");
+    fRecData->GetRecTracks();
+    TClonesArray* recTracks = fRecData->RecTracks();
     
     Int_t nrectracks = (Int_t) recTracks->GetEntriesFast(); //
     printf(">>> Event %d, Number of Recconstructed tracks %d \n",ievent, nrectracks);
@@ -968,7 +970,7 @@ AliMUONCheck::CheckRecTracks () const
       AliMUONTrackExtrap::ExtrapToZ(trackParam,0.);
       recTrack->Print("full");
     }
-    fData->ResetRecTracks();
+    fRecData->ResetRecTracks();
   }   
   fLoader->UnloadTracks();
 }

diff --git a/MUON/AliMUONCheck.h b/MUON/AliMUONCheck.h
index b0908feb3adaabf1c6a2aa9918366a39ceda9b33..e5a50221ad62f2126fe7c8c2a80c5ab3f976c9d9 100644 (file)
--- a/MUON/AliMUONCheck.h
+++ b/MUON/AliMUONCheck.h
@@ -19,7 +19,8 @@
 #  include "TString.h"
 #endif
 
-class AliMUONData;
+class AliMUONSimData;
+class AliMUONRecData;
 class AliRunLoader;
 class AliLoader;
 class AliESD;
@@ -36,7 +37,7 @@ public:
   virtual ~AliMUONCheck();
  
   /// Return true if contains valid data
-  Bool_t IsValid() const { return (fData!=0); }
+  Bool_t IsValid() const { return (fRecData!=0); }
   
   void CheckESD(Bool_t pdc06TriggerResponse= false);
   void CheckKine();
@@ -68,8 +69,8 @@ private:
   AliLoader*    fLoader;    //!< MUON loader pointer for reconstruction
   AliLoader*    fLoaderSim; //!< MUON loader pointer for simulation
 
-  AliMUONData*  fData;     //!< AliMUONData pointer (to access containers) for recontruction 
-  AliMUONData*  fDataSim;  //!< AliMUONData pointer (to access containers) for simulation
+  AliMUONRecData*  fRecData;  //!< AliMUONData pointer (to access containers) for recontruction 
+  AliMUONSimData*  fSimData;  //!< AliMUONData pointer (to access containers) for simulation
 
   TTree   * fTree ;     //!< pointer to the analyzed TTree or TChain
   AliESD  * fESD ;      //!< Declaration of leave types

diff --git a/MUON/AliMUONClusterReconstructor.cxx b/MUON/AliMUONClusterReconstructor.cxx
index 7c6109228705f7aa1d5aee0ac9245c892ba08845..9decfd382d7e096d2d41aeaeab39cf2822822641 100644 (file)
--- a/MUON/AliMUONClusterReconstructor.cxx
+++ b/MUON/AliMUONClusterReconstructor.cxx
@@ -28,7 +28,7 @@
 
 #include "AliMUONDigit.h"
 #include "AliMUONConstants.h"
-#include "AliMUONData.h"
+#include "AliMUONRecData.h"
 #include "AliMUONClusterFinderVS.h"
 #include "AliMUONClusterInput.h"
 #include "AliMUONRawCluster.h"
@@ -45,7 +45,7 @@ ClassImp(AliMUONClusterReconstructor) // Class implementation in ROOT context
 /// \endcond
  
 //__________________________________________________________________________
-AliMUONClusterReconstructor::AliMUONClusterReconstructor(AliMUONData* data,
+AliMUONClusterReconstructor::AliMUONClusterReconstructor(AliMUONRecData* data,
                                                          AliMUONVClusterFinder* clusterFinder,
                                                          const AliMUONGeometryTransformer* transformer)
 : TObject(),

diff --git a/MUON/AliMUONClusterReconstructor.h b/MUON/AliMUONClusterReconstructor.h
index b684a2af8fa3bedecde723295fae5148e078be67..5f9670dcd12b4f47c18f156f8eb6c27a6ef53157 100644 (file)
--- a/MUON/AliMUONClusterReconstructor.h
+++ b/MUON/AliMUONClusterReconstructor.h
@@ -13,7 +13,7 @@
 #include <TObject.h>
 
 class AliMUONClusterFinderVS;
-class AliMUONData;
+class AliMUONRecData;
 class TClonesArray;
 class AliMUONVClusterFinder;
 class AliMUONGeometryTransformer;
@@ -21,7 +21,7 @@ class AliMUONGeometryTransformer;
 class AliMUONClusterReconstructor : public TObject 
 {
  public:
-  AliMUONClusterReconstructor(AliMUONData* data = 0x0,
+  AliMUONClusterReconstructor(AliMUONRecData* data = 0x0,
                               AliMUONVClusterFinder* finder = 0x0,
                               const AliMUONGeometryTransformer* transformer = 0x0
                               ); 
@@ -48,7 +48,7 @@ class AliMUONClusterReconstructor : public TObject
   
 private:
   AliMUONVClusterFinder* fClusterFinder; //!< the object doing the real job (not owner)  
-  AliMUONData*            fMUONData;           //!< Data container for MUON subsystem 
+  AliMUONRecData*         fMUONData;           //!< Data container for MUON subsystem 
   AliMUONClusterFinderVS* fRecModel;           //!< cluster recontruction model
 
   TClonesArray* fDigitsCath0; //!< digits for cathode 0 of the current DE

diff --git a/MUON/AliMUONDigitizerV3.cxx b/MUON/AliMUONDigitizerV3.cxx
index 5fbf692d17e710e5c30602ed67ff75db893933af..6df5a2df058a4152403c80f51c980e53bf14f6f3 100644 (file)
--- a/MUON/AliMUONDigitizerV3.cxx
+++ b/MUON/AliMUONDigitizerV3.cxx
@@ -22,7 +22,7 @@
 #include "AliMUONCalibrationData.h"
 #include "AliCDBManager.h"
 #include "AliMUONConstants.h"
-#include "AliMUONData.h"
+#include "AliMUONSimData.h"
 #include "AliMUONDataIterator.h"
 #include "AliMUONDigit.h"
 #include "AliMUONLogger.h"
@@ -409,7 +409,7 @@ AliMUONDigitizerV3::Exec(Option_t*)
   // files.
   for ( Int_t iFile = 0; iFile < nInputFiles; ++iFile )
   {    
-    AliMUONData* inputData = GetDataAccess(fManager->GetInputFolderName(iFile));
+    AliMUONSimData* inputData = GetDataAccess(fManager->GetInputFolderName(iFile));
     if (!inputData)
     {
       AliFatal(Form("Could not get access to input file #%d",iFile));
@@ -655,10 +655,10 @@ AliMUONDigitizerV3::GenerateNoisyDigitsForOneCathode(Int_t detElemId, Int_t cath
 }
 
 //_____________________________________________________________________________
-AliMUONData* 
+AliMUONSimData* 
 AliMUONDigitizerV3::GetDataAccess(const TString& folderName)
 {
-  /// Create an AliMUONData to deal with data found in folderName.
+  /// Create an AliMUONSimData to deal with data found in folderName.
 
   AliDebug(2,Form("Getting access to folder %s",folderName.Data()));
   AliRunLoader* runLoader = AliRunLoader::GetRunLoader(folderName);
@@ -673,8 +673,8 @@ AliMUONDigitizerV3::GetDataAccess(const TString& folderName)
     AliError(Form("Could not get MuonLoader from folder %s",folderName.Data()));
     return 0x0;
   }
-  AliMUONData* data = new AliMUONData(loader,"MUON","MUONDataForDigitOutput");
-  AliDebug(2,Form("AliMUONData=%p loader=%p",data,loader));
+  AliMUONSimData* data = new AliMUONSimData(loader,"MUON","MUONDataForDigitOutput");
+  AliDebug(2,Form("AliMUONSimData=%p loader=%p",data,loader));
   return data;
 }
 
@@ -775,8 +775,8 @@ AliMUONDigitizerV3::MergeDigits(const AliMUONDigit& src,
 
 //_____________________________________________________________________________
 void 
-AliMUONDigitizerV3::MergeWithSDigits(AliMUONData& outputData, 
-                                     const AliMUONData& inputData, Int_t mask)
+AliMUONDigitizerV3::MergeWithSDigits(AliMUONSimData& outputData, 
+                                     const AliMUONSimData& inputData, Int_t mask)
 {
   /// Merge the sdigits in inputData with the digits already present in outputData
 

diff --git a/MUON/AliMUONDigitizerV3.h b/MUON/AliMUONDigitizerV3.h
index 0323abc423caff883c951d57cc4c87d6135c9320..aad00e7374c9dc99e6aca6292187251b1f1e3449 100644 (file)
--- a/MUON/AliMUONDigitizerV3.h
+++ b/MUON/AliMUONDigitizerV3.h
@@ -21,7 +21,7 @@
 #endif
 
 class AliMUONCalibrationData;
-class AliMUONData;
+class AliMUONSimData;
 class AliMUONDigit;
 class AliMUONLogger;
 class AliMUONTriggerEfficiencyCells;
@@ -62,16 +62,16 @@ private:
   void GenerateNoisyDigits();
   void GenerateNoisyDigitsForOneCathode(Int_t detElemId, Int_t cathode);
 
-  AliMUONData* GetDataAccess(const TString& folderName);
+  AliMUONSimData* GetDataAccess(const TString& folderName);
 
   Bool_t MergeDigits(const AliMUONDigit& src, AliMUONDigit& srcAndDest);
 
-  void MergeWithSDigits(AliMUONData& outputData, const AliMUONData& inputData, 
+  void MergeWithSDigits(AliMUONSimData& outputData, const AliMUONSimData& inputData, 
                         Int_t mask);
   
 private:
   Bool_t fIsInitialized; ///< are we initialized ?
-  AliMUONData* fOutputData; //!< pointer to access digits
+  AliMUONSimData* fOutputData; //!< pointer to access digits
   AliMUONCalibrationData* fCalibrationData; //!< pointer to access calib parameters
   TTask* fTriggerProcessor; ///< pointer to the trigger part of the job
   AliMUONTriggerEfficiencyCells* fTriggerEfficiency; ///< trigger efficiency map  
@@ -84,7 +84,7 @@ private:
   /// for noise-only digit generation and zero-suppression
   AliMUONLogger* fLogger; //!< to keep track of messages
   
-  ClassDef(AliMUONDigitizerV3,3) // MUON Digitizer V3-3
+  ClassDef(AliMUONDigitizerV3,4) // MUON Digitizer V3-3
 };
 
 #endif

diff --git a/MUON/AliMUONEventRecoCombi.cxx b/MUON/AliMUONEventRecoCombi.cxx
index 5186222070c4015b4b36520788a338a3d01507f8..899d7b64e3508b562602a5fe35289190753e5dd2 100644 (file)
--- a/MUON/AliMUONEventRecoCombi.cxx
+++ b/MUON/AliMUONEventRecoCombi.cxx
@@ -23,7 +23,7 @@
 
 #include "AliMUONEventRecoCombi.h"
 
-#include "AliMUONData.h"
+#include "AliMUONRecData.h"
 #include "AliMUONDetElement.h"
 #include "AliMUONDigit.h"
 #include "AliMUONHitForRec.h"
@@ -81,7 +81,7 @@ AliMUONEventRecoCombi::~AliMUONEventRecoCombi()
 }
 
 //_________________________________________________________________________
-void AliMUONEventRecoCombi::FillEvent(AliMUONData *data, AliMUONClusterFinderAZ *recModel)
+void AliMUONEventRecoCombi::FillEvent(AliMUONRecData *data, AliMUONClusterFinderAZ *recModel)
 {
   /// Fill event information
 
@@ -182,7 +182,7 @@ void AliMUONEventRecoCombi::FillEvent(AliMUONData *data, AliMUONClusterFinderAZ
 }
 
 //_________________________________________________________________________
-void AliMUONEventRecoCombi::FillRecP(AliMUONData *dataCluster, AliMUONTrackReconstructorK *recoTrack) const
+void AliMUONEventRecoCombi::FillRecP(AliMUONRecData *dataCluster, AliMUONTrackReconstructorK *recoTrack) const
 {
   /// Fill rec. points used for tracking from det. elems
 

diff --git a/MUON/AliMUONEventRecoCombi.h b/MUON/AliMUONEventRecoCombi.h
index 7222b08cf4b92c405d2ebf576dbd2d27eb25ce67..d4625d207b597b5e88d5f228a663da1c5d4d1718 100644 (file)
--- a/MUON/AliMUONEventRecoCombi.h
+++ b/MUON/AliMUONEventRecoCombi.h
@@ -14,7 +14,7 @@
 #include <TArrayD.h>
 #include <TClonesArray.h>
 
-class AliMUONData;
+class AliMUONRecData;
 class AliMUONDetElement;
 class AliMUONTrackReconstructorK;
 class AliMUONClusterFinderAZ;
@@ -27,8 +27,8 @@ class AliMUONEventRecoCombi : public TObject
  public:
     virtual ~AliMUONEventRecoCombi();
     static AliMUONEventRecoCombi* Instance(AliMUONSegmentation* segmentation = 0);
-    void FillEvent(AliMUONData *data, AliMUONClusterFinderAZ *recModel); // fill event info
-    void FillRecP(AliMUONData *dataCluster, AliMUONTrackReconstructorK *recoTrack) const; // fill used rec. points from det. elems
+    void FillEvent(AliMUONRecData *data, AliMUONClusterFinderAZ *recModel); // fill event info
+    void FillRecP(AliMUONRecData *dataCluster, AliMUONTrackReconstructorK *recoTrack) const; // fill used rec. points from det. elems
 
     Int_t Nz() const { return fNZ; } ///< number of DE different Z-positions
     Double_t Z(Int_t iz) const { return (*fZ)[iz]; } ///< Z of DE

diff --git a/MUON/AliMUONRecoCheck.cxx b/MUON/AliMUONRecoCheck.cxx
index 87ce1e9682f35a762fe6133663c41a24be575d2f..1aaa80214b544b75eb5795bbbfd893d8e97918d4 100644 (file)
--- a/MUON/AliMUONRecoCheck.cxx
+++ b/MUON/AliMUONRecoCheck.cxx
@@ -24,7 +24,7 @@
 #include "AliMUON.h"
 #include "AliMUONRecoCheck.h"
 #include "AliMUONTrack.h"
-#include "AliMUONData.h"
+#include "AliMUONRecData.h"
 #include "AliMUONConstants.h"
 
 #include "AliLoader.h" 
@@ -42,10 +42,12 @@ ClassImp(AliMUONRecoCheck)
 /// \endcond
 
 //_____________________________________________________________________________
-  AliMUONRecoCheck::AliMUONRecoCheck(Char_t *chLoader)
+  AliMUONRecoCheck::AliMUONRecoCheck(Char_t *chLoader, Char_t *chLoaderSim)
   : TObject(),
   fRunLoader(0x0),
   fMUONData(0x0),
+  fRunLoaderSim(0x0),
+  fMUONDataSim(0x0),
   fMuonTrackRef(0x0),
   fTrackReco(0x0),
   fReconstructibleTracks(0),
@@ -58,7 +60,7 @@ ClassImp(AliMUONRecoCheck)
   fMuonTrackRef = new TClonesArray("AliMUONTrack", 10);
 
   // run loader
-  fRunLoader = AliRunLoader::Open(chLoader);
+  fRunLoader = AliRunLoader::Open(chLoader,"MUONFolder","READ");
   if (!fRunLoader) {
     AliError(Form("no run loader found " ));
     return;
@@ -68,23 +70,43 @@ ClassImp(AliMUONRecoCheck)
   AliLoader *loader = fRunLoader->GetLoader("MUONLoader");
 
   // container
-  fMUONData  = new AliMUONData(loader,"MUON","MUON");
+  fMUONData  = new AliMUONRecData(loader,"MUON","MUON");
   if (!fMUONData) {
     AliError(Form("no MUONData found " ));
     return;
   }
 
-  fRunLoader->LoadKinematics("READ");   
+  // run loader
+  fRunLoaderSim = AliRunLoader::Open(chLoaderSim,"MUONFolderSim","READ");
+  if (!fRunLoaderSim) {
+    AliError(Form("no run sim loader found " ));
+    return;
+  }
+
+ // initialize loader   
+  AliLoader *loaderSim = fRunLoaderSim->GetLoader("MUONLoader");
+
+  // container
+  fMUONDataSim  = new AliMUONSimData(loaderSim,"MUON","MUON");
+  if (!fMUONDataSim) {
+    AliError(Form("no MUONDataSim found " ));
+    return;
+  }
+
+  fRunLoaderSim->LoadKinematics("READ");        
   fRunLoader->LoadTrackRefs("READ");    
   loader->LoadTracks("READ");
 
 }
 
 //_____________________________________________________________________________
-  AliMUONRecoCheck::AliMUONRecoCheck(AliRunLoader *runloader, AliMUONData *muondata)
+  AliMUONRecoCheck::AliMUONRecoCheck(AliRunLoader *runloader, AliMUONRecData *muondata,
+                                     AliRunLoader *runloaderSim, AliMUONSimData *muondataSim)
   : TObject(),
   fRunLoader(0x0),
   fMUONData(0x0),
+  fRunLoaderSim(0x0),
+  fMUONDataSim(0x0),
   fMuonTrackRef(0x0),
   fTrackReco(0x0),
   fReconstructibleTracks(0),
@@ -111,6 +133,20 @@ ClassImp(AliMUONRecoCheck)
     return;
   }
 
+  // run loader
+  fRunLoaderSim = runloaderSim;
+  if (!fRunLoaderSim) {
+    AliError(Form("no run sim loader found " ));
+    return;
+  }
+
+  // container
+  fMUONDataSim  = muondataSim;
+  if (!fMUONDataSim) {
+    AliError(Form("no MUONDataSim found " ));
+    return;
+  }
+
 }
 
 
@@ -120,11 +156,13 @@ AliMUONRecoCheck::~AliMUONRecoCheck()
 /// Destructor
   delete fMuonTrackRef;
   if(fIsLoadConstructor){
-    fRunLoader->UnloadKinematics();
+    fRunLoaderSim->UnloadKinematics();
     fRunLoader->UnloadTrackRefs();
     fRunLoader->UnloadTracks();
     delete fMUONData;
     delete fRunLoader;
+    delete fMUONDataSim;
+    delete fRunLoaderSim;
   }
 }
 
@@ -166,7 +204,7 @@ void AliMUONRecoCheck::MakeTrackRef()
   Int_t charge;
   TParticlePDG *ppdg;
 
-  Int_t max = fRunLoader->GetHeader()->Stack()->GetNtrack();
+  Int_t max = fRunLoaderSim->GetHeader()->Stack()->GetNtrack();
   for (Int_t iTrackRef  = 0; iTrackRef < nTrackRef; iTrackRef++) {
 
     branch->GetEntry(iTrackRef);
@@ -240,7 +278,7 @@ void AliMUONRecoCheck::MakeTrackRef()
       }
 
       // track parameters at vertex 
-      particle = fRunLoader->GetHeader()->Stack()->Particle(muonTrack->GetTrackID());
+      particle = fRunLoaderSim->GetHeader()->Stack()->Particle(muonTrack->GetTrackID());
 
       if (particle) {
 

diff --git a/MUON/AliMUONRecoCheck.h b/MUON/AliMUONRecoCheck.h
index 061af4bc8dea01995141fd96a0328260e432ebeb..024e17afe105126f5a507a2631bf18c1b648d9d7 100644 (file)
--- a/MUON/AliMUONRecoCheck.h
+++ b/MUON/AliMUONRecoCheck.h
@@ -6,7 +6,7 @@
 
 /* $Id$ */
 
-/// \ingroup base
+/// \ingroup evaluation
 /// \class AliMUONRecoCheck
 /// \brief Utility class to check reconstruction
 
@@ -14,21 +14,24 @@
 #include "AliMUONTrack.h"
 
 class TClonesArray;
-class AliMUONData;
+class AliMUONRecData;
+class AliMUONSimData;
 class AliRunLoader;
 
 
 class AliMUONRecoCheck : public TObject 
 {
 public:
-  AliMUONRecoCheck(Char_t *chLoader);
-  AliMUONRecoCheck(AliRunLoader *runloader, AliMUONData *muondata);
+  AliMUONRecoCheck(Char_t *chLoader, Char_t *chLoaderSim);
+  AliMUONRecoCheck(AliRunLoader *runloader, AliMUONRecData *muondata,
+                   AliRunLoader *runloaderSim, AliMUONSimData *muondataSim);
   virtual          ~AliMUONRecoCheck();
 
   /// Return MUON data          
-  AliMUONData*  GetMUONData() {return fMUONData;}
+  AliMUONRecData*  GetMUONData() {return fMUONData;}
   /// Return run loader         
-  AliRunLoader* GetRunLoader() {return fRunLoader;}
+  AliRunLoader* GetRunLoader()    {return fRunLoader;}
+  AliRunLoader* GetRunLoaderSim() {return fRunLoaderSim;}
 
   void MakeTrackRef();
                 /// Add track reference
@@ -53,10 +56,12 @@ private:
   /// Not implemented
   AliMUONRecoCheck& operator = (const AliMUONRecoCheck& rhs);
   
-  AliRunLoader* fRunLoader;     ///< alice run loader 
-  AliMUONData*  fMUONData;      ///< Data container for MUON subsystem 
-  TClonesArray* fMuonTrackRef;  ///< reference muon tracks
-  TClonesArray* fTrackReco;     ///< reconstructed muon tracks
+  AliRunLoader*   fRunLoader;     ///< alice run loader 
+  AliMUONRecData* fMUONData;      ///< Data container for MUON subsystem 
+  AliRunLoader*   fRunLoaderSim;  ///< alice run loader 
+  AliMUONSimData* fMUONDataSim;   ///< Data container for MUON subsystem 
+  TClonesArray*   fMuonTrackRef;  ///< reference muon tracks
+  TClonesArray*   fTrackReco;     ///< reconstructed muon tracks
   Int_t fReconstructibleTracks; ///< number of reconstructible tracks 
   Int_t fRecoTracks;            ///< number of reconstructed tracks 
   Bool_t fIsLoadConstructor;    //!< \brief boolean to tag the constructor, 

diff --git a/MUON/AliMUONReconstructor.cxx b/MUON/AliMUONReconstructor.cxx
index 5ecfd42618fee5a4b935cc637c929aeaccb4bd92..17c245674dcebd99da348da73e603fb11c84fe71 100644 (file)
--- a/MUON/AliMUONReconstructor.cxx
+++ b/MUON/AliMUONReconstructor.cxx
@@ -26,7 +26,7 @@
 #include "AliMUONCalibrationData.h"
 #include "AliMUONClusterFinderAZ.h"
 #include "AliMUONClusterReconstructor.h"
-#include "AliMUONData.h"
+#include "AliMUONRecData.h"
 #include "AliMUONDigitCalibrator.h"
 #include "AliMUONEventRecoCombi.h" 
 #include "AliMUONDigitMaker.h"
@@ -56,6 +56,7 @@
 
 #include "TTask.h"
 #include "TStopwatch.h"
+#include "Riostream.h"
 
 /// \cond CLASSIMP
 ClassImp(AliMUONReconstructor)
@@ -70,7 +71,7 @@ AliMUONReconstructor::AliMUONReconstructor()
     fTriggerCircuit(new TClonesArray("AliMUONTriggerCircuit", 234)),
     fTransformer(new AliMUONGeometryTransformer(kTRUE)),
     fSegmentation(0x0),
-    fMUONData(new AliMUONData(0x0,"MUON","MUON"))
+    fMUONData(new AliMUONRecData(0x0,"MUON","MUON"))
 {
 /// Default constructor
 
@@ -333,7 +334,7 @@ void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader) const
 void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader, 
                                        AliRawReader* rawReader) const
 {
-/// Recontruct
+/// Recontruct 
 /// \todo add more
 
   //  AliLoader

diff --git a/MUON/AliMUONReconstructor.h b/MUON/AliMUONReconstructor.h
index e8887a99d574b6f2eb347030d61c8abc46b1a7b0..6a4546defc500beb95e0609b56901ec1b241d066 100644 (file)
--- a/MUON/AliMUONReconstructor.h
+++ b/MUON/AliMUONReconstructor.h
@@ -13,7 +13,7 @@
 #include "AliReconstructor.h"
 
 class AliMUONCalibrationData;
-class AliMUONData;
+class AliMUONRecData;
 class AliMUONDigitMaker;
 class AliMUONTriggerCrateStore;
 class AliMUONGeometryTransformer;
@@ -76,7 +76,7 @@ private:
     AliMUONGeometryTransformer* fTransformer; //!< pointer to transformation
     AliMUONSegmentation*        fSegmentation; //!< pointer to segmentation
 
-    AliMUONData* fMUONData;                    //!< pointer to container
+    AliMUONRecData*             fMUONData;     //!< pointer to container
 
   ClassDef(AliMUONReconstructor, 0)   // class for the MUON reconstruction
 };

diff --git a/MUON/AliMUONSDigitizerV2.cxx b/MUON/AliMUONSDigitizerV2.cxx
index 9912a7056ac6f846afca1c8c3ad1a532ab8d4e17..b68c70284e6927790d18cf97c7a602e5f0aaf486 100644 (file)
--- a/MUON/AliMUONSDigitizerV2.cxx
+++ b/MUON/AliMUONSDigitizerV2.cxx
@@ -22,7 +22,7 @@
 #include "AliLog.h"
 #include "AliMUON.h"
 #include "AliMUONChamber.h"
-#include "AliMUONData.h"
+#include "AliMUONSimData.h"
 #include "AliMUONDigit.h"
 #include "AliMUONHit.h"
 #include "AliMpDEManager.h"
@@ -87,7 +87,7 @@ AliMUONSDigitizerV2::Exec(Option_t*)
 
   fLoader->LoadHits("READ");
   
-  AliMUONData muonData(fLoader,"MUON","MUON");
+  AliMUONSimData muonData(fLoader,"MUON","MUON");
 
   AliMUON* muon = static_cast<AliMUON*>(gAlice->GetModule("MUON"));
     

diff --git a/MUON/AliMUONTrackK.cxx b/MUON/AliMUONTrackK.cxx
index 3d624198201a2d1a5b102487c35feba24a4bd343..4a824f6338d599c4c0d20567b3713ca4ddd7770c 100644 (file)
--- a/MUON/AliMUONTrackK.cxx
+++ b/MUON/AliMUONTrackK.cxx
@@ -23,7 +23,7 @@
 // Author: Alexander Zinchenko, JINR Dubna
 
 #include "AliMUONTrackK.h"
-#include "AliMUONData.h"
+#include "AliMUONRecData.h"
 #include "AliMUONConstants.h"
 
 #include "AliMUONTrackReconstructorK.h"

diff --git a/MUON/AliMUONTrackReconstructor.cxx b/MUON/AliMUONTrackReconstructor.cxx
index 7cd149004bf07eddaa61dc40351e2476fbc0559e..5e6937d507e8812bbb344f54a245a37873358d58 100644 (file)
--- a/MUON/AliMUONTrackReconstructor.cxx
+++ b/MUON/AliMUONTrackReconstructor.cxx
@@ -26,7 +26,7 @@
 ///
 
 #include "AliMUONTrackReconstructor.h"
-#include "AliMUONData.h"
+#include "AliMUONRecData.h"
 #include "AliMUONConstants.h"
 #include "AliMUONRawCluster.h"
 #include "AliMUONHitForRec.h"
@@ -56,7 +56,7 @@ const Double_t AliMUONTrackReconstructor::fgkMaxNormChi2 = 100.0;
 const Bool_t AliMUONTrackReconstructor::fgkTrackAllTracks = kFALSE;
 
 //__________________________________________________________________________
-AliMUONTrackReconstructor::AliMUONTrackReconstructor(AliMUONData* data)
+AliMUONTrackReconstructor::AliMUONTrackReconstructor(AliMUONRecData* data)
   : AliMUONVTrackReconstructor(data)
 {
   /// Constructor for class AliMUONTrackReconstructor

diff --git a/MUON/AliMUONTrackReconstructor.h b/MUON/AliMUONTrackReconstructor.h
index 1f5f381a3455fc698d9f00233b82585e746a0944..1c8d00172d58f0dffd55d63bfae6e4ba6d88ef4e 100644 (file)
--- a/MUON/AliMUONTrackReconstructor.h
+++ b/MUON/AliMUONTrackReconstructor.h
@@ -16,7 +16,7 @@ class AliMUONTrack;
 class AliMUONTrackReconstructor : public AliMUONVTrackReconstructor {
 
  public:
-  AliMUONTrackReconstructor(AliMUONData* data); // default Constructor
+  AliMUONTrackReconstructor(AliMUONRecData* data); // default Constructor
   virtual ~AliMUONTrackReconstructor(); // Destructor
 
   virtual void EventDump(void);  // dump reconstructed event

diff --git a/MUON/AliMUONTrackReconstructorK.cxx b/MUON/AliMUONTrackReconstructorK.cxx
index 3e0a554c9d7b5bb67eeff53c0d49b10514e521c0..261b6ea1f53fa838506eeeac977d491c8ab5e54c 100644 (file)
--- a/MUON/AliMUONTrackReconstructorK.cxx
+++ b/MUON/AliMUONTrackReconstructorK.cxx
@@ -29,7 +29,7 @@
 ////////////////////////////////////
 
 #include "AliMUONTrackReconstructorK.h"
-#include "AliMUONData.h"
+#include "AliMUONRecData.h"
 #include "AliMUONConstants.h"
 #include "AliMUONHitForRec.h"
 #include "AliMUONObjectPair.h"
@@ -46,7 +46,7 @@ ClassImp(AliMUONConstants)
 /// \endcond
 
 //__________________________________________________________________________
-AliMUONTrackReconstructorK::AliMUONTrackReconstructorK(AliMUONData* data, const Option_t* TrackMethod)
+AliMUONTrackReconstructorK::AliMUONTrackReconstructorK(AliMUONRecData* data, const Option_t* TrackMethod)
   : AliMUONVTrackReconstructor(data),
     fTrackMethod(2), //tracking method (2-Kalman 3-Combination-Kalman/Clustering)
     fMuons(0)

diff --git a/MUON/AliMUONTrackReconstructorK.h b/MUON/AliMUONTrackReconstructorK.h
index ddb2f9f975e96b2c1826aef1ca58005b76f30782..3b39f721f653bf3a5865ba9a046d558e863ab8d1 100644 (file)
--- a/MUON/AliMUONTrackReconstructorK.h
+++ b/MUON/AliMUONTrackReconstructorK.h
@@ -18,7 +18,7 @@
 class AliMUONTrackReconstructorK : public AliMUONVTrackReconstructor {
 
  public:
-  AliMUONTrackReconstructorK(AliMUONData* data, const Option_t* TrackMethod); // default Constructor
+  AliMUONTrackReconstructorK(AliMUONRecData* data, const Option_t* TrackMethod); // default Constructor
   virtual ~AliMUONTrackReconstructorK(); // Destructor
 
           /// Return track method

diff --git a/MUON/AliMUONTracker.cxx b/MUON/AliMUONTracker.cxx
index 6f192fb6680c5c64f55b691c1b53a49729ec95c5..e2884d560709ee1af20a8e0fe8c7432a86798980 100644 (file)
--- a/MUON/AliMUONTracker.cxx
+++ b/MUON/AliMUONTracker.cxx
@@ -17,7 +17,7 @@
 #include "AliMUONTracker.h"
 #include "AliMUONTrackReconstructorK.h"
 #include "AliMUONTrackReconstructor.h"
-#include "AliMUONData.h"
+#include "AliMUONRecData.h"
 #include "AliLog.h"
 
 //_____________________________________________________________________________

diff --git a/MUON/AliMUONTracker.h b/MUON/AliMUONTracker.h
index a4b28d6c055d3025efedfdd722d5dc5dbeda056f..39dd1ba24c1f84d3f7224a7665a953da6f9ec8da 100644 (file)
--- a/MUON/AliMUONTracker.h
+++ b/MUON/AliMUONTracker.h
@@ -4,14 +4,14 @@
  * See cxx source for full Copyright notice                               */
 
 
-/// \ingroup base
+/// \ingroup rec
 /// \class AliMUONTracker
 /// \brief MUON base Tracker
 
 #include "AliTracker.h"
 class AliESD;
 class AliCluster;
-class AliMUONData;
+class AliMUONRecData;
 class TClonesArray;
 class AliMUONVTrackReconstructor;
 
@@ -38,7 +38,7 @@ class AliMUONTracker : public AliTracker
   /// Set trigger circuit
   void SetTriggerCircuit(TClonesArray* circuit) {fTriggerCircuit = circuit;}
   /// Set pointer to data container
-  void SetMUONData(AliMUONData* data) {fMUONData = data;}
+  void SetMUONData(AliMUONRecData* data) {fMUONData = data;}
   /// Set option
   void SetOption(Option_t* opt);
 
@@ -49,7 +49,7 @@ private:
   AliMUONTracker& operator=(const AliMUONTracker& rhs);
     
   TClonesArray* fTriggerCircuit;                //!< trigger circuit
-  AliMUONData*  fMUONData;                      //!< pointer to container
+  AliMUONRecData*  fMUONData;                   //!< pointer to container
   AliMUONVTrackReconstructor* fTrackReco;       //!< track reconstructor
 
   ClassDef(AliMUONTracker,0)  //tracker base class for MUON

diff --git a/MUON/AliMUONTrigger.cxx b/MUON/AliMUONTrigger.cxx
index 150f3c9c16dde997735c29ae5d51be785533f450..2d0bd7d6ef282e90ac1429123a50f8c5810e4b5a 100644 (file)
--- a/MUON/AliMUONTrigger.cxx
+++ b/MUON/AliMUONTrigger.cxx
@@ -23,7 +23,7 @@
 #include "AliTriggerInput.h"
 
 #include "AliMUON.h"
-#include "AliMUONLoader.h"
+#include "AliMUONSimLoader.h"
 #include "AliMUONData.h"
 #include "AliMUONDigit.h"
 #include "AliMUONGlobalTrigger.h"

diff --git a/MUON/AliMUONTriggerChamberEff.cxx b/MUON/AliMUONTriggerChamberEff.cxx
index 72e00788318526507900614fdfb6425ac9265c6c..4b6d6c844b13f8e22d3b339c60a2bac97b4e224f 100644 (file)
--- a/MUON/AliMUONTriggerChamberEff.cxx
+++ b/MUON/AliMUONTriggerChamberEff.cxx
@@ -29,7 +29,7 @@
 #include "AliMUONGeometryTransformer.h"
 #include "AliMUONSegmentation.h"
 #include "AliMUON.h"
-#include "AliMUONData.h"
+#include "AliMUONRecData.h"
 #include "AliMUONTriggerTrack.h"
 
 #include "AliMpVSegmentation.h"
@@ -126,7 +126,7 @@ void AliMUONTriggerChamberEff::SetGaliceFile(const char *galiceFile)
        AliLoader* loader = fRunLoader->GetLoader("MUONLoader");
        if ( loader )
        {
-           fData = new AliMUONData(loader,"MUON","MUON");
+           fData = new AliMUONRecData(loader,"MUON","MUON");
            loader->LoadTracks("READ");
            loader->LoadDigits("READ");
        }

diff --git a/MUON/AliMUONTriggerChamberEff.h b/MUON/AliMUONTriggerChamberEff.h
index e1161663fd2a0b120453abd27796b882bb964018..a445adb5d2540866d7839590fce5b74bcd6b7789 100644 (file)
--- a/MUON/AliMUONTriggerChamberEff.h
+++ b/MUON/AliMUONTriggerChamberEff.h
@@ -14,7 +14,7 @@
 #include "AliMUONGeometryTransformer.h"
 
 class AliRunLoader;
-class AliMUONData;
+class AliMUONRecData;
 class AliMUON;
 class AliMUONGlobalTrigger;
 class TString;
@@ -53,7 +53,7 @@ private:
     Int_t   fFirstRun; //!< First run to consider
     Int_t   fLastRun;  //!< Last run to consider
     AliRunLoader* fRunLoader; //!< AliRunLoader pointer
-    AliMUONData*  fData; //!< AliMUONData pointer (to access containers)
+    AliMUONRecData*  fData; //!< AliMUONData pointer (to access containers)
     Bool_t fReproduceTrigResponse;//!< Reproduce trigger response
     Bool_t fPrintInfo;//!< Print informations on event
     AliMUON *fMUON; //!< AliMUON pointer

diff --git a/MUON/AliMUONVTrackReconstructor.cxx b/MUON/AliMUONVTrackReconstructor.cxx
index 50dd89ffec0ddcedf0a010b42c2eb47cb187098e..f615a2ca53f37f28494ddc0664c9b210dd8ada97 100644 (file)
--- a/MUON/AliMUONVTrackReconstructor.cxx
+++ b/MUON/AliMUONVTrackReconstructor.cxx
@@ -34,7 +34,7 @@
 ////////////////////////////////////
 
 #include "AliMUONVTrackReconstructor.h"
-#include "AliMUONData.h"
+#include "AliMUONRecData.h"
 #include "AliMUONConstants.h"
 #include "AliMUONHitForRec.h"
 #include "AliMUONObjectPair.h"
@@ -68,7 +68,7 @@ const Double_t AliMUONVTrackReconstructor::fgkDefaultNonBendingVertexDispersion
 const Double_t AliMUONVTrackReconstructor::fgkDefaultMaxNormChi2MatchTrigger = 16.0;
 
 //__________________________________________________________________________
-AliMUONVTrackReconstructor::AliMUONVTrackReconstructor(AliMUONData* data)
+AliMUONVTrackReconstructor::AliMUONVTrackReconstructor(AliMUONRecData* data)
   : TObject(),
     fMinBendingMomentum(fgkDefaultMinBendingMomentum),
     fMaxBendingMomentum(fgkDefaultMaxBendingMomentum),

diff --git a/MUON/AliMUONVTrackReconstructor.h b/MUON/AliMUONVTrackReconstructor.h
index 1d258cbf7e815d0f86181e2b72df1ba6ebbcccdf..7daf14050f4367fdfdad09e26b4b6b950f0f5e91 100644 (file)
--- a/MUON/AliMUONVTrackReconstructor.h
+++ b/MUON/AliMUONVTrackReconstructor.h
@@ -14,14 +14,14 @@
 #include <TObject.h>
 
 class TClonesArray;
-class AliMUONData;
+class AliMUONRecData;
 class AliMUONTriggerTrack;
 class AliMUONTrackHitPattern;
 
 class AliMUONVTrackReconstructor : public TObject {
 
  public:
-  AliMUONVTrackReconstructor(AliMUONData* data); // default Constructor
+  AliMUONVTrackReconstructor(AliMUONRecData* data); // default Constructor
   virtual ~AliMUONVTrackReconstructor(); // Destructor
 
   // Parameters for track reconstruction: public methods
@@ -48,9 +48,9 @@ class AliMUONVTrackReconstructor : public TObject {
   void EventDumpTrigger(void);  // dump reconstructed trigger event
   
           /// Return MUON data
-  AliMUONData*  GetMUONData() {return fMUONData;}
+  AliMUONRecData*  GetMUONData() {return fMUONData;}
           /// Set MUON data
-  void SetMUONData(AliMUONData* data) {fMUONData = data;}
+  void SetMUONData(AliMUONRecData* data) {fMUONData = data;}
 
           /// Set trigger circuit
   void SetTriggerCircuit(TClonesArray* circuit) {fTriggerCircuit = circuit;}
@@ -86,7 +86,7 @@ class AliMUONVTrackReconstructor : public TObject {
   Int_t fNRecTracks; ///< number of reconstructed tracks
 
   // data container
-  AliMUONData* fMUONData; ///< Data container for MUON subsystem 
+  AliMUONRecData* fMUONData; ///< Data container for MUON subsystem 
 
   // Functions
   AliMUONVTrackReconstructor (const AliMUONVTrackReconstructor& rhs); ///< copy constructor

diff --git a/MUON/MUONCheck.C b/MUON/MUONCheck.C
index 5edf302c4e85ad3b664df2bfa9859dc62c8768ef..baf35c6f36e6998dfe9a3e309d328a4c38f814bb 100644 (file)
--- a/MUON/MUONCheck.C
+++ b/MUON/MUONCheck.C
@@ -28,6 +28,7 @@
 #endif
 
 void MUONCheck(Int_t firstEvent, Int_t lastEvent,
+               TString fileNameSim="$ALICE_ROOT/MUON/test_out/galice_sim.root",
                TString fileName="$ALICE_ROOT/MUON/test_out/galice.root",
                TString esdsFileName="$ALICE_ROOT/MUON/test_out/AliESDs.root",
                TString outDir="$ALICE_ROOT/MUON/test_out/DataQualityControl")
@@ -35,7 +36,7 @@ void MUONCheck(Int_t firstEvent, Int_t lastEvent,
    gSystem->Load("libMUONevaluation");
 
    AliMUONCheck* check
-     = new AliMUONCheck(fileName.Data(), esdsFileName.Data(),
+     = new AliMUONCheck(fileName.Data(), fileNameSim.Data(), esdsFileName.Data(),
                         firstEvent, lastEvent, outDir.Data());
       
    check->CheckESD();

diff --git a/MUON/MUONRecoCheck.C b/MUON/MUONRecoCheck.C
index db64db33132c284ea5185f637207c59fa33a7b0e..2f2f6d2e45170a2cd2275caf37df4518ba31c356 100644 (file)
--- a/MUON/MUONRecoCheck.C
+++ b/MUON/MUONRecoCheck.C
@@ -27,19 +27,21 @@
 #include "AliStack.h"
 #include "AliRunLoader.h"
 #include "AliMagFMaps.h"
+#include "AliTracker.h"
 
 // MUON includes
-#include "AliMUON.h"
 #include "AliMUONConstants.h"
 #include "AliMUONTrack.h"
 #include "AliMUONRecoCheck.h"
 #include "AliMUONTrackParam.h"
 #include "AliMUONTrackExtrap.h"
-#include "AliTracker.h"
+#include "AliMUONRecData.h"
+#include "AliMUONSimData.h"
 
 Int_t TrackCheck( Bool_t *compTrack);
 
-void MUONRecoCheck (Int_t nEvent = 1, char* geoFilename = "geometry.root", char * filename="galice.root"){
+void MUONRecoCheck (Int_t nEvent = 1, char* geoFilename = "geometry.root", 
+                    char * filenameSim="galice_sim.root", char * filename="galice.root"){
 
   // Utility macro to check the muon reconstruction. Reconstructed tracks are compared
   // to reference tracks. The reference tracks are built from AliTrackReference for the
@@ -94,15 +96,18 @@ void MUONRecoCheck (Int_t nEvent = 1, char* geoFilename = "geometry.root", char
   // set the magnetic field for track extrapolations
   AliMUONTrackExtrap::SetField(AliTracker::GetFieldMap());
 
-  AliRunLoader* runLoader = AliRunLoader::Open(filename,"read");
+  AliRunLoader* runLoaderSim = AliRunLoader::Open(filenameSim, "MUONFolderSim", "read");
+  AliRunLoader* runLoader = AliRunLoader::Open(filename, "MUONFolder", "read");
   AliLoader * MUONLoader = runLoader->GetLoader("MUONLoader");
-  AliMUONData * MUONData = new AliMUONData(MUONLoader,"MUON","MUON");
+  AliLoader * MUONLoaderSim = runLoaderSim->GetLoader("MUONLoader");
+  AliMUONRecData * MUONData = new AliMUONRecData(MUONLoader,"MUON","MUON");
+  AliMUONSimData * MUONDataSim = new AliMUONSimData(MUONLoaderSim,"MUON","MUON");
 
-  runLoader->LoadKinematics("READ");
-  runLoader->LoadTrackRefs("READ");
+  runLoaderSim->LoadKinematics("READ");
+  runLoaderSim->LoadTrackRefs("READ");
   MUONLoader->LoadTracks("READ");
   
-  AliMUONRecoCheck rc(runLoader,MUONData);
+  AliMUONRecoCheck rc(runLoader, MUONData, runLoaderSim, MUONDataSim);
     
   Int_t nevents = runLoader->GetNumberOfEvents();
   
@@ -115,7 +120,9 @@ void MUONRecoCheck (Int_t nEvent = 1, char* geoFilename = "geometry.root", char
 
   for (ievent=0; ievent<nEvent; ievent++) {
     if (!(ievent%10)) printf(" **** event # %d  \n",ievent);
+    runLoaderSim->GetEvent(ievent);
     runLoader->GetEvent(ievent);
+
     rc.ResetTracks();
     rc.MakeTrackRef(); // make reconstructible tracks
 //     rc.PrintEvent();
@@ -166,7 +173,7 @@ void MUONRecoCheck (Int_t nEvent = 1, char* geoFilename = "geometry.root", char
       if (testTrack == 4) {     // tracking requirements verified, track is found
        nReconstructibleTracksCheck++;
        hNHitComp->Fill(nHitOK);
-       particle = runLoader->GetHeader()->Stack()->Particle(trackID);
+       particle = runLoaderSim->GetHeader()->Stack()->Particle(trackID);
 //     printf(" trackID: %d , PDG code: %d \n",trackID,particle->GetPdgCode());
        trackParam = trackRef->GetTrackParamAtVertex();
        x1 = trackParam->GetNonBendingCoor();
@@ -218,15 +225,17 @@ void MUONRecoCheck (Int_t nEvent = 1, char* geoFilename = "geometry.root", char
               
       }
     } // end loop track ref.
-
+    
   } // end loop on event  
 
   MUONLoader->UnloadTracks();
-  runLoader->UnloadKinematics();
+  runLoaderSim->UnloadKinematics();
   runLoader->UnloadTrackRefs();
   delete runLoader;
+  delete runLoaderSim;
   delete field;
   delete MUONData;
+  delete MUONDataSim;
 
   printf(" nb of reconstructible tracks: %d \n", nReconstructibleTracks);
   printf(" nb of reconstructed tracks: %d \n", nReconstructedTracks);

diff --git a/MUON/MUONTrigger.C b/MUON/MUONTrigger.C
index 60297e67c460e7a35146d12ceb679385509e0a42..339dc3077287fe464b5239ca7191abe32b43b368 100644 (file)
--- a/MUON/MUONTrigger.C
+++ b/MUON/MUONTrigger.C
@@ -31,7 +31,7 @@
 #include "AliCDBManager.h"
 #include <TClonesArray.h>
 #endif
-void MUONTrigger(char * FileName="galice.root")
+void MUONTrigger(char * FileNameSim="galice_sim.root", char * FileName="galice.root")
 {
     // Creating Run Loader and openning file containing Digits 
     AliRunLoader * RunLoader = AliRunLoader::Open(FileName,"MUONLoader","UPDATE");

diff --git a/MUON/MUONTriggerEfficiency.C b/MUON/MUONTriggerEfficiency.C
index 660fc78bf18cbf5c473cb4bd6a6dda87549d73a3..e16828ecf6de968103000422bbc7f4f441cb1f38 100644 (file)
--- a/MUON/MUONTriggerEfficiency.C
+++ b/MUON/MUONTriggerEfficiency.C
@@ -41,7 +41,8 @@
 
 // MUON includes
 #include "AliMUON.h"
-#include "AliMUONData.h"
+#include "AliMUONSimData.h"
+#include "AliMUONRecData.h"
 #include "AliMUONHit.h"
 #include "AliMUONConstants.h"
 #include "AliMUONDigit.h"
@@ -54,7 +55,9 @@
 // Upsilon(1S)
 
 
-void MUONTriggerEfficiency (char filename[10]="galice.root",  Bool_t readFromRP = 0){
+void MUONTriggerEfficiency (char filenameSim[10]="galice_sim.root", 
+                            char filenameRec[10]="galice.root",  
+                            Bool_t readFromRP = 0){
  
 // output file
   char digitdat[100];
@@ -71,28 +74,38 @@ void MUONTriggerEfficiency (char filename[10]="galice.root",  Bool_t readFromRP
  
 // Initialise AliRoot
    // Creating Run Loader and openning file containing Hits
-   AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
+   AliRunLoader * RunLoaderSim = AliRunLoader::Open(filenameSim,"MUONFolderSim","READ");
     
-   if (RunLoader ==0x0) {
+   if (RunLoaderSim ==0x0) {
        printf(">>> Error : Error Opening %s file \n",currentfile);
        return;
    }
              
-   nevents = RunLoader->GetNumberOfEvents();          
+   AliRunLoader * RunLoaderRec = AliRunLoader::Open(filenameRec,"MUONFolder","READ");
+    
+   if (RunLoaderRec ==0x0) {
+       printf(">>> Error : Error Opening %s file \n",currentfile);
+       return;
+   }
+             
+   nevents = RunLoaderSim->GetNumberOfEvents();          
      
  
-   AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
+   AliLoader * MUONLoaderSim = RunLoaderSim->GetLoader("MUONLoader");
+   AliLoader * MUONLoaderRec = RunLoaderRec->GetLoader("MUONLoader");
+   
    if (!readFromRP) {
        cout << " reading from digits \n";
-       MUONLoader->LoadDigits("READ");
+       MUONLoaderSim->LoadDigits("READ");
    } else {
        cout << " reading from RecPoints \n";
-       MUONLoader->LoadRecPoints("READ");
+       MUONLoaderRec->LoadRecPoints("READ");
    }
-   MUONLoader->LoadHits("READ");
+   MUONLoaderSim->LoadHits("READ");
    
-   // Creating MUON data container
-   AliMUONData muondata(MUONLoader,"MUON","MUON");
+   // Creating MUON data containers
+   AliMUONSimData muondataSim(MUONLoaderSim,"MUON","MUON");
+   AliMUONRecData muondataRec(MUONLoaderRec,"MUON","MUON");
 
    TClonesArray * globalTrigger;
    AliMUONGlobalTrigger * gloTrg; 
@@ -101,12 +114,13 @@ void MUONTriggerEfficiency (char filename[10]="galice.root",  Bool_t readFromRP
    for (Int_t ievent=0; ievent<nevents; ievent++) {    // event loop
        CoincMuPlus=0;
        CoincMuMinus=0;
-       RunLoader->GetEvent(ievent);
+       RunLoaderSim->GetEvent(ievent);
+       RunLoaderRec->GetEvent(ievent);
          
      if (ievent%1000==0) printf("\t Event = %d\n",ievent);    
 
 // Hits
-     muondata.SetTreeAddress("H");    
+     muondataSim.SetTreeAddress("H");    
         
     Int_t itrack, ntracks, NbHits[2][4];
     Int_t SumNbHits;
@@ -115,15 +129,16 @@ void MUONTriggerEfficiency (char filename[10]="galice.root",  Bool_t readFromRP
       NbHits[j][jj]=0;
      }
     } 
-    ntracks = (Int_t) muondata.GetNtracks();      
+    ntracks = (Int_t) muondataSim.GetNtracks();      
     for (itrack=0; itrack<ntracks; itrack++) { // Track loop
-      muondata.GetTrack(itrack); 
+    
+      muondataSim.GetTrack(itrack); 
 
       Int_t ihit, nhits;
-      nhits = (Int_t) muondata.Hits()->GetEntriesFast();   
+      nhits = (Int_t) muondataSim.Hits()->GetEntriesFast();   
       AliMUONHit* mHit;
       for(ihit=0; ihit<nhits; ihit++) {
-        mHit = static_cast<AliMUONHit*>(muondata.Hits()->At(ihit));
+        mHit = static_cast<AliMUONHit*>(muondataSim.Hits()->At(ihit));
         Int_t Nch        = mHit->Chamber(); 
         Int_t hittrack   = mHit->Track();
         Float_t IdPart     = mHit->Particle();
@@ -137,7 +152,7 @@ void MUONTriggerEfficiency (char filename[10]="galice.root",  Bool_t readFromRP
         }
        }
        
-      muondata.ResetHits();
+      muondataSim.ResetHits();
       
     } // end track loop     
     
@@ -152,35 +167,39 @@ void MUONTriggerEfficiency (char filename[10]="galice.root",  Bool_t readFromRP
            
 // Trigger
     if (!readFromRP) {
-       muondata.SetTreeAddress("D,GLT"); 
-       muondata.GetTriggerD();
+       muondataSim.SetTreeAddress("D,GLT"); 
+       muondataSim.GetTriggerD();
+        globalTrigger = muondataSim.GlobalTrigger();
     } else {    
-       muondata.SetTreeAddress("RC,TC"); 
-       muondata.GetTrigger();
+       muondataRec.SetTreeAddress("RC,TC"); 
+       muondataRec.GetTrigger();
+        globalTrigger = muondataRec.GlobalTrigger();
     }
    
-    globalTrigger = muondata.GlobalTrigger();
-
     Int_t nglobals = (Int_t) globalTrigger->GetEntriesFast(); // should be 1
 
     for (Int_t iglobal=0; iglobal<nglobals; iglobal++) { // Global Trigger
+    
       gloTrg = static_cast<AliMUONGlobalTrigger*>(globalTrigger->At(iglobal));
-      
+            
        if (gloTrg->PairUnlikeLpt()>=1) muonlpt++;
        if (gloTrg->PairUnlikeHpt()>=1) muonhpt++;
                                
     } // end of loop on Global Trigger         
     
-    muondata.ResetTrigger();    
+    //if (!readFromRP) 
+      muondataSim.ResetTrigger();  
+    //else    
+      muondataRec.ResetTrigger();  
 
   } // end loop on event  
 
-   MUONLoader->UnloadHits();
+   MUONLoaderSim->UnloadHits();
 
   if (!readFromRP) {
-      MUONLoader->UnloadDigits();  
+      MUONLoaderSim->UnloadDigits();  
   } else {    
-      MUONLoader->UnloadRecPoints();
+      MUONLoaderRec->UnloadRecPoints();
   }  
  
   // calculate efficiency with as a ref. at least 3/4 planes fired

diff --git a/MUON/MUONdisplay.C b/MUON/MUONdisplay.C
index 4b219f4c358c2efc121f79a5f4dd00364043e5b5..bfd8cb167b77dd42c7225ddcf9ae0885f42a1fd7 100644 (file)
--- a/MUON/MUONdisplay.C
+++ b/MUON/MUONdisplay.C
@@ -35,36 +35,47 @@
 
 
 
-void MUONdisplay (Int_t nevent=0, TString fileName="galice.root") {
+void MUONdisplay (Int_t nevent=0, 
+                  TString fileName="galice.root",
+                  TString fileNameSim="galice_sim.root") {
 
   // set off mag field 
   AliMagF::SetReadField(kFALSE);
  
   // Getting runloader 
-  AliRunLoader * RunLoader = AliRunLoader::Open(fileName.Data(),"MUONFolder","READ");
-  if (RunLoader == 0x0) {
+  AliRunLoader * RunLoaderSim = AliRunLoader::Open(fileNameSim.Data(),"MUONFolderSim","READ");
+  if (RunLoaderSim == 0x0) {
     Error("MUONdisplay","Inut file %s error!",fileName.Data());
     return;   
   }
-  RunLoader->LoadHeader();
-  RunLoader->LoadKinematics("READ");
+  RunLoaderSim->LoadHeader();
+  RunLoaderSim->LoadKinematics("READ");
 
   //  if (RunLoader->GetAliRun() == 0x0) 
-  RunLoader->LoadgAlice();
-  gAlice = RunLoader->GetAliRun();
+  RunLoaderSim->LoadgAlice();
+  gAlice = RunLoaderSim->GetAliRun();
 
   // Getting MUONloader 
-  AliLoader * MUONLoader  = RunLoader->GetLoader("MUONLoader");
-  MUONLoader->LoadHits("READ");
-  MUONLoader->LoadDigits("READ");
-  MUONLoader->LoadRecPoints("READ");
-  MUONLoader->LoadTracks("READ");
+  AliLoader * MUONLoaderSim  = RunLoaderSim->GetLoader("MUONLoader");
+  MUONLoaderSim->LoadHits("READ");
+  MUONLoaderSim->LoadDigits("READ");
+  
+  // Getting runloader 
+  AliRunLoader * RunLoaderRec = AliRunLoader::Open(fileName.Data(),"MUONFolder","READ");
+  if (RunLoaderRec == 0x0) {
+    Error("MUONdisplay","Inut file %s error!",fileName.Data());
+    return;   
+  }
+  AliLoader * MUONLoaderRec  = RunLoaderRec->GetLoader("MUONLoader");
+  MUONLoaderRec->LoadRecPoints("READ");
+  MUONLoaderRec->LoadTracks("READ");
 
 
   // Create Event Display object
-  AliMUONDisplay *muondisplay = new AliMUONDisplay(750, MUONLoader);
+  AliMUONDisplay *muondisplay = new AliMUONDisplay(750, MUONLoaderSim, MUONLoaderRec);
 
   // Display first event
-  RunLoader->GetEvent(nevent);
+  RunLoaderSim->GetEvent(nevent);
+  RunLoaderRec->GetEvent(nevent);
   muondisplay->ShowNextEvent(0);
 }

diff --git a/MUON/MUONefficiency.C b/MUON/MUONefficiency.C
index 609b1ac1b59b5929e49f41885de05b5a6f7ee566..21c3e50d7df6d48dabd0978f7422e305a2a63298 100644 (file)
--- a/MUON/MUONefficiency.C
+++ b/MUON/MUONefficiency.C
@@ -77,8 +77,8 @@
 //   ResType (default 553)
 //      553 for Upsilon, anything else for J/Psi
 
-Bool_t MUONefficiency( Int_t ExtrapToVertex = -1, Int_t ResType = 553, Int_t FirstEvent = 0, Int_t LastEvent = 1000000,
-                      char* geoFilename = "geometry.root", char* esdFileName = "AliESDs.root", char* filename = "galice.root")
+Bool_t MUONefficiency( char* filename = "galice.root", char* geoFilename = "geometry.root", char* esdFileName = "AliESDs.root",
+                       Int_t ExtrapToVertex = -1, Int_t ResType = 553, Int_t FirstEvent = 0, Int_t LastEvent = 1000000 )
 { // MUONefficiency starts
 
   Double_t MUON_MASS = 0.105658369;

diff --git a/MUON/MUONmassPlot_ESD.C b/MUON/MUONmassPlot_ESD.C
index 830d86537ce127ba604d2cf6aa513f644c458e3c..e2a5979954d3664557932a1379b0cdae781f9779 100644 (file)
--- a/MUON/MUONmassPlot_ESD.C
+++ b/MUON/MUONmassPlot_ESD.C
@@ -63,7 +63,7 @@
 
 // Add parameters and histograms for analysis 
 
-Bool_t MUONmassPlot(Int_t ExtrapToVertex = -1, char* geoFilename = "geometry.root", char* filename = "galice.root",
+Bool_t MUONmassPlot(char* filename = "galice_sim.root", Int_t ExtrapToVertex = -1, char* geoFilename = "geometry.root", 
                  Int_t FirstEvent = 0, Int_t LastEvent = 10000, char* esdFileName = "AliESDs.root", Int_t ResType = 553, 
                   Float_t Chi2Cut = 100., Float_t PtCutMin = 1., Float_t PtCutMax = 10000.,
                   Float_t massMin = 9.17,Float_t massMax = 9.77)
@@ -152,12 +152,13 @@ Bool_t MUONmassPlot(Int_t ExtrapToVertex = -1, char* geoFilename = "geometry.roo
     Error("MUONmass_ESD", "getting run loader from file %s failed", filename);
     return kFALSE;
   }
-
+/*  
+  runLoader->LoadgAlice();
   if (!gAlice) {
     Error("MUONmass_ESD", "no galice object found");
     return kFALSE;
   }
-  
+*/  
 
   // open the ESD file
   TFile* esdFile = TFile::Open(esdFileName);