///
/// AZ : use the AliMUONClusterFinderAZ clusterizer (default)
///
+/// MLEM : another implementation of AZ, where preclustering is external
+/// MLEMV3 : MLEM with preclustering=PRECLUSTERV2
+/// MLEMV3 : MLEM with preclustering=PRECLUSTERV3
+///
/// PRECLUSTER : use only AliMUONPreClusterFinder. Only for debug as
/// the produced clusters do not have a position, hence the tracking will not
/// work
+/// PRECLUSTERV2 : another version of the preclustering
+/// PRECLUSTERV3 : yet another version of the preclustering
///
/// COG : use AliMUONClusterFinderCOG clusterizer. Not really a production
/// option either, as center-of-gravity is generally not a good estimate
///
/// TRIGGERDISABLE : disable the treatment of MUON trigger
///
+/// DIGITSTOREV1 : use the V1 implementation of the digitstore
+/// DIGITSTOREV2R : use the V2R implementation of the digitstore
+///
/// \author Laurent Aphecetche, Subatech
#include "AliMUONReconstructor.h"
#include "AliMUONDigitCalibrator.h"
#include "AliMUONDigitMaker.h"
#include "AliMUONDigitStoreV1.h"
+#include "AliMUONDigitStoreV2R.h"
#include "AliMUONGeometryTransformer.h"
#include "AliMUONPreClusterFinder.h"
+#include "AliMUONPreClusterFinderV2.h"
+#include "AliMUONPreClusterFinderV3.h"
#include "AliMUONTracker.h"
#include "AliMUONVTrackStore.h"
+#include "AliMUONTriggerChamberEff.h"
#include "AliMUONTriggerCircuit.h"
#include "AliMUONTriggerCrateStore.h"
#include "AliMUONTriggerStoreV1.h"
#include "AliMUONVClusterFinder.h"
+#include "AliMpCDB.h"
#include "AliRawReader.h"
-#include "AliMUONStopwatchGroup.h"
-#include "AliMUONStopwatchGroupElement.h"
+#include "AliCodeTimer.h"
#include <Riostream.h>
#include <TClonesArray.h>
#include <TString.h>
#include <TTree.h>
-
+//#include "AliCodeTimer.h"
/// \cond CLASSIMP
ClassImp(AliMUONReconstructor)
/// \endcond
AliReconstructor(),
fCrateManager(0x0),
fDigitMaker(0x0),
-fTransformer(new AliMUONGeometryTransformer(kTRUE)),
+fTransformer(new AliMUONGeometryTransformer()),
fDigitStore(0x0),
fTriggerCircuit(0x0),
fCalibrationData(0x0),
fClusterStore(0x0),
fTriggerStore(0x0),
fTrackStore(0x0),
-fTimers(new AliMUONStopwatchGroup)
+fTrigChamberEff(0x0)
{
/// normal ctor
- fTransformer->ReadGeometryData("volpath.dat", "geometry.root");
+
+ // Load geometry data
+ fTransformer->LoadGeometryData();
+
+ // Load mapping
+ if ( ! AliMpCDB::LoadMpSegmentation() )
+ {
+ AliFatal("Could not access mapping from OCDB !");
+ }
+
+ // Load DDL store
+ if ( ! AliMpCDB::LoadDDLStore() )
+ {
+ AliFatal("Could not access DDL Store from OCDB !");
+ }
+
+
}
//_____________________________________________________________________________
delete fClusterStore;
delete fTriggerStore;
delete fTrackStore;
- AliInfo("Timers:");
- fTimers->Print();
- delete fTimers;
+ delete fTrigChamberEff;
}
//_____________________________________________________________________________
{
CreateCalibrator();
}
- AliMUONStopwatchGroupElement timer(fTimers,"MUON",Form("%s::Calibrate(AliMUONVDigitStore*)",fDigitCalibrator->ClassName()));
+ AliCodeTimerAuto(Form("%s::Calibrate(AliMUONVDigitStore*)",fDigitCalibrator->ClassName()))
fDigitCalibrator->Calibrate(digitStore);
}
CreateClusterReconstructor();
}
- AliMUONStopwatchGroupElement timer(fTimers,"MUON",Form("%s::Digits2Clusters(const AliMUONVDigitStore&,AliMUONVClusterStore&)",
- fClusterReconstructor->ClassName()));
+ AliCodeTimerAuto(Form("%s::Digits2Clusters(const AliMUONVDigitStore&,AliMUONVClusterStore&)",
+ fClusterReconstructor->ClassName()))
fClusterReconstructor->Digits2Clusters(digitStore,clusterStore);
}
{
/// Convert raw data into digit and trigger stores
CreateDigitMaker();
- AliMUONStopwatchGroupElement timer(fTimers,"MUON",Form("%s::Raw2Digits(AliRawReader*,AliMUONVDigitStore*,AliMUONVTriggerStore*)",
- fDigitMaker->ClassName()));
+
+ AliCodeTimerStart(Form("%s::Raw2Digits(AliRawReader*,AliMUONVDigitStore*,AliMUONVTriggerStore*)",
+ fDigitMaker->ClassName()))
fDigitMaker->Raw2Digits(rawReader,digitStore,triggerStore);
+ AliCodeTimerStop(Form("%s::Raw2Digits(AliRawReader*,AliMUONVDigitStore*,AliMUONVTriggerStore*)",
+ fDigitMaker->ClassName()))
Calibrate(*digitStore);
}
/// Create (and create if necessary) the digit maker
if (fDigitMaker) return;
- AliMUONStopwatchGroupElement timer(fTimers,"MUON","AliMUONReconstructor::CreateDigitMaker()");
+ AliCodeTimerAuto("")
fDigitMaker = new AliMUONDigitMaker;
}
/// Return (and create if necessary) the trigger circuit object
if (fTriggerCircuit) return;
- AliMUONStopwatchGroupElement timer(fTimers,"MUON","AliMUONReconstructor::CreateTriggerCircuit()");
+ AliCodeTimerAuto("")
- fTriggerCircuit = new TClonesArray("AliMUONTriggerCircuit", 234);
- for (Int_t i = 0; i < AliMUONConstants::NTriggerCircuit(); i++)
- {
- AliMUONTriggerCircuit c;
- c.SetTransformer(fTransformer);
- c.Init(i,*(CrateManager()));
- TClonesArray& circuit = *fTriggerCircuit;
- new(circuit[circuit.GetEntriesFast()]) AliMUONTriggerCircuit(c);
- }
+ fTriggerCircuit = new AliMUONTriggerCircuit(fTransformer);
+
+}
+
+//_____________________________________________________________________________
+void
+AliMUONReconstructor::CreateTriggerChamberEff() const
+{
+ /// Create (and create if necessary) the trigger chamber efficiency class
+ if (fTrigChamberEff) return;
+
+ AliCodeTimerAuto("")
+
+ fTrigChamberEff = new AliMUONTriggerChamberEff(fTransformer,fDigitMaker,kTRUE);
+ //fTrigChamberEff->SetDebugLevel(1);
}
//_____________________________________________________________________________
CreateTriggerCircuit();
CreateDigitMaker();
+ CreateTriggerChamberEff();
AliLoader* loader = runLoader->GetDetectorLoader("MUON");
if (!loader)
AliError("Cannot get MUONLoader, so cannot create MUONTracker");
return 0x0;
}
- AliMUONTracker* tracker = new AliMUONTracker(loader,fDigitMaker,fTransformer,fTriggerCircuit);
+ AliMUONTracker* tracker = new AliMUONTracker(loader,fDigitMaker,fTransformer,fTriggerCircuit,fTrigChamberEff);
tracker->SetOption(GetOption());
return tracker;
{
/// Create cluster reconstructor, depending on GetOption()
- AliMUONStopwatchGroupElement timer(fTimers,"MUON","AliMUONReconstructor::CreateClusterReconstructor()");
+ AliCodeTimerAuto("")
AliDebug(1,"");
TString opt(GetOption());
opt.ToUpper();
- if ( strstr(opt,"PRECLUSTER") )
+ if ( strstr(opt,"PRECLUSTERV2") )
+ {
+ clusterFinder = new AliMUONPreClusterFinderV2;
+ }
+ else if ( strstr(opt,"PRECLUSTERV3") )
+ {
+ clusterFinder = new AliMUONPreClusterFinderV3;
+ }
+ else if ( strstr(opt,"PRECLUSTER") )
{
clusterFinder = new AliMUONPreClusterFinder;
}
else if ( strstr(opt,"COG") )
{
- clusterFinder = new AliMUONClusterFinderCOG;
+ clusterFinder = new AliMUONClusterFinderCOG(new AliMUONPreClusterFinder);
}
+ else if ( strstr(opt,"SIMPLEFITV3") )
+ {
+ clusterFinder = new AliMUONClusterFinderSimpleFit(new AliMUONClusterFinderCOG(new AliMUONPreClusterFinderV3));
+ }
else if ( strstr(opt,"SIMPLEFIT") )
{
- clusterFinder = new AliMUONClusterFinderSimpleFit;
+ clusterFinder = new AliMUONClusterFinderSimpleFit(new AliMUONClusterFinderCOG(new AliMUONPreClusterFinder));
}
else if ( strstr(opt,"MLEM:DRAW") )
{
- clusterFinder = new AliMUONClusterFinderMLEM(kTRUE);
+ clusterFinder = new AliMUONClusterFinderMLEM(kTRUE,new AliMUONPreClusterFinder);
}
+ else if ( strstr(opt,"MLEMV3") )
+ {
+ clusterFinder = new AliMUONClusterFinderMLEM(kFALSE,new AliMUONPreClusterFinderV3);
+ }
+ else if ( strstr(opt,"MLEMV2") )
+ {
+ clusterFinder = new AliMUONClusterFinderMLEM(kFALSE,new AliMUONPreClusterFinderV2);
+ }
else if ( strstr(opt,"MLEM") )
{
- clusterFinder = new AliMUONClusterFinderMLEM(kFALSE);
+ clusterFinder = new AliMUONClusterFinderMLEM(kFALSE,new AliMUONPreClusterFinder);
}
else if ( strstr(opt,"AZ") )
{
}
else
{
+ // default is currently AZ
clusterFinder = new AliMUONClusterFinderAZ;
}
{
/// Create the calibrator
- AliMUONStopwatchGroupElement timer(fTimers,"MUON","AliMUONReconstructor::CreateCalibrator()");
+ AliCodeTimerAuto("")
Int_t runNumber = AliCDBManager::Instance()->GetRun();
/// Return (and create if necessary) the digit container
if (!fDigitStore)
{
- fDigitStore = new AliMUONDigitStoreV1;
+ TString sopt(GetOption());
+ sopt.ToUpper();
+
+ AliInfo(Form("Options=%s",sopt.Data()));
+
+ if ( sopt.Contains("DIGITSTOREV1") )
+ {
+ fDigitStore = AliMUONVDigitStore::Create("AliMUONDigitStoreV1");
+ }
+ else if ( sopt.Contains("DIGITSTOREV2R") )
+ {
+ fDigitStore = AliMUONVDigitStore::Create("AliMUONDigitStoreV2R");
+ }
+ else if ( sopt.Contains("DIGITSTOREV2S") )
+ {
+ fDigitStore = AliMUONVDigitStore::Create("AliMUONDigitStoreV2S");
+ }
+
+ if (!fDigitStore) fDigitStore = AliMUONVDigitStore::Create("AliMUONDigitStoreV2R");
+
+ AliInfo(Form("Will use %s to store digits during reconstruction",fDigitStore->ClassName()));
}
return fDigitStore;
}
{
/// Write the trigger and cluster information into TreeR
- AliMUONStopwatchGroupElement timer(fTimers,"MUON","AliMUONReconstructor::FillTreeR()");
+ AliCodeTimerAuto("")
AliDebug(1,"");
return;
}
- if ( DigitStore() )
- {
- ConvertDigits(rawReader,DigitStore(),TriggerStore());
- Clusterize(*(DigitStore()),*(ClusterStore()));
- }
+ ConvertDigits(rawReader,DigitStore(),TriggerStore());
+ Clusterize(*(DigitStore()),*(ClusterStore()));
FillTreeR(TriggerStore(),ClusterStore(),*clustersTree);
}
{
/// Reconstruct simulated data
- AliMUONStopwatchGroupElement timer(fTimers,"MUON","AliMUONReconstructor::Reconstruct(AliRunLoader*)");
+ AliCodeTimerAuto("Reconstruct(AliRunLoader*)")
AliLoader* loader = runLoader->GetDetectorLoader("MUON");
if (!loader)
{
/// This method is called by AliReconstruction if HasLocalReconstruction()==kFALSE
- AliMUONStopwatchGroupElement timer(fTimers,"MUON","AliMUONReconstructor::Reconstruct(AliRunLoader*, AliRawReader*)");
+ AliCodeTimerAuto("AliMUONReconstructor::Reconstruct(AliRunLoader*, AliRawReader*)")
AliLoader* loader = runLoader->GetDetectorLoader("MUON");
if (!loader)
/// This method is called by AliReconstruction if HasLocalReconstruction()==kTRUE
/// AND HasDigitConversion()==kTRUE
+// AliCodeTimerAuto("(TTree*,TTree*)")
+
AliDebug(1,"");
if (!digitsTree || !clustersTree)
if ( fDigitStore )
{
+ // Insure we got calibrated digits (if we reconstruct from pure simulated,
+ // i.e. w/o going through raw data, this will be the case)
+ TIter next(fDigitStore->CreateIterator());
+ AliMUONVDigit* digit = static_cast<AliMUONVDigit*>(next());
+ if (!digit->IsCalibrated())
+ {
+ Calibrate(*fDigitStore);
+ }
Clusterize(*fDigitStore,*(ClusterStore()));
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff