X-Git-Url: http://git.uio.no/git/?p=u%2Fmrichter%2FAliRoot.git;a=blobdiff_plain;f=MUON%2FAliMUONReconstructor.cxx;h=beaf1f5fa9f68ba23af4489748e9e93a276dbc69;hp=e35fd3cc4b5806fe22923c46eddd88ef24da3808;hb=95153273156d2401573870c81190c9bff2bdeeec;hpb=8e0ae46cb649b5a03dad5bb23cf0f446b288c740 diff --git a/MUON/AliMUONReconstructor.cxx b/MUON/AliMUONReconstructor.cxx index e35fd3cc4b5..beaf1f5fa9f 100644 --- a/MUON/AliMUONReconstructor.cxx +++ b/MUON/AliMUONReconstructor.cxx @@ -14,390 +14,859 @@ **************************************************************************/ /* $Id$ */ -/////////////////////////////////////////////////////////////////////////////// -// // -// class for MUON reconstruction // -// // -/////////////////////////////////////////////////////////////////////////////// -#include -#include - -#include "AliRunLoader.h" -#include "AliHeader.h" -#include "AliGenEventHeader.h" -#include "AliESD.h" -#include "AliMUONReconstructor.h" - -#include "AliMUONData.h" -#include "AliMUONTrackReconstructor.h" -#include "AliMUONClusterReconstructor.h" -#include "AliMUONClusterFinderVS.h" -#include "AliMUONClusterFinderAZ.h" -#include "AliMUONEventRecoCombi.h" -#include "AliMUONTrack.h" -#include "AliMUONTrackParam.h" -#include "AliMUONTriggerTrack.h" -#include "AliESDMuonTrack.h" -#include "AliMUONRawData.h" +//----------------------------------------------------------------------------- +/// \class AliMUONReconstructor +/// +/// Implementation of AliReconstructor for MUON subsystem. +/// +/// The clustering mode and the associated parameters can be changed through the +/// AliMUONRecoParam object set in the reconstruction macro or read from the CDB +/// (see methods in AliMUONRecoParam.h file for details) +/// +/// Valid modes are : +/// +/// SIMPLEFIT : use the AliMUONClusterFinderSimpleFit clusterizer +/// +/// SIMPLEFITV3 : SIMPLEFIT with preclustering=PRECLUSTERV3 +/// +/// MLEM : use AliMUONClusterFinderMLEM and AliMUONPreClusterFinder for preclustering (default) +/// MLEMV2 : 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 +/// of the cluster position... +/// +/// PEAKCOG : COG cluster finder around local maxima +/// PEAKFIT : fit around local maxima with up to 3 peaks, COG otherwise +/// +/// NOCLUSTERING : bypass completely the clustering stage +/// +/// ------ +/// +/// The behavior of the MUON reconstruction can also 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 +/// +/// DIGITSTOREV1 : use the V1 implementation of the digitstore +/// DIGITSTOREV2R : use the V2R implementation of the digitstore +/// +/// NOLOCALRECONSTRUCTION : for debug, to disable local reconstruction (and hence +/// "recover" old behavior) +/// +/// TRIGGERDISABLE : disable the treatment of MUON trigger +/// +/// ENABLEERRORLOGGING : enable error logging (this activates also warnings in RawStreamTracker) +/// +/// \author Laurent Aphecetche, Subatech +//----------------------------------------------------------------------------- -#include "AliRawReader.h" +#include "AliMUONReconstructor.h" +#include "AliMUONCalibrationData.h" +#include "AliMUONClusterFinderCOG.h" +#include "AliMUONClusterFinderMLEM.h" +#include "AliMUONClusterFinderSimpleFit.h" +#include "AliMUONClusterFinderPeakCOG.h" +#include "AliMUONClusterFinderPeakFit.h" +#include "AliMUONClusterStoreV1.h" +#include "AliMUONClusterStoreV2.h" +#include "AliMUONConstants.h" +#include "AliMUONDigitCalibrator.h" +#include "AliMUONDigitMaker.h" +#include "AliMUONDigitStoreV1.h" +#include "AliMUONDigitStoreV2R.h" +#include "AliMUONGeometryTransformer.h" +#include "AliMUONPadStatusMaker.h" +#include "AliMUONPreClusterFinder.h" +#include "AliMUONPreClusterFinderV2.h" +#include "AliMUONPreClusterFinderV3.h" +#include "AliMUONSimpleClusterServer.h" +#include "AliMUONTracker.h" +#include "AliMUONTriggerCircuit.h" +#include "AliMUONTriggerStoreV1.h" +#include "AliMUONVClusterFinder.h" +#include "AliMUONVClusterServer.h" +#include "AliMUONVTrackStore.h" +#include "AliMUONTriggerElectronics.h" +#include "AliMUONTriggerUtilities.h" + +#include "AliMpArea.h" +#include "AliMpCDB.h" +#include "AliMpConstants.h" +#include "AliMpDDLStore.h" +#include "AliMpSegmentation.h" +#include "AliRawReader.h" +#include "AliCDBManager.h" +#include "AliCodeTimer.h" +#include "AliLog.h" +#include "AliRunInfo.h" + +#include +#include +#include +#include +#include + +/// \cond CLASSIMP ClassImp(AliMUONReconstructor) +/// \endcond + //_____________________________________________________________________________ -AliMUONReconstructor::AliMUONReconstructor() - : AliReconstructor() +AliMUONReconstructor::AliMUONReconstructor() : +AliReconstructor(), +fDigitMaker(0x0), +fTransformer(new AliMUONGeometryTransformer()), +fDigitStore(0x0), +fTriggerCircuit(0x0), +fCalibrationData(0x0), +fDigitCalibrator(0x0), +fTriggerStore(0x0), +fTrackStore(0x0), +fClusterStore(0x0), +fTriggerProcessor(0x0), +fTriggerUtilities(0x0), +fClusterServers(), +fTrackers(), +fShouldCalibrate(kTRUE) { + /// normal ctor + + AliDebug(1,""); + + // Unload mapping objects + // if they have been loaded from the obsolete OCDB mapping objects + + if ( AliMpDDLStore::Instance(false) ) { + AliCDBManager::Instance()->UnloadFromCache("MUON/Calib/DDLStore"); + delete AliMpDDLStore::Instance(); + } + + if ( AliMpSegmentation::Instance(false) ) { + AliCDBManager::Instance()->UnloadFromCache("MUON/Calib/Mapping"); + delete AliMpSegmentation::Instance(); + } + + // Load mapping + if ( ! AliMpCDB::LoadDDLStore() ) { + AliFatal("Could not access mapping from OCDB !"); + } + + // Load geometry data + fTransformer->LoadGeometryData(); + + fClusterServers.SetOwner(kTRUE); + fTrackers.SetOwner(kTRUE); } + //_____________________________________________________________________________ AliMUONReconstructor::~AliMUONReconstructor() { + /// dtor + + AliDebug(1,""); + + delete fDigitCalibrator; + + delete fDigitMaker; + delete fDigitStore; + delete fTransformer; + delete fTriggerCircuit; + delete fTriggerStore; + delete fTrackStore; + delete fClusterStore; + delete fTriggerProcessor; + delete fTriggerUtilities; + + delete AliMpSegmentation::Instance(false); + delete AliMpDDLStore::Instance(false); + + delete fCalibrationData; +} + +//_____________________________________________________________________________ +void +AliMUONReconstructor::Calibrate(AliMUONVDigitStore& digitStore) const +{ + /// Calibrate the digitStore + if (!fDigitCalibrator) + { + CreateCalibrator(); + } + + if ( fShouldCalibrate ) + { + AliCodeTimerAuto(Form("%s::Calibrate(AliMUONVDigitStore*)",fDigitCalibrator->ClassName()),0) + fDigitCalibrator->Calibrate(digitStore); + } } + //_____________________________________________________________________________ -void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader) const +void +AliMUONReconstructor::ConvertDigits(AliRawReader* rawReader, + AliMUONVDigitStore* digitStore, + AliMUONVTriggerStore* triggerStore) const { -// AliLoader - AliLoader* loader = runLoader->GetLoader("MUONLoader"); - Int_t nEvents = runLoader->GetNumberOfEvents(); - -// used local container for each method -// passing fLoader as argument, could be avoided ??? - AliMUONTrackReconstructor* recoEvent = new AliMUONTrackReconstructor(loader); - AliMUONData* dataEvent = recoEvent->GetMUONData(); - if (strstr(GetOption(),"Original")) recoEvent->SetTrackMethod(1); // Original tracking - else if (strstr(GetOption(),"Combi")) recoEvent->SetTrackMethod(3); // Combined cluster / track - else recoEvent->SetTrackMethod(2); // Kalman - - AliMUONClusterReconstructor* recoCluster = new AliMUONClusterReconstructor(loader); - AliMUONData* dataCluster = recoCluster->GetMUONData(); - AliMUONClusterFinderVS *recModel = recoCluster->GetRecoModel(); - if (!strstr(GetOption(),"VS")) { - recModel = (AliMUONClusterFinderVS*) new AliMUONClusterFinderAZ(); - recoCluster->SetRecoModel(recModel); - } - recModel->SetGhostChi2Cut(10); - - loader->LoadDigits("READ"); - loader->LoadRecPoints("RECREATE"); - loader->LoadTracks("RECREATE"); - - Int_t chBeg = recoEvent->GetTrackMethod() == 3 ? 6 : 0; - // Loop over events - for(Int_t ievent = 0; ievent < nEvents; ievent++) { - printf("Event %d\n",ievent); - runLoader->GetEvent(ievent); - - //----------------------- digit2cluster & Trigger2Trigger ------------------- - if (!loader->TreeR()) loader->MakeRecPointsContainer(); - - // tracking branch - if (recoEvent->GetTrackMethod() != 3) { - dataCluster->MakeBranch("RC"); - dataCluster->SetTreeAddress("D,RC"); - } else { - dataCluster->SetTreeAddress("D"); - dataCluster->SetTreeAddress("RCC"); + /// Convert raw data into digit and trigger stores + CreateDigitMaker(); + + // Skip reconstruction if event is Calibration + if ( GetRecoParam()->GetEventSpecie() == AliRecoParam::kCalib ) { + digitStore->Clear(); // Remove possible digits from previous event + triggerStore->Clear(); // Remove possible triggers from previous event + AliInfo("Calibration event: do not convert digits"); + return; + } + + 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); +} + +//_____________________________________________________________________________ +void +AliMUONReconstructor::ConvertDigits(AliRawReader* rawReader, TTree* digitsTree) const +{ + /// convert raw data into a digit tree + AliCodeTimerAuto("",0) + + Bool_t alone = ( TriggerStore() == 0 ); + + Bool_t ok = DigitStore()->Connect(*digitsTree,alone); + if ( TriggerStore() ) + { + ok = ok && TriggerStore()->Connect(*digitsTree,kFALSE); + } + + if (!ok) + { + AliError("Could not make branches on TreeD"); + } + else + { + ConvertDigits(rawReader,DigitStore(),TriggerStore()); + AliCodeTimerStart("Fill digits") + digitsTree->Fill(); + AliCodeTimerStop("Fill digits") + DigitStore()->Clear(); + } +} + +//_____________________________________________________________________________ +void +AliMUONReconstructor::CreateDigitMaker() const +{ + /// Create (and create if necessary) the digit maker + if (fDigitMaker) return; + + AliCodeTimerAuto("",0) + + TString option = GetOption(); + + Bool_t enableErrorLogging = kFALSE; + + if (option.Contains("ENABLEERRORLOGGING")) + { + enableErrorLogging = kTRUE; + } + + fDigitMaker = new AliMUONDigitMaker(enableErrorLogging); + option.ToUpper(); + + // Always make trigger digits + // (needed when calculating trigger chamber efficiency) + fDigitMaker->SetMakeTriggerDigits(kTRUE); + + if ( GetRecoParam()->TryRecover() ) + { + fDigitMaker->SetTryRecover(kTRUE); + } + else + { + fDigitMaker->SetTryRecover(kFALSE); + } +} + +//_____________________________________________________________________________ +void +AliMUONReconstructor::CreateTriggerCircuit() const +{ + /// Return (and create if necessary) the trigger circuit object + if (fTriggerCircuit) return; + + AliCodeTimerAuto("",0) + + fTriggerCircuit = new AliMUONTriggerCircuit(fTransformer); + +} + +//_____________________________________________________________________________ +void +AliMUONReconstructor::CreateTriggerUtilities() const +{ + /// Return (and create if necessary) the trigger utilities object + if ( fTriggerUtilities ) return; + + AliCodeTimerAuto("",0) + + if ( ! fCalibrationData ) CreateCalibrationData(); + + fTriggerUtilities = new AliMUONTriggerUtilities(fCalibrationData); +} + +//_____________________________________________________________________________ +AliTracker* +AliMUONReconstructor::CreateTracker() const +{ + /// Create the MUONTracker object + + CreateTriggerCircuit(); + CreateTriggerUtilities(); + + const AliMUONRecoParam* rp = GetRecoParam(); + + Int_t es = rp->GetEventSpecie(); + + AliTracker* tracker = static_cast(fTrackers.At(es)); + + if (!tracker ) + { + if ( ! rp->CombineClusterTrackReco() ) + { + tracker = new AliMUONTracker(rp, + 0x0, + *DigitStore(), + fTransformer, + fTriggerCircuit, + fTriggerUtilities); + + AliInfo(Form("Created tracker %p for recoparam of type %s es=%d", + tracker, + AliRecoParam::GetEventSpecieName(AliRecoParam::Convert(rp->GetEventSpecie())),es)); } - // 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 - dataCluster->SetTreeAddress("GLT"); - - recoCluster->Digits2Clusters(chBeg); - if (recoEvent->GetTrackMethod() == 3) { - // Combined cluster / track finder - AliMUONEventRecoCombi::Instance()->FillEvent(dataCluster, dataEvent, (AliMUONClusterFinderAZ*)recModel); - ((AliMUONClusterFinderAZ*) recModel)->SetReco(2); + else + { + + tracker = new AliMUONTracker(rp, + CreateClusterServer(*rp), + *DigitStore(), + fTransformer, + fTriggerCircuit, + fTriggerUtilities); + + AliInfo(Form("Created (combined) tracker %p for recoparam of type %s es=%d", + tracker, + AliRecoParam::GetEventSpecieName(AliRecoParam::Convert(rp->GetEventSpecie())),es)); } - else dataCluster->Fill("RC"); - - // trigger branch - dataCluster->MakeBranch("TC"); - dataCluster->SetTreeAddress("TC"); - recoCluster->Trigger2Trigger(); - dataCluster->Fill("TC"); - - //AZ loader->WriteRecPoints("OVERWRITE"); - - //---------------------------- Track & TriggerTrack --------------------- - if (!loader->TreeT()) loader->MakeTracksContainer(); - - // trigger branch - dataEvent->MakeBranch("RL"); //trigger track - dataEvent->SetTreeAddress("RL"); - recoEvent->EventReconstructTrigger(); - dataEvent->Fill("RL"); - - // tracking branch - dataEvent->MakeBranch("RT"); //track - dataEvent->SetTreeAddress("RT"); - recoEvent->EventReconstruct(); - dataEvent->Fill("RT"); - - loader->WriteTracks("OVERWRITE"); - - if (recoEvent->GetTrackMethod() == 3) { - // Combined cluster / track - ((AliMUONClusterFinderAZ*) recModel)->SetReco(1); - dataCluster->MakeBranch("RC"); - dataCluster->SetTreeAddress("RC"); - AliMUONEventRecoCombi::Instance()->FillRecP(dataCluster, recoEvent); - dataCluster->Fill("RC"); + + fTrackers.AddAtAndExpand(tracker,es); + } + + + return tracker; +} + +//_____________________________________________________________________________ +AliMUONVClusterFinder* +AliMUONReconstructor::CreateClusterFinder(const char* clusterFinderType) +{ + /// Create a given cluster finder instance + + AliCodeTimerAutoGeneral("",0) + + AliMUONVClusterFinder* clusterFinder(0x0); + + TString opt(clusterFinderType); + opt.ToUpper(); + + 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,"PEAKCOG") ) + { + clusterFinder = new AliMUONClusterFinderPeakCOG(kFALSE,new AliMUONPreClusterFinder); + } + else if ( strstr(opt,"PEAKFIT") ) + { + clusterFinder = new AliMUONClusterFinderPeakFit(kFALSE,new AliMUONPreClusterFinder); + } + else if ( strstr(opt,"COG") ) + { + 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(new AliMUONClusterFinderCOG(new AliMUONPreClusterFinder)); + } + else if ( strstr(opt,"MLEM:DRAW") ) + { + 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,new AliMUONPreClusterFinder); + } + else + { + AliErrorClass(Form("clustering mode \"%s\" does not exist",opt.Data())); + return 0x0; + } + + return clusterFinder; +} + +//_____________________________________________________________________________ +AliMUONVClusterServer* +AliMUONReconstructor::CreateClusterServer(const AliMUONRecoParam& rp) const +{ + /// Create cluster server + + AliCodeTimerAuto("",0); + + AliMUONVClusterServer* clusterServer = static_cast(fClusterServers.At(rp.GetEventSpecie())); + + if (!clusterServer ) + { + AliMUONVClusterFinder* clusterFinder = CreateClusterFinder(rp.GetClusteringMode()); + + if ( !clusterFinder ) return 0x0; + + clusterServer = new AliMUONSimpleClusterServer(clusterFinder,*fTransformer); + + AliInfo(Form("Created AliMUONSimpleClusterServer (%p) for specie %d with clustering = %s (following requesting clustering mode %s)", + clusterServer,rp.GetEventSpecie(),clusterFinder->ClassName(),rp.GetClusteringMode())); + + fClusterServers.AddAtAndExpand(clusterServer,rp.GetEventSpecie()); + } + + return clusterServer; +} + +//_____________________________________________________________________________ +void +AliMUONReconstructor::CreateCalibrationData() const +{ + /// Create the calibrator + + AliCodeTimerAuto("",0); + + Int_t runNumber = AliCDBManager::Instance()->GetRun(); + + fCalibrationData = new AliMUONCalibrationData(runNumber); + if ( !fCalibrationData->IsValid() ) + { + AliError("Could not retrieve calibrations !"); + delete fCalibrationData; + fCalibrationData = 0x0; + return; + } + + // It is now time to check whether we have everything to proceed. + // What we need depends on whether both tracker and trigger + // are in the readout chain, and what specific "bad channel policy" + // we use + + Bool_t kTracker(kFALSE); + Bool_t kTrigger(kFALSE); + + const AliRunInfo* runInfo = GetRunInfo(); + if (!runInfo) + { + AliError("Could not get runinfo ?"); + } + else + { + TString detectors(runInfo->GetActiveDetectors()); + if (detectors.Contains("MUONTRK")) kTracker=kTRUE; + if (detectors.Contains("MUONTRG")) kTrigger=kTRUE; + } + + AliInfo(Form("Run with MUON TRIGGER : %s and MUON TRACKER : %s", + kTrigger ? "YES":"NO" , + kTracker ? "YES":"NO")); + + if ( kTracker ) + { + // Check that we get all the calibrations we'll need + if ( !fCalibrationData->Pedestals() || + !fCalibrationData->Gains() ) + { + AliFatal(Form("Could not access all required calibration data (PED %p GAIN %p)", + fCalibrationData->Pedestals(),fCalibrationData->Gains())); } - loader->WriteRecPoints("OVERWRITE"); + + if ( !fCalibrationData->HV() ) + { + // Special treatment of HV. We only break if the values + // are not there *AND* we cut on them. + UInt_t mask = GetRecoParam()->PadGoodnessMask(); + TString smask(AliMUONPadStatusMaker::AsCondition(mask)); + if ( smask.Contains("HV") ) + { + AliFatal("Could not access all required calibration data (HV)"); + } + } + } +} - //--------------------------- Resetting branches ----------------------- - dataCluster->ResetDigits(); - dataCluster->ResetRawClusters(); - dataCluster->ResetTrigger(); +//_____________________________________________________________________________ +void +AliMUONReconstructor::CreateCalibrator() const +{ + /// Create the calibrator + + AliCodeTimerAuto("",0); - dataEvent->ResetRawClusters(); - dataEvent->ResetTrigger(); - dataEvent->ResetRecTracks(); - dataEvent->ResetRecTriggerTracks(); + if ( ! fCalibrationData ) + CreateCalibrationData(); + + AliInfo("Calibration will occur."); + + TString opt(GetOption()); + opt.ToUpper(); + + if ( strstr(opt,"NOSTATUSMAP") ) + { + AliWarning("NOSTATUSMAP is obsolete"); + } + Bool_t kTracker(kFALSE); + + const AliRunInfo* runInfo = GetRunInfo(); + if (!runInfo) + { + AliError("Could not get runinfo ?"); + } + else + { + TString detectors(runInfo->GetActiveDetectors()); + if (detectors.Contains("MUONTRK")) kTracker=kTRUE; + } + + if ( kTracker ) + { + fDigitCalibrator = new AliMUONDigitCalibrator(*fCalibrationData,GetRecoParam()); } - loader->UnloadDigits(); - loader->UnloadRecPoints(); - loader->UnloadTracks(); + else + { + AliWarning("Apparently running without MCH so will not instantiante the DigitCalibrator nor read MCH OCDB objects..."); + fShouldCalibrate=kFALSE; + } +} + +//_____________________________________________________________________________ +void +AliMUONReconstructor::ResponseRemovingChambers(AliMUONVTriggerStore* triggerStore) const +{ + /// Update trigger information with informatins obtained after + /// re-calculation of trigger response + AliCodeTimerAuto("",0); + + if ( ! fCalibrationData ) + CreateCalibrationData(); + + if ( ! fTriggerProcessor ) + fTriggerProcessor = new AliMUONTriggerElectronics(fCalibrationData); - delete recoCluster; - delete recoEvent; + fTriggerProcessor->ResponseRemovingChambers(*triggerStore); } //_____________________________________________________________________________ -void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader, AliRawReader* rawReader) const +AliMUONVDigitStore* +AliMUONReconstructor::DigitStore() const { -// AliLoader - AliLoader* loader = runLoader->GetLoader("MUONLoader"); - -// used local container for each method -// passing fLoader as argument, could be avoided ??? - AliMUONTrackReconstructor* recoEvent = new AliMUONTrackReconstructor(loader); - AliMUONData* dataEvent = recoEvent->GetMUONData(); - - AliMUONRawData* rawData = new AliMUONRawData(loader); - AliMUONData* dataCluster = rawData->GetMUONData(); - - AliMUONClusterReconstructor* recoCluster = new AliMUONClusterReconstructor(loader, dataCluster); - AliMUONClusterFinderVS *recModel = recoCluster->GetRecoModel(); - recModel->SetGhostChi2Cut(10); - - loader->LoadRecPoints("RECREATE"); - loader->LoadTracks("RECREATE"); - loader->LoadDigits("RECREATE"); - - - // Loop over events - Int_t iEvent = 0; - - while (rawReader->NextEvent()) { - printf("Event %d\n",iEvent); - runLoader->GetEvent(iEvent++); - - //----------------------- raw2digits & raw2trigger------------------- - if (!loader->TreeD()) loader->MakeDigitsContainer(); - - // tracking branch - dataCluster->MakeBranch("D"); - dataCluster->SetTreeAddress("D"); - rawData->ReadTrackerDDL(rawReader); - dataCluster->Fill("D"); - - // trigger branch - dataCluster->MakeBranch("GLT"); - dataCluster->SetTreeAddress("GLT"); - rawData->ReadTriggerDDL(rawReader); - dataCluster->Fill("GLT"); - - loader->WriteDigits("OVERWRITE"); - - //----------------------- digit2cluster & Trigger2Trigger ------------------- - if (!loader->TreeR()) loader->MakeRecPointsContainer(); - - // tracking branch - dataCluster->MakeBranch("RC"); - dataCluster->SetTreeAddress("RC"); - recoCluster->Digits2Clusters(); - dataCluster->Fill("RC"); - - // trigger branch - dataCluster->MakeBranch("TC"); - dataCluster->SetTreeAddress("TC"); - recoCluster->Trigger2Trigger(); - dataCluster->Fill("TC"); - - loader->WriteRecPoints("OVERWRITE"); - - //---------------------------- Track & TriggerTrack --------------------- - if (!loader->TreeT()) loader->MakeTracksContainer(); - - // trigger branch - dataEvent->MakeBranch("RL"); //trigger track - dataEvent->SetTreeAddress("RL"); - recoEvent->EventReconstructTrigger(); - dataEvent->Fill("RL"); - - // tracking branch - dataEvent->MakeBranch("RT"); //track - dataEvent->SetTreeAddress("RT"); - recoEvent->EventReconstruct(); - dataEvent->Fill("RT"); - - loader->WriteTracks("OVERWRITE"); - - //--------------------------- Resetting branches ----------------------- - dataCluster->ResetDigits(); - dataCluster->ResetRawClusters(); - dataCluster->ResetTrigger(); - - dataEvent->ResetRawClusters(); - dataEvent->ResetTrigger(); - dataEvent->ResetRecTracks(); - dataEvent->ResetRecTriggerTracks(); - - } - loader->UnloadRecPoints(); - loader->UnloadTracks(); - loader->UnloadDigits(); - - delete recoCluster; - delete recoEvent; + /// Return (and create if necessary) the digit container + if (!fDigitStore) + { + 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; } //_____________________________________________________________________________ -void AliMUONReconstructor::FillESD(AliRunLoader* runLoader, AliESD* esd) const +void +AliMUONReconstructor::FillTreeR(AliMUONVTriggerStore* triggerStore, + TTree& clustersTree) const { - TClonesArray* recTracksArray = 0; - TClonesArray* recTrigTracksArray = 0; - - AliLoader* loader = runLoader->GetLoader("MUONLoader"); - loader->LoadTracks("READ"); - AliMUONData* muonData = new AliMUONData(loader,"MUON","MUON"); - - // declaration - Int_t iEvent;// nPart; - Int_t nTrackHits;// nPrimary; - Double_t fitFmin; - TArrayF vertex(3); - - Double_t bendingSlope, nonBendingSlope, inverseBendingMomentum; - Double_t xRec, yRec, zRec, chi2MatchTrigger; - Bool_t matchTrigger; - - // setting pointer for tracks, triggertracks & trackparam at vertex - AliMUONTrack* recTrack = 0; - AliMUONTrackParam* trackParam = 0; - AliMUONTriggerTrack* recTriggerTrack = 0; -// TParticle* particle = new TParticle(); -// AliGenEventHeader* header = 0; - iEvent = runLoader->GetEventNumber(); - runLoader->GetEvent(iEvent); - - // vertex calculation (maybe it exists already somewhere else) - vertex[0] = vertex[1] = vertex[2] = 0.; - // nPrimary = 0; -// if ( (header = runLoader->GetHeader()->GenEventHeader()) ) { -// header->PrimaryVertex(vertex); -// } else { -// runLoader->LoadKinematics("READ"); -// runLoader->TreeK()->GetBranch("Particles")->SetAddress(&particle); -// nPart = (Int_t)runLoader->TreeK()->GetEntries(); -// for(Int_t iPart = 0; iPart < nPart; iPart++) { -// runLoader->TreeK()->GetEvent(iPart); -// if (particle->GetFirstMother() == -1) { -// vertex[0] += particle->Vx(); -// vertex[1] += particle->Vy(); -// vertex[2] += particle->Vz(); -// nPrimary++; -// } -// if (nPrimary) { -// vertex[0] /= (double)nPrimary; -// vertex[1] /= (double)nPrimary; -// vertex[2] /= (double)nPrimary; -// } -// } -// } - // setting ESD MUON class - AliESDMuonTrack* theESDTrack = new AliESDMuonTrack() ; - - //-------------------- trigger tracks------------- - Long_t trigPat = 0; - muonData->SetTreeAddress("RL"); - muonData->GetRecTriggerTracks(); - recTrigTracksArray = muonData->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------------- - muonData->SetTreeAddress("RT"); - muonData->GetRecTracks(); - recTracksArray = muonData->RecTracks(); + /// Write the trigger and cluster information into TreeR + + AliCodeTimerAuto("",0) + + Bool_t ok(kFALSE); + Bool_t alone(kTRUE); // is trigger the only info in TreeR ? + + const AliMUONRecoParam* rp = GetRecoParam(); + + if ( ! rp->CombineClusterTrackReco() ) + { + alone = kFALSE; // we'll get both tracker and trigger information in TreeR + } + + if ( triggerStore ) + { + ResponseRemovingChambers(triggerStore); + ok = triggerStore->Connect(clustersTree,alone); + if (!ok) + { + AliError("Could not create triggerStore branches in TreeR"); + } + } + + if ( !alone ) + { + if (!fClusterStore) + { + fClusterStore = new AliMUONClusterStoreV2; + } + + AliMUONVClusterServer* clusterServer = CreateClusterServer(*rp); + + TIter next(DigitStore()->CreateIterator()); + clusterServer->UseDigits(next,DigitStore()); + + AliMpArea area; + + AliDebug(1,Form("Doing full clusterization in local reconstruction using %s ",clusterServer->ClassName())); + + for ( Int_t i = 0; i < AliMpConstants::NofTrackingChambers(); ++i ) + { + if (rp->UseChamber(i)) + { + if ( ( i == 6 || i == 7 ) && rp->BypassSt4() ) continue; + if ( ( i == 8 || i == 9 ) && rp->BypassSt5() ) continue; - 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); - - trackParam = (AliMUONTrackParam*) (recTrack->GetTrackParamAtHit())->First(); - trackParam->ExtrapToVertex(vertex[0],vertex[1],vertex[2]); - - bendingSlope = trackParam->GetBendingSlope(); - nonBendingSlope = trackParam->GetNonBendingSlope(); - inverseBendingMomentum = trackParam->GetInverseBendingMomentum(); - xRec = trackParam->GetNonBendingCoor(); - yRec = trackParam->GetBendingCoor(); - zRec = trackParam->GetZ(); - - nTrackHits = recTrack->GetNTrackHits(); - fitFmin = recTrack->GetFitFMin(); - matchTrigger = recTrack->GetMatchTrigger(); - chi2MatchTrigger = recTrack->GetChi2MatchTrigger(); - - // setting data member of ESD MUON - theESDTrack->SetInverseBendingMomentum(inverseBendingMomentum); - theESDTrack->SetThetaX(TMath::ATan(nonBendingSlope)); - theESDTrack->SetThetaY(TMath::ATan(bendingSlope)); - theESDTrack->SetZ(zRec); - theESDTrack->SetBendingCoor(yRec); // calculate vertex at ESD or Tracking level ? - theESDTrack->SetNonBendingCoor(xRec); - theESDTrack->SetChi2(fitFmin); - theESDTrack->SetNHit(nTrackHits); - theESDTrack->SetMatchTrigger(matchTrigger); - theESDTrack->SetChi2MatchTrigger(chi2MatchTrigger); - - // storing ESD MUON Track into ESD Event - if (nRecTracks != 0) - esd->AddMuonTrack(theESDTrack); - } // end loop tracks - - // add global trigger pattern - if (nRecTracks != 0) - esd->SetTrigger(trigPat); - - // reset muondata - muonData->ResetRecTracks(); - muonData->ResetRecTriggerTracks(); - - //} // end loop on event - loader->UnloadTracks(); - // if (!header) -// runLoader->UnloadKinematics(); - delete theESDTrack; - delete muonData; - // delete particle; -}//_____________________________________________________________________________ -void AliMUONReconstructor::FillESD(AliRunLoader* runLoader, AliRawReader* /*rawReader*/, AliESD* esd) const + clusterServer->Clusterize(i,*fClusterStore,area,rp); + } + } + + Bool_t cok = fClusterStore->Connect(clustersTree,alone); + + if (!cok) AliError("Could not connect clusterStore to clusterTree"); + + AliDebug(1,Form("Number of clusters found = %d",fClusterStore->GetSize())); + + StdoutToAliDebug(1,fClusterStore->Print()); + } + + if (ok) // at least one type of branches created successfully + { + clustersTree.Fill(); + } + + if (fClusterStore) fClusterStore->Clear(); +} + +//_____________________________________________________________________________ +const AliMUONRecoParam* AliMUONReconstructor::GetRecoParam() +{ + /// Get the recoparam from reconstruction + return dynamic_cast(AliReconstructor::GetRecoParam(AliReconstruction::GetDetIndex("MUON"))); +} + + +//_____________________________________________________________________________ +Bool_t +AliMUONReconstructor::HasDigitConversion() const +{ + /// 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; + } +} + +//_____________________________________________________________________________ +void +AliMUONReconstructor::Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const +{ + /// This method is called by AliReconstruction if HasLocalReconstruction()==kTRUE AND + /// HasDigitConversion()==kFALSE + + if ( !clustersTree ) + { + AliError("clustersTree is 0x0 !"); + return; + } + + ConvertDigits(rawReader,DigitStore(),TriggerStore()); + + FillTreeR(TriggerStore(),*clustersTree); +} + +//_____________________________________________________________________________ +void +AliMUONReconstructor::Reconstruct(TTree* digitsTree, TTree* clustersTree) const +{ + /// This method is called by AliReconstruction if HasLocalReconstruction()==kTRUE + /// AND HasDigitConversion()==kTRUE + + AliCodeTimerAuto("",0) + + AliDebug(1,""); + + if (!digitsTree || !clustersTree) + { + AliError(Form("Tree is null : digitsTree=%p clustersTree=%p", + digitsTree,clustersTree)); + return; + } + + 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 ) + { + // 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(next()); + if (digit && !digit->IsCalibrated()) + { + Calibrate(*fDigitStore); + } + } + + FillTreeR(fTriggerStore,*clustersTree); +} + +//_____________________________________________________________________________ +AliMUONVTriggerStore* +AliMUONReconstructor::TriggerStore() const { - // don't need rawReader ??? - FillESD(runLoader, esd); + /// 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; }