/// \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"
/// \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),
fLastEvent(lastEvent),
fRunLoader(0x0),
fRunLoaderSim(0x0),
- fData(0x0),
- fDataSim(0x0),
+ fRecData(0x0),
+ fSimData(0x0),
fTree(0)
{
/// ctor
fLoader = fRunLoader->GetLoader("MUONLoader");
if ( fLoader )
{
- fData = new AliMUONData(fLoader,"MUON","MUON");
+ fRecData = new AliMUONRecData(fLoader,"MUON","MUON");
}
else
{
fLoaderSim = fRunLoaderSim->GetLoader("MUONLoader");
if ( fLoaderSim )
{
- fDataSim = new AliMUONData(fLoaderSim,"MUON","MUON");
+ fSimData = new AliMUONSimData(fLoaderSim,"MUON","MUON");
}
else
{
fLastEvent(lastEvent),
fRunLoader(0x0),
fRunLoaderSim(0x0),
- fData(0x0),
- fDataSim(0x0),
+ fRecData(0x0),
+ fSimData(0x0),
fTree(0)
{
/// ctor
fLoader = fRunLoader->GetLoader("MUONLoader");
if ( fLoader )
{
- fData = new AliMUONData(fLoader,"MUON","MUON");
+ fRecData = new AliMUONRecData(fLoader,"MUON","MUON");
}
else
{
fLoaderSim = fRunLoaderSim->GetLoader("MUONLoader");
if ( fLoaderSim )
{
- fDataSim = new AliMUONData(fLoaderSim,"MUON","MUON");
+ fSimData = new AliMUONSimData(fLoaderSim,"MUON","MUON");
}
else
{
fRunLoader->UnloadAll();
fRunLoaderSim->UnloadAll();
delete fRunLoader;
- delete fData;
+ delete fRecData;
delete fRunLoaderSim;
- delete fDataSim;
+ delete fSimData;
}
//_____________________________________________________________________________
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);
AliMUONTrackExtrap::ExtrapToZ(trackParam,0.);
recTrack->Print("full");
}
- fData->ResetRecTracks();
+ fRecData->ResetRecTracks();
}
fLoader->UnloadTracks();
}
# include "TString.h"
#endif
-class AliMUONData;
+class AliMUONSimData;
+class AliMUONRecData;
class AliRunLoader;
class AliLoader;
class AliESD;
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();
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
#include "AliMUONDigit.h"
#include "AliMUONConstants.h"
-#include "AliMUONData.h"
+#include "AliMUONRecData.h"
#include "AliMUONClusterFinderVS.h"
#include "AliMUONClusterInput.h"
#include "AliMUONRawCluster.h"
/// \endcond
//__________________________________________________________________________
-AliMUONClusterReconstructor::AliMUONClusterReconstructor(AliMUONData* data,
+AliMUONClusterReconstructor::AliMUONClusterReconstructor(AliMUONRecData* data,
AliMUONVClusterFinder* clusterFinder,
const AliMUONGeometryTransformer* transformer)
: TObject(),
#include <TObject.h>
class AliMUONClusterFinderVS;
-class AliMUONData;
+class AliMUONRecData;
class TClonesArray;
class AliMUONVClusterFinder;
class AliMUONGeometryTransformer;
class AliMUONClusterReconstructor : public TObject
{
public:
- AliMUONClusterReconstructor(AliMUONData* data = 0x0,
+ AliMUONClusterReconstructor(AliMUONRecData* data = 0x0,
AliMUONVClusterFinder* finder = 0x0,
const AliMUONGeometryTransformer* transformer = 0x0
);
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
#include "AliMUONCalibrationData.h"
#include "AliCDBManager.h"
#include "AliMUONConstants.h"
-#include "AliMUONData.h"
+#include "AliMUONSimData.h"
#include "AliMUONDataIterator.h"
#include "AliMUONDigit.h"
#include "AliMUONLogger.h"
// 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));
}
//_____________________________________________________________________________
-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);
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;
}
//_____________________________________________________________________________
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
#endif
class AliMUONCalibrationData;
-class AliMUONData;
+class AliMUONSimData;
class AliMUONDigit;
class AliMUONLogger;
class AliMUONTriggerEfficiencyCells;
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
/// 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
#include "AliMUONEventRecoCombi.h"
-#include "AliMUONData.h"
+#include "AliMUONRecData.h"
#include "AliMUONDetElement.h"
#include "AliMUONDigit.h"
#include "AliMUONHitForRec.h"
}
//_________________________________________________________________________
-void AliMUONEventRecoCombi::FillEvent(AliMUONData *data, AliMUONClusterFinderAZ *recModel)
+void AliMUONEventRecoCombi::FillEvent(AliMUONRecData *data, AliMUONClusterFinderAZ *recModel)
{
/// Fill event information
}
//_________________________________________________________________________
-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
#include <TArrayD.h>
#include <TClonesArray.h>
-class AliMUONData;
+class AliMUONRecData;
class AliMUONDetElement;
class AliMUONTrackReconstructorK;
class AliMUONClusterFinderAZ;
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
#include "AliMUON.h"
#include "AliMUONRecoCheck.h"
#include "AliMUONTrack.h"
-#include "AliMUONData.h"
+#include "AliMUONRecData.h"
#include "AliMUONConstants.h"
#include "AliLoader.h"
/// \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),
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;
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),
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;
+ }
+
}
/// Destructor
delete fMuonTrackRef;
if(fIsLoadConstructor){
- fRunLoader->UnloadKinematics();
+ fRunLoaderSim->UnloadKinematics();
fRunLoader->UnloadTrackRefs();
fRunLoader->UnloadTracks();
delete fMUONData;
delete fRunLoader;
+ delete fMUONDataSim;
+ delete fRunLoaderSim;
}
}
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);
}
// track parameters at vertex
- particle = fRunLoader->GetHeader()->Stack()->Particle(muonTrack->GetTrackID());
+ particle = fRunLoaderSim->GetHeader()->Stack()->Particle(muonTrack->GetTrackID());
if (particle) {
/* $Id$ */
-/// \ingroup base
+/// \ingroup evaluation
/// \class AliMUONRecoCheck
/// \brief Utility class to check reconstruction
#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
/// 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,
#include "AliMUONCalibrationData.h"
#include "AliMUONClusterFinderAZ.h"
#include "AliMUONClusterReconstructor.h"
-#include "AliMUONData.h"
+#include "AliMUONRecData.h"
#include "AliMUONDigitCalibrator.h"
#include "AliMUONEventRecoCombi.h"
#include "AliMUONDigitMaker.h"
#include "TTask.h"
#include "TStopwatch.h"
+#include "Riostream.h"
/// \cond CLASSIMP
ClassImp(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
void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader,
AliRawReader* rawReader) const
{
-/// Recontruct
+/// Recontruct
/// \todo add more
// AliLoader
#include "AliReconstructor.h"
class AliMUONCalibrationData;
-class AliMUONData;
+class AliMUONRecData;
class AliMUONDigitMaker;
class AliMUONTriggerCrateStore;
class AliMUONGeometryTransformer;
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
};
#include "AliLog.h"
#include "AliMUON.h"
#include "AliMUONChamber.h"
-#include "AliMUONData.h"
+#include "AliMUONSimData.h"
#include "AliMUONDigit.h"
#include "AliMUONHit.h"
#include "AliMpDEManager.h"
fLoader->LoadHits("READ");
- AliMUONData muonData(fLoader,"MUON","MUON");
+ AliMUONSimData muonData(fLoader,"MUON","MUON");
AliMUON* muon = static_cast<AliMUON*>(gAlice->GetModule("MUON"));
// Author: Alexander Zinchenko, JINR Dubna
#include "AliMUONTrackK.h"
-#include "AliMUONData.h"
+#include "AliMUONRecData.h"
#include "AliMUONConstants.h"
#include "AliMUONTrackReconstructorK.h"
///
#include "AliMUONTrackReconstructor.h"
-#include "AliMUONData.h"
+#include "AliMUONRecData.h"
#include "AliMUONConstants.h"
#include "AliMUONRawCluster.h"
#include "AliMUONHitForRec.h"
const Bool_t AliMUONTrackReconstructor::fgkTrackAllTracks = kFALSE;
//__________________________________________________________________________
-AliMUONTrackReconstructor::AliMUONTrackReconstructor(AliMUONData* data)
+AliMUONTrackReconstructor::AliMUONTrackReconstructor(AliMUONRecData* data)
: AliMUONVTrackReconstructor(data)
{
/// Constructor for class AliMUONTrackReconstructor
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
////////////////////////////////////
#include "AliMUONTrackReconstructorK.h"
-#include "AliMUONData.h"
+#include "AliMUONRecData.h"
#include "AliMUONConstants.h"
#include "AliMUONHitForRec.h"
#include "AliMUONObjectPair.h"
/// \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)
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
#include "AliMUONTracker.h"
#include "AliMUONTrackReconstructorK.h"
#include "AliMUONTrackReconstructor.h"
-#include "AliMUONData.h"
+#include "AliMUONRecData.h"
#include "AliLog.h"
//_____________________________________________________________________________
* 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;
/// 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);
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
#include "AliTriggerInput.h"
#include "AliMUON.h"
-#include "AliMUONLoader.h"
+#include "AliMUONSimLoader.h"
#include "AliMUONData.h"
#include "AliMUONDigit.h"
#include "AliMUONGlobalTrigger.h"
#include "AliMUONGeometryTransformer.h"
#include "AliMUONSegmentation.h"
#include "AliMUON.h"
-#include "AliMUONData.h"
+#include "AliMUONRecData.h"
#include "AliMUONTriggerTrack.h"
#include "AliMpVSegmentation.h"
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");
}
#include "AliMUONGeometryTransformer.h"
class AliRunLoader;
-class AliMUONData;
+class AliMUONRecData;
class AliMUON;
class AliMUONGlobalTrigger;
class TString;
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
////////////////////////////////////
#include "AliMUONVTrackReconstructor.h"
-#include "AliMUONData.h"
+#include "AliMUONRecData.h"
#include "AliMUONConstants.h"
#include "AliMUONHitForRec.h"
#include "AliMUONObjectPair.h"
const Double_t AliMUONVTrackReconstructor::fgkDefaultMaxNormChi2MatchTrigger = 16.0;
//__________________________________________________________________________
-AliMUONVTrackReconstructor::AliMUONVTrackReconstructor(AliMUONData* data)
+AliMUONVTrackReconstructor::AliMUONVTrackReconstructor(AliMUONRecData* data)
: TObject(),
fMinBendingMomentum(fgkDefaultMinBendingMomentum),
fMaxBendingMomentum(fgkDefaultMaxBendingMomentum),
#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
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;}
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
#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")
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();
#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
// 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();
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();
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();
}
} // 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);
#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");
// MUON includes
#include "AliMUON.h"
-#include "AliMUONData.h"
+#include "AliMUONSimData.h"
+#include "AliMUONRecData.h"
#include "AliMUONHit.h"
#include "AliMUONConstants.h"
#include "AliMUONDigit.h"
// 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];
// 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;
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;
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();
}
}
- muondata.ResetHits();
+ muondataSim.ResetHits();
} // end track loop
// 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
-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);
}
// 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;
// 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)
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);