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