From 6b092dfc5b92d57f52172c8c08f1c01fa953c513 Mon Sep 17 00:00:00 2001 From: ivana Date: Wed, 2 May 2007 14:15:06 +0000 Subject: [PATCH] Updated for separation of simulation and reconstruction classes (namely AliMUONData class) --- MUON/AliMUONCheck.cxx | 32 ++++++------ MUON/AliMUONCheck.h | 9 ++-- MUON/AliMUONClusterReconstructor.cxx | 4 +- MUON/AliMUONClusterReconstructor.h | 6 +-- MUON/AliMUONDigitizerV3.cxx | 16 +++--- MUON/AliMUONDigitizerV3.h | 10 ++-- MUON/AliMUONEventRecoCombi.cxx | 6 +-- MUON/AliMUONEventRecoCombi.h | 6 +-- MUON/AliMUONRecoCheck.cxx | 56 ++++++++++++++++---- MUON/AliMUONRecoCheck.h | 25 +++++---- MUON/AliMUONReconstructor.cxx | 7 +-- MUON/AliMUONReconstructor.h | 4 +- MUON/AliMUONSDigitizerV2.cxx | 4 +- MUON/AliMUONTrackK.cxx | 2 +- MUON/AliMUONTrackReconstructor.cxx | 4 +- MUON/AliMUONTrackReconstructor.h | 2 +- MUON/AliMUONTrackReconstructorK.cxx | 4 +- MUON/AliMUONTrackReconstructorK.h | 2 +- MUON/AliMUONTracker.cxx | 2 +- MUON/AliMUONTracker.h | 8 +-- MUON/AliMUONTrigger.cxx | 2 +- MUON/AliMUONTriggerChamberEff.cxx | 4 +- MUON/AliMUONTriggerChamberEff.h | 4 +- MUON/AliMUONVTrackReconstructor.cxx | 4 +- MUON/AliMUONVTrackReconstructor.h | 10 ++-- MUON/MUONCheck.C | 3 +- MUON/MUONRecoCheck.C | 31 +++++++---- MUON/MUONTrigger.C | 2 +- MUON/MUONTriggerEfficiency.C | 77 +++++++++++++++++----------- MUON/MUONdisplay.C | 39 +++++++++----- MUON/MUONefficiency.C | 4 +- MUON/MUONmassPlot_ESD.C | 7 +-- 32 files changed, 242 insertions(+), 154 deletions(-) diff --git a/MUON/AliMUONCheck.cxx b/MUON/AliMUONCheck.cxx index d5ad904c5be..422c723324f 100644 --- 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; ieventGetEvent(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 b0908feb3ad..e5a50221ad6 100644 --- 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 7c610922870..9decfd382d7 100644 --- 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 b684a2af8fa..5f9670dcd12 100644 --- a/MUON/AliMUONClusterReconstructor.h +++ b/MUON/AliMUONClusterReconstructor.h @@ -13,7 +13,7 @@ #include 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 5fbf692d17e..6df5a2df058 100644 --- 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 0323abc423c..aad00e7374c 100644 --- 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 5186222070c..899d7b64e35 100644 --- 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 7222b08cf4b..d4625d207b5 100644 --- a/MUON/AliMUONEventRecoCombi.h +++ b/MUON/AliMUONEventRecoCombi.h @@ -14,7 +14,7 @@ #include #include -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 87ce1e9682f..1aaa80214b5 100644 --- 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 061af4bc8de..024e17afe10 100644 --- 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 5ecfd42618f..17c245674dc 100644 --- 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 e8887a99d57..6a4546defc5 100644 --- 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 9912a7056ac..b68c70284e6 100644 --- 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(gAlice->GetModule("MUON")); diff --git a/MUON/AliMUONTrackK.cxx b/MUON/AliMUONTrackK.cxx index 3d624198201..4a824f6338d 100644 --- 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 7cd149004bf..5e6937d507e 100644 --- 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 1f5f381a345..1c8d00172d5 100644 --- 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 3e0a554c9d7..261b6ea1f53 100644 --- 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 ddb2f9f975e..3b39f721f65 100644 --- 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 6f192fb6680..e2884d56070 100644 --- 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 a4b28d6c055..39dd1ba24c1 100644 --- 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 150f3c9c16d..2d0bd7d6ef2 100644 --- 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 72e00788318..4b6d6c844b1 100644 --- 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 e1161663fd2..a445adb5d25 100644 --- 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 50dd89ffec0..f615a2ca53f 100644 --- 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 1d258cbf7e8..7daf14050f4 100644 --- a/MUON/AliMUONVTrackReconstructor.h +++ b/MUON/AliMUONVTrackReconstructor.h @@ -14,14 +14,14 @@ #include 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 5edf302c4e8..baf35c6f36e 100644 --- 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 db64db33132..2f2f6d2e451 100644 --- 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; ieventGetEvent(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 60297e67c46..339dc307728 100644 --- a/MUON/MUONTrigger.C +++ b/MUON/MUONTrigger.C @@ -31,7 +31,7 @@ #include "AliCDBManager.h" #include #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 660fc78bf18..e16828ecf6d 100644 --- 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; ieventGetEvent(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; itrackGetEntriesFast(); + nhits = (Int_t) muondataSim.Hits()->GetEntriesFast(); AliMUONHit* mHit; for(ihit=0; ihit(muondata.Hits()->At(ihit)); + mHit = static_cast(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(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 4b219f4c358..bfd8cb167b7 100644 --- 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 609b1ac1b59..21c3e50d7df 100644 --- 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 830d86537ce..e2a5979954d 100644 --- 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); -- 2.43.0