X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=STEER%2FAliReconstruction.cxx;h=d1862eb32e4c7bdcdf0ff815e24c323d5ff38ad1;hb=59224b2be92076d0e97d388f1d16fd87dab5c7d0;hp=33610e4c7fbcab5f43dfce4e38c927104b700240;hpb=79740dfc53f9369932880bcaaa2dd395f2ee0dec;p=u%2Fmrichter%2FAliRoot.git diff --git a/STEER/AliReconstruction.cxx b/STEER/AliReconstruction.cxx index 33610e4c7fb..d1862eb32e4 100644 --- a/STEER/AliReconstruction.cxx +++ b/STEER/AliReconstruction.cxx @@ -105,16 +105,6 @@ // data by calling (usual detector string) // // SetUseHLTData("..."); // // // -// For debug purposes the method SetCheckPointLevel can be used. If the // -// argument is greater than 0, files with ESD events will be written after // -// selected steps of the reconstruction for each event: // -// level 1: after tracking and after filling of ESD (final) // -// level 2: in addition after each tracking step // -// level 3: in addition after the filling of ESD for each detector // -// If a final check point file exists for an event, this event will be // -// skipped in the reconstruction. The tracking and the filling of ESD for // -// a detector will be skipped as well, if the corresponding check point // -// file exists. The ESD event will then be loaded from the file instead. // // // /////////////////////////////////////////////////////////////////////////////// @@ -129,6 +119,11 @@ #include #include #include +#include +#include +#include +#include +#include #include "AliReconstruction.h" #include "AliCodeTimer.h" @@ -140,6 +135,7 @@ #include "AliRawReaderDate.h" #include "AliRawReaderRoot.h" #include "AliRawEventHeaderBase.h" +#include "AliRawEvent.h" #include "AliESDEvent.h" #include "AliESDMuonTrack.h" #include "AliESDfriend.h" @@ -163,7 +159,6 @@ #include "AliESDPmdTrack.h" #include "AliESDTagCreator.h" -#include "AliAODTagCreator.h" #include "AliGeomManager.h" #include "AliTrackPointArray.h" @@ -175,6 +170,7 @@ #include "AliCentralTrigger.h" #include "AliTriggerConfiguration.h" #include "AliTriggerClass.h" +#include "AliTriggerCluster.h" #include "AliCTPRawStream.h" #include "AliQADataMakerRec.h" @@ -187,19 +183,24 @@ #include "AliSysInfo.h" // memory snapshots #include "AliRawHLTManager.h" +#include "AliMagWrapCheb.h" -ClassImp(AliReconstruction) +#include "AliDetectorRecoParam.h" +#include "AliRunInfo.h" +#include "AliEventInfo.h" + +#include "AliDAQ.h" +ClassImp(AliReconstruction) //_____________________________________________________________________________ const char* AliReconstruction::fgkDetectorName[AliReconstruction::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"}; //_____________________________________________________________________________ -AliReconstruction::AliReconstruction(const char* gAliceFilename, - const char* name, const char* title) : - TNamed(name, title), - - fUniformField(kTRUE), +AliReconstruction::AliReconstruction(const char* gAliceFilename) : + TSelector(), + fUniformField(kFALSE), + fForcedFieldMap(NULL), fRunVertexFinder(kTRUE), fRunVertexFinderTracks(kTRUE), fRunHLTTracking(kFALSE), @@ -209,7 +210,6 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename, fStopOnError(kFALSE), fWriteAlignmentData(kFALSE), fWriteESDfriend(kFALSE), - fWriteAOD(kFALSE), fFillTriggerESD(kTRUE), fCleanESD(kTRUE), @@ -221,37 +221,43 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename, fRunLocalReconstruction("ALL"), fRunTracking("ALL"), fFillESD("ALL"), + fLoadCDB(""), fUseTrackingErrorsForAlignment(""), fGAliceFileName(gAliceFilename), - fInput(""), - fpEvent(NULL), + fRawInput(""), fEquipIdMap(""), fFirstEvent(0), fLastEvent(-1), fNumberOfEventsPerFile(1), - fCheckPointLevel(0), fOptions(), fLoadAlignFromCDB(kTRUE), fLoadAlignData("ALL"), fESDPar(""), fUseHLTData(), + fRunInfo(NULL), + fEventInfo(), fRunLoader(NULL), fRawReader(NULL), fParentRawReader(NULL), + fRecoParam(), + fVertexer(NULL), fDiamondProfile(NULL), fDiamondProfileTPC(NULL), fMeanVertexConstraint(kTRUE), - fGRPList(NULL), + fGRPData(NULL), fAlignObjArray(NULL), fCDBUri(), fSpecCDBUri(), fInitCDBCalled(kFALSE), fSetRunNumberFromDataCalled(kFALSE), + fQADetectors("ALL"), + fQASteer(NULL), + fQATasks("ALL"), fRunQA(kTRUE), fRunGlobalQA(kTRUE), fInLoopQA(kFALSE), @@ -265,30 +271,29 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename, ffile(NULL), ftree(NULL), fhlttree(NULL), - ffileOld(NULL), - ftreeOld(NULL), - fhlttreeOld(NULL), ftVertexer(NULL), - fIsNewRunLoader(kFALSE) + fIsNewRunLoader(kFALSE), + fRunAliEVE(kFALSE), + fChain(NULL) { // create reconstruction object with default parameters + gGeoManager = NULL; for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { fReconstructor[iDet] = NULL; fLoader[iDet] = NULL; fTracker[iDet] = NULL; - fQADataMaker[iDet] = NULL; - fQACycles[iDet] = 999999; + fQACycles[iDet] = 999999; } - fQADataMaker[fgkNDetectors]=NULL; //Global QA + fQATasks = Form("%d %d %d", AliQA::kRAWS, AliQA::kRECPOINTS, AliQA::kESDS) ; AliPID pid; } //_____________________________________________________________________________ AliReconstruction::AliReconstruction(const AliReconstruction& rec) : - TNamed(rec), - + TSelector(), fUniformField(rec.fUniformField), + fForcedFieldMap(NULL), fRunVertexFinder(rec.fRunVertexFinder), fRunVertexFinderTracks(rec.fRunVertexFinderTracks), fRunHLTTracking(rec.fRunHLTTracking), @@ -298,7 +303,6 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) : fStopOnError(rec.fStopOnError), fWriteAlignmentData(rec.fWriteAlignmentData), fWriteESDfriend(rec.fWriteESDfriend), - fWriteAOD(rec.fWriteAOD), fFillTriggerESD(rec.fFillTriggerESD), fCleanESD(rec.fCleanESD), @@ -310,37 +314,43 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) : fRunLocalReconstruction(rec.fRunLocalReconstruction), fRunTracking(rec.fRunTracking), fFillESD(rec.fFillESD), + fLoadCDB(rec.fLoadCDB), fUseTrackingErrorsForAlignment(rec.fUseTrackingErrorsForAlignment), fGAliceFileName(rec.fGAliceFileName), - fInput(rec.fInput), - fpEvent(rec.fpEvent), + fRawInput(rec.fRawInput), fEquipIdMap(rec.fEquipIdMap), fFirstEvent(rec.fFirstEvent), fLastEvent(rec.fLastEvent), fNumberOfEventsPerFile(rec.fNumberOfEventsPerFile), - fCheckPointLevel(0), fOptions(), fLoadAlignFromCDB(rec.fLoadAlignFromCDB), fLoadAlignData(rec.fLoadAlignData), fESDPar(rec.fESDPar), fUseHLTData(rec.fUseHLTData), + fRunInfo(NULL), + fEventInfo(), fRunLoader(NULL), fRawReader(NULL), fParentRawReader(NULL), + fRecoParam(rec.fRecoParam), + fVertexer(NULL), - fDiamondProfile(NULL), - fDiamondProfileTPC(NULL), + fDiamondProfile(rec.fDiamondProfile), + fDiamondProfileTPC(rec.fDiamondProfileTPC), fMeanVertexConstraint(rec.fMeanVertexConstraint), - fGRPList(NULL), + fGRPData(NULL), fAlignObjArray(rec.fAlignObjArray), fCDBUri(rec.fCDBUri), fSpecCDBUri(), fInitCDBCalled(rec.fInitCDBCalled), fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled), + fQADetectors(rec.fQADetectors), + fQASteer(NULL), + fQATasks(rec.fQATasks), fRunQA(rec.fRunQA), fRunGlobalQA(rec.fRunGlobalQA), fInLoopQA(rec.fInLoopQA), @@ -353,11 +363,10 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) : ffile(NULL), ftree(NULL), fhlttree(NULL), - ffileOld(NULL), - ftreeOld(NULL), - fhlttreeOld(NULL), ftVertexer(NULL), - fIsNewRunLoader(rec.fIsNewRunLoader) + fIsNewRunLoader(rec.fIsNewRunLoader), + fRunAliEVE(kFALSE), + fChain(NULL) { // copy constructor @@ -368,22 +377,120 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) : fReconstructor[iDet] = NULL; fLoader[iDet] = NULL; fTracker[iDet] = NULL; - fQADataMaker[iDet] = NULL; - fQACycles[iDet] = rec.fQACycles[iDet]; + fQACycles[iDet] = rec.fQACycles[iDet]; } - fQADataMaker[fgkNDetectors]=NULL; //Global QA for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) { if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone()); } + } //_____________________________________________________________________________ AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec) { // assignment operator +// Used in PROOF mode +// Be very careful while modifing it! +// Simple rules to follow: +// for persistent data members - use their assignment operators +// for non-persistent ones - do nothing or take the default values from constructor +// TSelector members should not be touched + if(&rec == this) return *this; + + fUniformField = rec.fUniformField; + fForcedFieldMap = NULL; + fRunVertexFinder = rec.fRunVertexFinder; + fRunVertexFinderTracks = rec.fRunVertexFinderTracks; + fRunHLTTracking = rec.fRunHLTTracking; + fRunMuonTracking = rec.fRunMuonTracking; + fRunV0Finder = rec.fRunV0Finder; + fRunCascadeFinder = rec.fRunCascadeFinder; + fStopOnError = rec.fStopOnError; + fWriteAlignmentData = rec.fWriteAlignmentData; + fWriteESDfriend = rec.fWriteESDfriend; + fFillTriggerESD = rec.fFillTriggerESD; + + fCleanESD = rec.fCleanESD; + fV0DCAmax = rec.fV0DCAmax; + fV0CsPmin = rec.fV0CsPmin; + fDmax = rec.fDmax; + fZmax = rec.fZmax; + + fRunLocalReconstruction = rec.fRunLocalReconstruction; + fRunTracking = rec.fRunTracking; + fFillESD = rec.fFillESD; + fLoadCDB = rec.fLoadCDB; + fUseTrackingErrorsForAlignment = rec.fUseTrackingErrorsForAlignment; + fGAliceFileName = rec.fGAliceFileName; + fRawInput = rec.fRawInput; + fEquipIdMap = rec.fEquipIdMap; + fFirstEvent = rec.fFirstEvent; + fLastEvent = rec.fLastEvent; + fNumberOfEventsPerFile = rec.fNumberOfEventsPerFile; + + for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) { + if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone()); + } + + fLoadAlignFromCDB = rec.fLoadAlignFromCDB; + fLoadAlignData = rec.fLoadAlignData; + fESDPar = rec.fESDPar; + fUseHLTData = rec.fUseHLTData; + + delete fRunInfo; fRunInfo = NULL; + if (rec.fRunInfo) fRunInfo = new AliRunInfo(*rec.fRunInfo); + + fEventInfo = rec.fEventInfo; + + fRunLoader = NULL; + fRawReader = NULL; + fParentRawReader = NULL; + + fRecoParam = rec.fRecoParam; + + for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { + delete fReconstructor[iDet]; fReconstructor[iDet] = NULL; + delete fLoader[iDet]; fLoader[iDet] = NULL; + delete fTracker[iDet]; fTracker[iDet] = NULL; + fQACycles[iDet] = rec.fQACycles[iDet]; + } + + fVertexer = NULL; + delete fDiamondProfile; fDiamondProfile = NULL; + if (rec.fDiamondProfile) fDiamondProfile = new AliESDVertex(*rec.fDiamondProfile); + delete fDiamondProfileTPC; fDiamondProfileTPC = NULL; + if (rec.fDiamondProfileTPC) fDiamondProfileTPC = new AliESDVertex(*rec.fDiamondProfileTPC); + fMeanVertexConstraint = rec.fMeanVertexConstraint; + + delete fGRPData; fGRPData = NULL; + if (rec.fGRPData) fGRPData = (TMap*)((rec.fGRPData)->Clone()); + + delete fAlignObjArray; fAlignObjArray = NULL; + + fCDBUri = ""; + fSpecCDBUri.Delete(); + fInitCDBCalled = rec.fInitCDBCalled; + fSetRunNumberFromDataCalled = rec.fSetRunNumberFromDataCalled; + fQADetectors = rec.fQADetectors; + fQASteer = NULL; + fQATasks = rec.fQATasks; + fRunQA = rec.fRunQA; + fRunGlobalQA = rec.fRunGlobalQA; + fInLoopQA = rec.fInLoopQA; + fSameQACycle = rec.fSameQACycle; + fRunPlaneEff = rec.fRunPlaneEff; + + fesd = NULL; + fhltesd = NULL; + fesdf = NULL; + ffile = NULL; + ftree = NULL; + fhlttree = NULL; + ftVertexer = NULL; + fIsNewRunLoader = rec.fIsNewRunLoader; + fRunAliEVE = kFALSE; + fChain = NULL; - this->~AliReconstruction(); - new(this) AliReconstruction(rec); return *this; } @@ -393,9 +500,14 @@ AliReconstruction::~AliReconstruction() // clean up CleanUp(); + delete fForcedFieldMap; fOptions.Delete(); + if (fAlignObjArray) { + fAlignObjArray->Delete(); + delete fAlignObjArray; + } fSpecCDBUri.Delete(); - + delete fQASteer; AliCodeTimer::Instance()->Print(); } @@ -405,6 +517,7 @@ void AliReconstruction::InitCDB() // activate a default CDB storage // First check if we have any CDB storage set, because it is used // to retrieve the calibration and alignment constants + AliCodeTimerAuto(""); if (fInitCDBCalled) return; fInitCDBCalled = kTRUE; @@ -444,7 +557,7 @@ void AliReconstruction::InitCDB() AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"); man->SetSpecificStorage(obj->GetName(), obj->GetTitle()); } - + AliSysInfo::AddStamp("InitCDB"); } //_____________________________________________________________________________ @@ -510,40 +623,45 @@ Bool_t AliReconstruction::SetRunNumberFromData() fSetRunNumberFromDataCalled = kTRUE; AliCDBManager* man = AliCDBManager::Instance(); - - if(man->GetRun() > 0) { + + if(fRawReader) { + if(fRawReader->NextEvent()) { + if(man->GetRun() > 0) { AliWarning("Run number is taken from raw-event header! Ignoring settings in AliCDBManager!"); - } - - if (!fRunLoader) { - AliError("No run loader is found !"); + } + man->SetRun(fRawReader->GetRunNumber()); + fRawReader->RewindEvents(); + } + else { + if(man->GetRun() > 0) { + AliWarning("No raw-data events are found ! Using settings in AliCDBManager !"); + } + else { + AliWarning("Neither raw events nor settings in AliCDBManager are found !"); + return kFALSE; + } + } + } + else { + AliRunLoader *rl = AliRunLoader::Open(fGAliceFileName.Data()); + if (!rl) { + AliError(Form("No run loader found in file %s", fGAliceFileName.Data())); return kFALSE; } - // read run number from gAlice - if(fRunLoader->GetAliRun()) - AliCDBManager::Instance()->SetRun(fRunLoader->GetHeader()->GetRun()); else { - if(fRawReader) { - if(fRawReader->NextEvent()) { - AliCDBManager::Instance()->SetRun(fRawReader->GetRunNumber()); - fRawReader->RewindEvents(); - } - else { - if(man->GetRun() > 0) { - AliWarning("No raw events is found ! Using settings in AliCDBManager !"); - man->Print(); - return kTRUE; - } - else { - AliWarning("Neither raw events nor settings in AliCDBManager are found !"); - return kFALSE; - } - } + rl->LoadHeader(); + // read run number from gAlice + if(rl->GetHeader()) { + man->SetRun(rl->GetHeader()->GetRun()); + rl->UnloadHeader(); + delete rl; } else { - AliError("Neither gAlice nor RawReader objects are found !"); + AliError("Neither run-loader header nor RawReader objects are found !"); + delete rl; return kFALSE; } + } } man->Print(); @@ -583,6 +701,7 @@ Bool_t AliReconstruction::MisalignGeometry(const TString& detectors) } // end loop over detectors loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data()); + AliCDBManager::Instance()->UnloadFromCache("*/Align/*"); }else{ // Check if the array with alignment objects was // provided by the user. If yes, apply the objects @@ -602,7 +721,10 @@ Bool_t AliReconstruction::MisalignGeometry(const TString& detectors) } } - delete fAlignObjArray; fAlignObjArray=0; + if (fAlignObjArray) { + fAlignObjArray->Delete(); + delete fAlignObjArray; fAlignObjArray=NULL; + } return kTRUE; } @@ -616,21 +738,15 @@ void AliReconstruction::SetGAliceFile(const char* fileName) } //_____________________________________________________________________________ -void AliReconstruction::SetInput(const char* input,void **pEvent) +void AliReconstruction::SetInput(const char* input) { - // In case event pointer is given, we run in an online mode - // and the first argument is ignored. - // In case event pointer is NULL, we run in a normal - // mode over a raw-data file and the first argument points - // to the name of that file - if (!pEvent) { - fInput = input; - fpEvent = NULL; - } - else { - fInput = ""; - fpEvent = pEvent; - } + // In case the input string starts with 'mem://', we run in an online mode + // and AliRawReaderDateOnline object is created. In all other cases a raw-data + // file is assumed. One can give as an input: + // mem://: - events taken from DAQ monitoring libs online + // or + // mem:// - emulation of the above mode (via DATE monitoring libs) + if (input) fRawInput = input; } //_____________________________________________________________________________ @@ -644,60 +760,315 @@ void AliReconstruction::SetOption(const char* detector, const char* option) } //_____________________________________________________________________________ -Bool_t AliReconstruction::Run(const char* input) +void AliReconstruction::SetRecoParam(const char* detector, AliDetectorRecoParam *par) { - // Run Run Run - AliCodeTimerAuto(""); + // Set custom reconstruction parameters for a given detector + // Single set of parameters for all the events + for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { + if(!strcmp(detector, fgkDetectorName[iDet])) { + par->SetAsDefault(); + fRecoParam.AddDetRecoParam(iDet,par); + break; + } + } - if (!InitRun(input)) return kFALSE; - - //******* The loop over events - Int_t iEvent = 0; - while ((iEvent < fRunLoader->GetNumberOfEvents()) || - (fRawReader && fRawReader->NextEvent())) { - if (!RunEvent(iEvent)) return kFALSE; - iEvent++; +} + +//_____________________________________________________________________________ +Bool_t AliReconstruction::SetFieldMap(Float_t l3Current, Float_t diCurrent, Float_t factor, const char *path) { + //------------------------------------------------ + // The magnetic field map, defined externally... + // L3 current 30000 A -> 0.5 T + // L3 current 12000 A -> 0.2 T + // dipole current 6000 A + // The polarities must be the same + //------------------------------------------------ + const Float_t l3NominalCurrent1=30000.; // (A) + const Float_t l3NominalCurrent2=12000.; // (A) + const Float_t diNominalCurrent =6000. ; // (A) + + const Float_t tolerance=0.03; // relative current tolerance + const Float_t zero=77.; // "zero" current (A) + + Int_t map=0; + Bool_t dipoleON=kFALSE; + + TString s=(factor < 0) ? "L3: -" : "L3: +"; + + l3Current = TMath::Abs(l3Current); + if (TMath::Abs(l3Current-l3NominalCurrent1)/l3NominalCurrent1 < tolerance) { + map=AliMagWrapCheb::k5kG; + s+="0.5 T; "; + } else + if (TMath::Abs(l3Current-l3NominalCurrent2)/l3NominalCurrent2 < tolerance) { + map=AliMagWrapCheb::k2kG; + s+="0.2 T; "; + } else + if (l3Current < zero) { + map=AliMagWrapCheb::k2kG; + s+="0.0 T; "; + factor=0.; // in fact, this is a global factor... + fUniformField=kTRUE; // track with the uniform (zero) B field + } else { + AliError(Form("Wrong L3 current (%f A)!",l3Current)); + return kFALSE; } - if (!FinishRun()) return kFALSE; + diCurrent = TMath::Abs(diCurrent); + if (TMath::Abs(diCurrent-diNominalCurrent)/diNominalCurrent < tolerance) { + // 3% current tolerance... + dipoleON=kTRUE; + s+="Dipole ON"; + } else + if (diCurrent < zero) { // some small current.. + dipoleON=kFALSE; + s+="Dipole OFF"; + } else { + AliError(Form("Wrong dipole current (%f A)!",diCurrent)); + return kFALSE; + } + + delete fForcedFieldMap; + fForcedFieldMap= + new AliMagWrapCheb("B field map ",s,2,factor,10.,map,dipoleON,path); + + fForcedFieldMap->Print(); + + AliTracker::SetFieldMap(fForcedFieldMap,fUniformField); return kTRUE; } + +Bool_t AliReconstruction::InitGRP() { + //------------------------------------ + // Initialization of the GRP entry + //------------------------------------ + AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/Data"); + + if (entry) { + fGRPData = dynamic_cast(entry->GetObject()); + entry->SetOwner(0); + AliCDBManager::Instance()->UnloadFromCache("GRP/GRP/Data"); + } + + if (!fGRPData) { + AliError("No GRP entry found in OCDB!"); + return kFALSE; + } + + TObjString *lhcState= + dynamic_cast(fGRPData->GetValue("fLHCState")); + if (!lhcState) { + AliError("GRP/GRP/Data entry: missing value for the LHC state ! Using UNKNOWN"); + } + + TObjString *beamType= + dynamic_cast(fGRPData->GetValue("fAliceBeamType")); + if (!beamType) { + AliError("GRP/GRP/Data entry: missing value for the beam type ! Using UNKNOWN"); + } + + TObjString *beamEnergyStr= + dynamic_cast(fGRPData->GetValue("fAliceBeamEnergy")); + if (!beamEnergyStr) { + AliError("GRP/GRP/Data entry: missing value for the beam energy ! Using 0"); + } + + TObjString *runType= + dynamic_cast(fGRPData->GetValue("fRunType")); + if (!runType) { + AliError("GRP/GRP/Data entry: missing value for the run type ! Using UNKNOWN"); + } + + TObjString *activeDetectors= + dynamic_cast(fGRPData->GetValue("fDetectorMask")); + if (!activeDetectors) { + AliError("GRP/GRP/Data entry: missing value for the detector mask ! Using 1074790399"); + } + + fRunInfo = new AliRunInfo(lhcState ? lhcState->GetString().Data() : "UNKNOWN", + beamType ? beamType->GetString().Data() : "UNKNOWN", + beamEnergyStr ? beamEnergyStr->GetString().Atof() : 0, + runType ? runType->GetString().Data() : "UNKNOWN", + activeDetectors ? activeDetectors->GetString().Atoi() : 1074790399); + + // Process the list of active detectors + if (activeDetectors && activeDetectors->GetString().IsDigit()) { + UInt_t detMask = activeDetectors->GetString().Atoi(); + fLoadCDB.Form("%s %s %s %s", + fRunLocalReconstruction.Data(), + fRunTracking.Data(), + fFillESD.Data(), + fQADetectors.Data()); + fRunLocalReconstruction = MatchDetectorList(fRunLocalReconstruction,detMask); + fRunTracking = MatchDetectorList(fRunTracking,detMask); + fFillESD = MatchDetectorList(fFillESD,detMask); + fQADetectors = MatchDetectorList(fQADetectors,detMask); + fLoadCDB = MatchDetectorList(fLoadCDB,detMask); + } + + AliInfo("==================================================================================="); + AliInfo(Form("Running local reconstruction for detectors: %s",fRunLocalReconstruction.Data())); + AliInfo(Form("Running tracking for detectors: %s",fRunTracking.Data())); + AliInfo(Form("Filling ESD for detectors: %s",fFillESD.Data())); + AliInfo(Form("Quality assurance is active for detectors: %s",fQADetectors.Data())); + AliInfo(Form("CDB and reconstruction parameters are loaded for detectors: %s",fLoadCDB.Data())); + AliInfo("==================================================================================="); + + //*** Dealing with the magnetic field map + if (AliTracker::GetFieldMap()) { + AliInfo("Running with the externally set B field !"); + } else { + // Construct the field map out of the information retrieved from GRP. + + Bool_t ok = kTRUE; + + // L3 + TObjString *l3Current= + dynamic_cast(fGRPData->GetValue("fL3Current")); + if (!l3Current) { + AliError("GRP/GRP/Data entry: missing value for the L3 current !"); + ok = kFALSE; + } + TObjString *l3Polarity= + dynamic_cast(fGRPData->GetValue("fL3Polarity")); + if (!l3Polarity) { + AliError("GRP/GRP/Data entry: missing value for the L3 polarity !"); + ok = kFALSE; + } + + // Dipole + TObjString *diCurrent= + dynamic_cast(fGRPData->GetValue("fDipoleCurrent")); + if (!diCurrent) { + AliError("GRP/GRP/Data entry: missing value for the dipole current !"); + ok = kFALSE; + } + TObjString *diPolarity= + dynamic_cast(fGRPData->GetValue("fDipolePolarity")); + if (!diPolarity) { + AliError("GRP/GRP/Data entry: missing value for the dipole polarity !"); + ok = kFALSE; + } + + if (ok) { + Float_t l3Cur=TMath::Abs(atof(l3Current->GetName())); + Float_t diCur=TMath::Abs(atof(diCurrent->GetName())); + Float_t l3Pol=atof(l3Polarity->GetName()); + Float_t factor=1.; + if (l3Pol != 0.) factor=-1.; + + + if (!SetFieldMap(l3Cur, diCur, factor)) { + AliFatal("Failed to creat a B field map ! Exiting..."); + } + AliInfo("Running with the B field constructed out of GRP !"); + } + else { + AliFatal("B field is neither set nor constructed from GRP ! Exitig..."); + } + + } + + //*** Get the diamond profile from OCDB + entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex"); + if (entry) { + if (fMeanVertexConstraint) + fDiamondProfile = dynamic_cast (entry->GetObject()); + } else { + AliError("No diamond profile found in OCDB!"); + } + + entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC"); + if (entry) { + if (fMeanVertexConstraint) + fDiamondProfileTPC = dynamic_cast (entry->GetObject()); + } else { + AliError("No diamond profile found in OCDB!"); + } + + return kTRUE; +} + //_____________________________________________________________________________ -Bool_t AliReconstruction::InitRun(const char* input, void **pEvent) +Bool_t AliReconstruction::LoadCDB() { - // Initialize all the stuff before - // going into the event loop - // If the second argument is given, the first one is ignored and - // the reconstruction works in an online mode AliCodeTimerAuto(""); - if (pEvent) fpEvent = pEvent; - if (input) fInput = input; + AliCDBManager::Instance()->Get("GRP/CTP/Config"); - // set the input in case of raw data - if (!fInput.IsNull() || fpEvent) { - if (!fInput.IsNull()) { - AliInfo(Form("Reconstruction will run over a raw-data file: %s",fInput.Data())); - TString fileName(fInput); - if (fInput.EndsWith("/")) { - fRawReader = new AliRawReaderFile(fInput); - } else if (fInput.EndsWith(".root")) { - fRawReader = new AliRawReaderRoot(fInput); - } else { - fRawReader = new AliRawReaderDate(fInput); - } + TString detStr = fLoadCDB; + for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { + if (!IsSelected(fgkDetectorName[iDet], detStr)) continue; + AliCDBManager::Instance()->GetAll(Form("%s/Calib/*",fgkDetectorName[iDet])); + } + return kTRUE; +} + +//_____________________________________________________________________________ +Bool_t AliReconstruction::Run(const char* input) +{ + // Run Run Run + AliCodeTimerAuto(""); + + InitRun(input); + if (GetAbort() != TSelector::kContinue) return kFALSE; + + TChain *chain = NULL; + if (fRawReader && (chain = fRawReader->GetChain())) { + // Proof mode + if (gProof) { + gProof->AddInput(this); + TUrl outputFile; + outputFile.SetProtocol("root",kTRUE); + outputFile.SetHost(gSystem->HostName()); + outputFile.SetFile(Form("%s/AliESDs.root",gSystem->pwd())); + AliInfo(Form("Output file with ESDs is %s",outputFile.GetUrl())); + gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",outputFile.GetUrl())); + chain->SetProof(); + chain->Process("AliReconstruction"); } else { - AliInfo(Form("Reconstruction will run over an event in memory at: %p",*fpEvent)); - fRawReader = new AliRawReaderDate((void *)(*fpEvent)); + chain->Process(this); } } else { - AliInfo("Reconstruction will run over digits"); + Begin(NULL); + if (GetAbort() != TSelector::kContinue) return kFALSE; + SlaveBegin(NULL); + if (GetAbort() != TSelector::kContinue) return kFALSE; + //******* The loop over events + Int_t iEvent = 0; + while ((iEvent < fRunLoader->GetNumberOfEvents()) || + (fRawReader && fRawReader->NextEvent())) { + if (!ProcessEvent(iEvent)) { + Abort("ProcessEvent",TSelector::kAbortFile); + return kFALSE; + } + iEvent++; + } + SlaveTerminate(); + if (GetAbort() != TSelector::kContinue) return kFALSE; + Terminate(); + if (GetAbort() != TSelector::kContinue) return kFALSE; } + return kTRUE; +} + +//_____________________________________________________________________________ +void AliReconstruction::InitRawReader(const char* input) +{ + AliCodeTimerAuto(""); + + // Init raw-reader and + // set the input in case of raw data + if (input) fRawInput = input; + fRawReader = AliRawReader::Create(fRawInput.Data()); + if (!fRawReader) + AliInfo("Reconstruction will run over digits"); + if (!fEquipIdMap.IsNull() && fRawReader) fRawReader->LoadEquipmentIdsMap(fEquipIdMap); @@ -712,90 +1083,185 @@ Bool_t AliReconstruction::InitRun(const char* input, void **pEvent) AliError(Form("can not create Raw Reader for HLT input %s", fUseHLTData.Data())); } } + AliSysInfo::AddStamp("CreateRawReader"); +} - AliSysInfo::AddStamp("Start"); - // get the run loader - if (!InitRunLoader()) return kFALSE; - AliSysInfo::AddStamp("LoadLoader"); +//_____________________________________________________________________________ +void AliReconstruction::InitRun(const char* input) +{ + // Initialization of raw-reader, + // run number, CDB etc. + AliCodeTimerAuto(""); + AliSysInfo::AddStamp("Start"); + + // Initialize raw-reader if any + InitRawReader(input); // Initialize the CDB storage InitCDB(); - - AliSysInfo::AddStamp("LoadCDB"); // Set run number in CDBManager (if it is not already set by the user) - if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE; - + if (!SetRunNumberFromData()) { + Abort("SetRunNumberFromData", TSelector::kAbortProcess); + return; + } + // Set CDB lock: from now on it is forbidden to reset the run number // or the default storage or to activate any further storage! SetCDBLock(); +} + +//_____________________________________________________________________________ +void AliReconstruction::Begin(TTree *) +{ + // Initialize AlReconstruction before + // going into the event loop + // Should follow the TSelector convention + // i.e. initialize only the object on the client side + AliCodeTimerAuto(""); + + AliReconstruction *reco = NULL; + if (fInput) { + if ((reco = (AliReconstruction*)fInput->FindObject("AliReconstruction"))) { + *this = *reco; + } + AliSysInfo::AddStamp("ReadInputInBegin"); + } + // Import ideal TGeo geometry and apply misalignment if (!gGeoManager) { TString geom(gSystem->DirName(fGAliceFileName)); geom += "/geometry.root"; AliGeomManager::LoadGeometry(geom.Data()); - if (!gGeoManager) if (fStopOnError) return kFALSE; + if (!gGeoManager) { + Abort("LoadGeometry", TSelector::kAbortProcess); + return; + } + AliSysInfo::AddStamp("LoadGeom"); + TString detsToCheck=fRunLocalReconstruction; + if(!AliGeomManager::CheckSymNamesLUT(detsToCheck.Data())) { + Abort("CheckSymNamesLUT", TSelector::kAbortProcess); + return; + } + AliSysInfo::AddStamp("CheckGeom"); } - if (!MisalignGeometry(fLoadAlignData)) if (fStopOnError) return kFALSE; - AliSysInfo::AddStamp("LoadGeom"); + if (!MisalignGeometry(fLoadAlignData)) { + Abort("MisalignGeometry", TSelector::kAbortProcess); + return; + } + AliCDBManager::Instance()->UnloadFromCache("GRP/Geometry/Data"); + AliSysInfo::AddStamp("MisalignGeom"); - //QA - AliQADataMakerSteer qas ; - if (fRunQA && fRawReader) { - qas.Run(fRunLocalReconstruction, fRawReader) ; - fSameQACycle = kTRUE ; + if (!InitGRP()) { + Abort("InitGRP", TSelector::kAbortProcess); + return; } - // checking the QA of previous steps - //CheckQA() ; - - /* - // local reconstruction - if (!fRunLocalReconstruction.IsNull()) { - if (!RunLocalReconstruction(fRunLocalReconstruction)) { - if (fStopOnError) {CleanUp(); return kFALSE;} + AliSysInfo::AddStamp("InitGRP"); + + if (!LoadCDB()) { + Abort("LoadCDB", TSelector::kAbortProcess); + return; + } + AliSysInfo::AddStamp("LoadCDB"); + + // Read the reconstruction parameters from OCDB + if (!InitRecoParams()) { + AliWarning("Not all detectors have correct RecoParam objects initialized"); + } + AliSysInfo::AddStamp("InitRecoParams"); + + if (fInput) { + if (reco) *reco = *this; + fInput->Add(gGeoManager); + gGeoManager = NULL; + fInput->Add(const_cast(AliCDBManager::Instance()->GetEntryCache())); + fInput->Add(new TParameter("RunNumber",AliCDBManager::Instance()->GetRun())); + AliMagF *magFieldMap = (AliMagF*)AliTracker::GetFieldMap(); + magFieldMap->SetName("MagneticFieldMap"); + fInput->Add(magFieldMap); + } + +} + +//_____________________________________________________________________________ +void AliReconstruction::SlaveBegin(TTree*) +{ + // Initialization related to run-loader, + // vertexer, trackers, recontructors + // In proof mode it is executed on the slave + AliCodeTimerAuto(""); + + TProofOutputFile *outProofFile = NULL; + if (fInput) { + if (AliReconstruction *reco = (AliReconstruction*)fInput->FindObject("AliReconstruction")) { + *this = *reco; + } + if (TGeoManager *tgeo = (TGeoManager*)fInput->FindObject("Geometry")) { + gGeoManager = tgeo; + AliGeomManager::SetGeometry(tgeo); + } + if (TMap *entryCache = (TMap*)fInput->FindObject("CDBEntryCache")) { + Int_t runNumber = -1; + if (TProof::GetParameter(fInput,"RunNumber",runNumber) == 0) { + AliCDBManager *man = AliCDBManager::Instance(entryCache,runNumber); + man->SetCacheFlag(kTRUE); + man->SetLock(kTRUE); + man->Print(); + } + } + if (AliMagF *map = (AliMagF*)fInput->FindObject("MagneticFieldMap")) { + AliTracker::SetFieldMap(map,fUniformField); + } + if (TNamed *outputFileName = (TNamed *) fInput->FindObject("PROOF_OUTPUTFILE")) { + outProofFile = new TProofOutputFile(gSystem->BaseName(TUrl(outputFileName->GetTitle()).GetFile())); + outProofFile->SetOutputFileName(outputFileName->GetTitle()); + fOutput->Add(outProofFile); } + AliSysInfo::AddStamp("ReadInputInSlaveBegin"); + } + + // get the run loader + if (!InitRunLoader()) { + Abort("InitRunLoader", TSelector::kAbortProcess); + return; } - */ + AliSysInfo::AddStamp("LoadLoader"); + + ftVertexer = new AliVertexerTracks(AliTracker::GetBz()); + if(fDiamondProfile && fMeanVertexConstraint) ftVertexer->SetVtxStart(fDiamondProfile); // get vertexer if (fRunVertexFinder && !CreateVertexer()) { - if (fStopOnError) { - CleanUp(); - return kFALSE; - } + Abort("CreateVertexer", TSelector::kAbortProcess); + return; } - AliSysInfo::AddStamp("Vertexer"); + AliSysInfo::AddStamp("CreateVertexer"); // get trackers if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) { - if (fStopOnError) { - CleanUp(); - return kFALSE; - } - } - AliSysInfo::AddStamp("LoadTrackers"); + Abort("CreateTrackers", TSelector::kAbortProcess); + return; + } + AliSysInfo::AddStamp("CreateTrackers"); - // get the possibly already existing ESD file and tree - fesd = new AliESDEvent(); fhltesd = new AliESDEvent(); - if (!gSystem->AccessPathName("AliESDs.root")){ - gSystem->CopyFile("AliESDs.root", "AliESDs.old.root", kTRUE); - ffileOld = TFile::Open("AliESDs.old.root"); - if (ffileOld && ffileOld->IsOpen()) { - ftreeOld = (TTree*) ffileOld->Get("esdTree"); - if (ftreeOld)fesd->ReadFromTree(ftreeOld); - fhlttreeOld = (TTree*) ffileOld->Get("HLTesdTree"); - if (fhlttreeOld) fhltesd->ReadFromTree(fhlttreeOld); + // create the ESD output file and tree + if (!outProofFile) { + ffile = TFile::Open("AliESDs.root", "RECREATE"); + ffile->SetCompressionLevel(2); + if (!ffile->IsOpen()) { + Abort("OpenESDFile", TSelector::kAbortProcess); + return; } } - - // create the ESD output file and tree - ffile = TFile::Open("AliESDs.root", "RECREATE"); - ffile->SetCompressionLevel(2); - if (!ffile->IsOpen()) { - AliError("opening AliESDs.root failed"); - if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;} + else { + if (!(ffile = outProofFile->OpenFile("RECREATE"))) { + Abort(Form("Problems opening output PROOF file: %s/%s", + outProofFile->GetDir(), outProofFile->GetFileName()), + TSelector::kAbortProcess); + return; + } } ftree = new TTree("esdTree", "Tree with ESD objects"); @@ -808,13 +1274,6 @@ Bool_t AliReconstruction::InitRun(const char* input, void **pEvent) fhltesd->CreateStdContent(); fhltesd->WriteToTree(fhlttree); - /* CKB Why? - delete esd; delete hltesd; - esd = NULL; hltesd = NULL; - */ - // create the branch with ESD additions - - if (fWriteESDfriend) { fesdf = new AliESDfriend(); @@ -823,88 +1282,92 @@ Bool_t AliReconstruction::InitRun(const char* input, void **pEvent) fesd->AddObject(fesdf); } + ProcInfo_t ProcInfo; + gSystem->GetProcInfo(&ProcInfo); + AliInfo(Form("Current memory usage %d %d", ProcInfo.fMemResident, ProcInfo.fMemVirtual)); - // Get the GRP CDB entry - AliCDBEntry* entryGRP = AliCDBManager::Instance()->Get("GRP/GRP/Data"); + //QA + fQASteer = new AliQADataMakerSteer("rec") ; + fQASteer->SetActiveDetectors(fQADetectors) ; + fQASteer->SetTasks(fQATasks) ; + + if ( !fInLoopQA ) { + if (fRunQA && fRawReader && fQATasks.Contains(Form("%d", AliQA::kRAWS))) { + fQASteer->Run(fQADetectors, fRawReader) ; + fSameQACycle = kTRUE ; + } + } - if(entryGRP) { - fGRPList = dynamic_cast (entryGRP->GetObject()); - } else { - AliError("No GRP entry found in OCDB!"); + //Initialize the QA and start of cycle for out-of-loop QA + if (fRunQA) { + fQASteer->InitQADataMaker(AliCDBManager::Instance()->GetRun(), fRecoParam, fSameQACycle, !fInLoopQA) ; } - - // Get the diamond profile from OCDB - AliCDBEntry* entry = AliCDBManager::Instance() - ->Get("GRP/Calib/MeanVertex"); - if(entry) { - fDiamondProfile = dynamic_cast (entry->GetObject()); - } else { - AliError("No diamond profile found in OCDB!"); + if (fRunGlobalQA) { + fSameQACycle = kFALSE; + AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL); + AliInfo(Form("Initializing the global QA data maker")); + if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS))) { + TObjArray *arr=qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun()); + AliTracker::SetResidualsArray(arr); + if (!fInLoopQA) { + qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle); + fSameQACycle = kTRUE; + } + } + if (fQATasks.Contains(Form("%d", AliQA::kESDS))) { + qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun()); + if (!fInLoopQA) { + qadm->StartOfCycle(AliQA::kESDS, fSameQACycle); + fSameQACycle = kTRUE; + } + } } - entry = 0; - entry = AliCDBManager::Instance() - ->Get("GRP/Calib/MeanVertexTPC"); - - if(entry) { - fDiamondProfileTPC = dynamic_cast (entry->GetObject()); - } else { - AliError("No diamond profile found in OCDB!"); + //Initialize the Plane Efficiency framework + if (fRunPlaneEff && !InitPlaneEff()) { + Abort("InitPlaneEff", TSelector::kAbortProcess); + return; } - ftVertexer = new AliVertexerTracks(AliTracker::GetBz()); - if(fDiamondProfile && fMeanVertexConstraint) ftVertexer->SetVtxStart(fDiamondProfile); + if (strcmp(gProgName,"alieve") == 0) + fRunAliEVE = InitAliEVE(); - if (fRawReader) fRawReader->RewindEvents(); + return; +} - ProcInfo_t ProcInfo; - gSystem->GetProcInfo(&ProcInfo); - AliInfo(Form("Current memory usage %d %d", ProcInfo.fMemResident, ProcInfo.fMemVirtual)); - +//_____________________________________________________________________________ +Bool_t AliReconstruction::Process(Long64_t entry) +{ + // run the reconstruction over a single entry + // from the chain with raw data + AliCodeTimerAuto(""); - //Initialize the QA and start of cycle for out-of-cycle QA - if (fRunQA) { - TString detStr(fFillESD); - for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { - if (!IsSelected(fgkDetectorName[iDet], detStr)) continue; - AliQADataMakerRec *qadm = GetQADataMaker(iDet); - if (!qadm) continue; - AliInfo(Form("Initializing the QA data maker for %s", - fgkDetectorName[iDet])); - qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun()); - qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun()); - if (!fInLoopQA) { - qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle); - qadm->StartOfCycle(AliQA::kESDS,"same"); - } - } - if (fRunGlobalQA) { - AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL); - AliInfo(Form("Initializing the global QA data maker")); - TObjArray *arr= - qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun()); - AliTracker::SetResidualsArray(arr); - qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun()); - if (!fInLoopQA) { - qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle); - qadm->StartOfCycle(AliQA::kESDS, "same"); - } - } - if (!fInLoopQA) - fSameQACycle = kTRUE; - } + TTree *currTree = fChain->GetTree(); + AliRawEvent *event = new AliRawEvent; + currTree->SetBranchAddress("rawevent",&event); + currTree->GetEntry(entry); + fRawReader = new AliRawReaderRoot(event); + fStatus = ProcessEvent(fRunLoader->GetNumberOfEvents()); + delete fRawReader; + fRawReader = NULL; + delete event; - //Initialize the Plane Efficiency framework - if (fRunPlaneEff && !InitPlaneEff()) { - if(fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;} - } + return fStatus; +} - return kTRUE; +//_____________________________________________________________________________ +void AliReconstruction::Init(TTree *tree) +{ + if (tree == 0) { + AliError("The input tree is not found!"); + return; + } + fChain = tree; } //_____________________________________________________________________________ -Bool_t AliReconstruction::RunEvent(Int_t iEvent) +Bool_t AliReconstruction::ProcessEvent(Int_t iEvent) { // run the reconstruction over a single event // The event loop is steered in Run method @@ -915,60 +1378,57 @@ Bool_t AliReconstruction::RunEvent(Int_t iEvent) fRunLoader->SetEventNumber(iEvent); fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(), iEvent, iEvent); - //?? fRunLoader->MakeTree("H"); fRunLoader->TreeE()->Fill(); + if (fRawReader && fRawReader->UseAutoSaveESD()) + fRunLoader->TreeE()->AutoSave("SaveSelf"); } if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) { - // copy old ESD to the new one - if (ftreeOld) { - fesd->ReadFromTree(ftreeOld); - ftreeOld->GetEntry(iEvent); - ftree->Fill(); - } - if (fhlttreeOld) { - fesd->ReadFromTree(fhlttreeOld); - fhlttreeOld->GetEntry(iEvent); - fhlttree->Fill(); - } return kTRUE; } AliInfo(Form("processing event %d", iEvent)); - //Start of cycle for the in-loop QA - if (fInLoopQA) { - if (fRunQA) { - TString detStr(fFillESD); - for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { - if (!IsSelected(fgkDetectorName[iDet], detStr)) - continue; - AliQADataMakerRec *qadm = GetQADataMaker(iDet); - if (!qadm) - continue; - qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle); - qadm->StartOfCycle(AliQA::kESDS, "same") ; - } - if (fRunGlobalQA) { - AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL); - qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle); - qadm->StartOfCycle(AliQA::kESDS, "same"); - } - } + // Fill Event-info object + GetEventInfo(); + fRecoParam.SetEventSpecie(fRunInfo,fEventInfo); + + //Start of cycle for the in-loop QA + if (fInLoopQA && fRunQA) { + fQASteer->InitQADataMaker(AliCDBManager::Instance()->GetRun(), fRecoParam, fSameQACycle, fInLoopQA) ; + } + if (fInLoopQA && fRunGlobalQA) { + fSameQACycle = kFALSE; + AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL); + if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS))) { + qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle); + fSameQACycle = kTRUE; + } + if (fQATasks.Contains(Form("%d", AliQA::kESDS))) { + qadm->StartOfCycle(AliQA::kESDS, fSameQACycle); + fSameQACycle = kTRUE; } + } - fRunLoader->GetEvent(iEvent); + fRunLoader->GetEvent(iEvent); - char aFileName[256]; - sprintf(aFileName, "ESD_%d.%d_final.root", - fRunLoader->GetHeader()->GetRun(), - fRunLoader->GetHeader()->GetEventNrInRun()); - if (!gSystem->AccessPathName(aFileName)) return kTRUE; + // QA on single raw + if (fInLoopQA && fRunQA) + fQASteer->RunOneEvent(fRawReader) ; - // local signle event reconstruction + // local single event reconstruction if (!fRunLocalReconstruction.IsNull()) { - if (!RunLocalEventReconstruction(fRunLocalReconstruction)) { - if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;} + TString detectors=fRunLocalReconstruction; + // run HLT event reconstruction first + // ;-( IsSelected changes the string + if (IsSelected("HLT", detectors) && + !RunLocalEventReconstruction("HLT")) { + if (fStopOnError) {CleanUp(); return kFALSE;} + } + detectors=fRunLocalReconstruction; + detectors.ReplaceAll("HLT", ""); + if (!RunLocalEventReconstruction(detectors)) { + if (fStopOnError) {CleanUp(); return kFALSE;} } } @@ -988,21 +1448,8 @@ Bool_t AliReconstruction::RunEvent(Int_t iEvent) // vertex finder if (fRunVertexFinder) { - if (!ReadESD(fesd, "vertex")) { - if (!RunVertexFinder(fesd)) { - if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;} - } - if (fCheckPointLevel > 0) WriteESD(fesd, "vertex"); - } - } - - // HLT tracking - if (!fRunTracking.IsNull()) { - if (fRunHLTTracking) { - fhltesd->SetPrimaryVertexSPD(fesd->GetVertex()); - if (!RunHLTTracking(fhltesd)) { - if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;} - } + if (!RunVertexFinder(fesd)) { + if (fStopOnError) {CleanUp(); return kFALSE;} } } @@ -1010,25 +1457,39 @@ Bool_t AliReconstruction::RunEvent(Int_t iEvent) if (!fRunTracking.IsNull()) { if (fRunMuonTracking) { if (!RunMuonTracking(fesd)) { - if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;} + if (fStopOnError) {CleanUp(); return kFALSE;} } } } // barrel tracking if (!fRunTracking.IsNull()) { - if (!ReadESD(fesd, "tracking")) { - if (!RunTracking(fesd)) { - if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;} - } - if (fCheckPointLevel > 0) WriteESD(fesd, "tracking"); + if (!RunTracking(fesd)) { + if (fStopOnError) {CleanUp(); return kFALSE;} } } // fill ESD if (!fFillESD.IsNull()) { - if (!FillESD(fesd, fFillESD)) { - if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;} + TString detectors=fFillESD; + // run HLT first and on hltesd + // ;-( IsSelected changes the string + if (IsSelected("HLT", detectors) && + !FillESD(fhltesd, "HLT")) { + if (fStopOnError) {CleanUp(); return kFALSE;} + } + detectors=fFillESD; + // Temporary fix to avoid problems with HLT that overwrites the offline ESDs + if (detectors.Contains("ALL")) { + detectors=""; + for (Int_t idet=0; idet 1) WriteESD(fesd, "PID"); if (fFillTriggerESD) { - if (!ReadESD(fesd, "trigger")) { - if (!FillTriggerESD(fesd)) { - if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;} - } - if (fCheckPointLevel > 1) WriteESD(fesd, "trigger"); + if (!FillTriggerESD(fesd)) { + if (fStopOnError) {CleanUp(); return kFALSE;} } } ffile->cd(); // - // Propagate track to the beam pipe (if not laready done by ITS) + // Propagate track to the beam pipe (if not already done by ITS) // const Int_t ntracks = fesd->GetNumberOfTracks(); const Double_t kBz = fesd->GetMagneticField(); @@ -1074,35 +1531,34 @@ Bool_t AliReconstruction::RunEvent(Int_t iEvent) ok = AliTracker:: PropagateTrackTo(tpcTrack,kRadius,track->GetMass(),kMaxStep,kTRUE); - - if (ok) { Int_t n=trkArray.GetEntriesFast(); selectedIdx[n]=track->GetID(); trkArray.AddLast(tpcTrack); } - if (track->GetX() < kRadius) continue; + //Tracks refitted by ITS should already be at the SPD vertex + if (track->IsOn(AliESDtrack::kITSrefit)) continue; + + AliTracker:: + PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kTRUE); + track->RelateToVertex(fesd->GetPrimaryVertexSPD(), kBz, kVeryBig); - ok = AliTracker:: - PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kTRUE); - if (ok) { - track->RelateToVertex(fesd->GetPrimaryVertexSPD(), kBz, kRadius); - } } // // Improve the reconstructed primary vertex position using the tracks // - TObject *obj = fOptions.FindObject("ITS"); - if (obj) { - TString optITS = obj->GetTitle(); - if (optITS.Contains("cosmics") || optITS.Contains("COSMICS")) - fRunVertexFinderTracks=kFALSE; + Bool_t runVertexFinderTracks = fRunVertexFinderTracks; + if(fesd->GetPrimaryVertexSPD()) { + TString vtitle = fesd->GetPrimaryVertexSPD()->GetTitle(); + if(vtitle.Contains("cosmics")) { + runVertexFinderTracks=kFALSE; + } } - if (fRunVertexFinderTracks) { + if (runVertexFinderTracks) { // TPC + ITS primary vertex - ftVertexer->SetITSrefitRequired(); + ftVertexer->SetITSMode(); if(fDiamondProfile && fMeanVertexConstraint) { ftVertexer->SetVtxStart(fDiamondProfile); } else { @@ -1114,13 +1570,13 @@ Bool_t AliReconstruction::RunEvent(Int_t iEvent) fesd->SetPrimaryVertex(pvtx); for (Int_t i=0; iGetTrack(i); - t->RelateToVertex(pvtx, kBz, kRadius); + t->RelateToVertex(pvtx, kBz, kVeryBig); } } } // TPC-only primary vertex - ftVertexer->SetITSrefitNotRequired(); + ftVertexer->SetTPCMode(); if(fDiamondProfileTPC && fMeanVertexConstraint) { ftVertexer->SetVtxStart(fDiamondProfileTPC); } else { @@ -1130,11 +1586,9 @@ Bool_t AliReconstruction::RunEvent(Int_t iEvent) if (pvtx) { if (pvtx->GetStatus()) { fesd->SetPrimaryVertexTPC(pvtx); - Int_t nsel=trkArray.GetEntriesFast(); - for (Int_t i=0; iPropagateToDCA(pvtx, kBz, kRadius); + for (Int_t i=0; iGetTrack(i); + t->RelateToVertexTPC(pvtx, kBz, kVeryBig); } } } @@ -1160,12 +1614,11 @@ Bool_t AliReconstruction::RunEvent(Int_t iEvent) // write ESD if (fCleanESD) CleanESD(fesd); - if (fRunQA) { - if (fRunGlobalQA) { - AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL); - if (qadm) qadm->Exec(AliQA::kESDS, fesd); - } - } + if (fRunGlobalQA) { + AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL); + if (qadm && fQATasks.Contains(Form("%d", AliQA::kESDS))) + qadm->Exec(AliQA::kESDS, fesd); + } if (fWriteESDfriend) { fesdf->~AliESDfriend(); @@ -1174,10 +1627,16 @@ Bool_t AliReconstruction::RunEvent(Int_t iEvent) } ftree->Fill(); + // Auto-save the ESD tree in case of prompt reco @P2 + if (fRawReader && fRawReader->UseAutoSaveESD()) + ftree->AutoSave("SaveSelf"); + // write HLT ESD fhlttree->Fill(); - if (fCheckPointLevel > 0) WriteESD(fesd, "final"); + // call AliEVE + if (fRunAliEVE) RunAliEVE(); + fesd->Reset(); fhltesd->Reset(); if (fWriteESDfriend) { @@ -1190,65 +1649,35 @@ Bool_t AliReconstruction::RunEvent(Int_t iEvent) AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, ProcInfo.fMemResident, ProcInfo.fMemVirtual)); - // End of cycle for the in-loop QA - if (fInLoopQA) { - if (fRunQA) { - RunQA(fFillESD.Data(), fesd); - TString detStr(fFillESD); - for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { - if (!IsSelected(fgkDetectorName[iDet], detStr)) - continue; - AliQADataMakerRec * qadm = GetQADataMaker(iDet); - if (!qadm) - continue; - qadm->EndOfCycle(AliQA::kRECPOINTS); - qadm->EndOfCycle(AliQA::kESDS); - qadm->Finish(); - } - } - if (fRunGlobalQA) { - AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL); - if (qadm) { - qadm->EndOfCycle(AliQA::kRECPOINTS); - qadm->EndOfCycle(AliQA::kESDS); - qadm->Finish(); - } - } - } - - return kTRUE; -} - -//_____________________________________________________________________________ -Bool_t AliReconstruction::AddEventAndRun() -{ - // for online usage only - // Add an event to the run-loader - // and - // re-creates AliRawReaderDate for this new event - AliCodeTimerAuto(""); - - if (!fpEvent) { - AliError("No raw-data event in memory given as an input! Do nothing!"); - return kFALSE; - } - - // New raw-reader. Could be redone in a better way... To do - fRawReader->~AliRawReader(); - new (fRawReader) AliRawReaderDate((void*)(*fpEvent)); - if (!fRawReader->NextEvent()) return kFALSE; - - // Expand the number of events in the run-loader - - Int_t nEvents = fRunLoader->GetNumberOfEvents(); + // End of cycle for the in-loop + if (fInLoopQA && fRunQA) { + fQASteer->RunOneEvent(fesd) ; + fQASteer->EndOfCycle() ; + } + if (fInLoopQA && fRunGlobalQA) { + AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL); + if (qadm) { + if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS))) + qadm->EndOfCycle(AliQA::kRECPOINTS); + if (fQATasks.Contains(Form("%d", AliQA::kESDS))) + qadm->EndOfCycle(AliQA::kESDS); + qadm->Finish(); + } + } - return RunEvent(nEvents); + fEventInfo.Reset(); + for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { + if (fReconstructor[iDet]) + fReconstructor[iDet]->SetRecoParam(NULL); + } + + return kTRUE; } //_____________________________________________________________________________ -Bool_t AliReconstruction::FinishRun() +void AliReconstruction::SlaveTerminate() { - // Finalize the run + // Finalize the run on the slave side // Called after the exit // from the event loop AliCodeTimerAuto(""); @@ -1283,8 +1712,8 @@ Bool_t AliReconstruction::FinishRun() TIter iter2(cdbList); - AliCDBId* id=0; - while((id = dynamic_cast (iter2.Next()))){ + AliCDBId* id=0; + while((id = dynamic_cast (iter2.Next()))){ cdbListCopy->Add(new TObjString(id->ToString().Data())); } @@ -1312,100 +1741,36 @@ Bool_t AliReconstruction::FinishRun() AliWarning("Finish PlaneEff evaluation failed"); } - gROOT->cd(); - CleanUp(ffile, ffileOld); - - if (fWriteAOD) { - AliWarning("AOD creation not supported anymore during reconstruction. See ANALYSIS/AliAnalysisTaskESDfilter.cxx instead."); + //Finish QA and end of cycle for out-of-loop QA + if (!fInLoopQA && fRunQA) + fQASteer->Run(fRunLocalReconstruction.Data(), AliQA::kNULLTASKINDEX, fSameQACycle) ; + if (!fInLoopQA && fRunGlobalQA) { + AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL); + if (qadm) { + if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS))) + qadm->EndOfCycle(AliQA::kRECPOINTS); + if (fQATasks.Contains(Form("%d", AliQA::kESDS))) + qadm->EndOfCycle(AliQA::kESDS); + qadm->Finish(); + } } + gROOT->cd(); + CleanUp(); +} + +//_____________________________________________________________________________ +void AliReconstruction::Terminate() +{ // Create tags for the events in the ESD tree (the ESD tree is always present) // In case of empty events the tags will contain dummy values + AliCodeTimerAuto(""); + AliESDTagCreator *esdtagCreator = new AliESDTagCreator(); - esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPList); - if (fWriteAOD) { - AliWarning("AOD tag creation not supported anymore during reconstruction."); - } + esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData); - //Finish QA and end of cycle for out-of-loop QA - if (!fInLoopQA) { - if (fRunQA) { - AliQADataMakerSteer qas; - qas.Run(fRunLocalReconstruction.Data(), AliQA::kRECPOINTS, fSameQACycle); - //qas.Reset() ; - qas.Run(fRunTracking.Data(), AliQA::kESDS, fSameQACycle); - if (fRunGlobalQA) { - AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL); - if (qadm) { - qadm->EndOfCycle(AliQA::kRECPOINTS); - qadm->EndOfCycle(AliQA::kESDS); - qadm->Finish(); - } - } - } - } - // Cleanup of CDB manager: cache and active storages! AliCDBManager::Instance()->ClearCache(); - - return kTRUE; -} - - -//_____________________________________________________________________________ -Bool_t AliReconstruction::RunLocalReconstruction(const TString& /*detectors*/) -{ -// run the local reconstruction - static Int_t eventNr=0; - AliCodeTimerAuto("") - - // AliCDBManager* man = AliCDBManager::Instance(); -// Bool_t origCache = man->GetCacheFlag(); - -// TString detStr = detectors; -// for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { -// if (!IsSelected(fgkDetectorName[iDet], detStr)) continue; -// AliReconstructor* reconstructor = GetReconstructor(iDet); -// if (!reconstructor) continue; -// if (reconstructor->HasLocalReconstruction()) continue; - -// AliCodeTimerStart(Form("running reconstruction for %s", fgkDetectorName[iDet])); -// AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet])); - -// AliCodeTimerStart(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet])); -// AliInfo(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet])); - -// man->SetCacheFlag(kTRUE); -// TString calibPath = Form("%s/Calib/*", fgkDetectorName[iDet]); -// man->GetAll(calibPath); // entries are cached! - -// AliCodeTimerStop(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet])); - -// if (fRawReader) { -// fRawReader->RewindEvents(); -// reconstructor->Reconstruct(fRunLoader, fRawReader); -// } else { -// reconstructor->Reconstruct(fRunLoader); -// } - -// AliCodeTimerStop(Form("running reconstruction for %s", fgkDetectorName[iDet])); - // AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr)); - -// // unload calibration data -// man->UnloadFromCache(calibPath); -// //man->ClearCache(); -// } - -// man->SetCacheFlag(origCache); - -// if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) { -// AliError(Form("the following detectors were not found: %s", -// detStr.Data())); -// if (fStopOnError) return kFALSE; -// } - - eventNr++; - return kTRUE; } //_____________________________________________________________________________ @@ -1422,6 +1787,17 @@ Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors) AliReconstructor* reconstructor = GetReconstructor(iDet); if (!reconstructor) continue; AliLoader* loader = fLoader[iDet]; + // Matthias April 2008: temporary fix to run HLT reconstruction + // although the HLT loader is missing + if (strcmp(fgkDetectorName[iDet], "HLT")==0) { + if (fRawReader) { + reconstructor->Reconstruct(fRawReader, NULL); + } else { + TTree* dummy=NULL; + reconstructor->Reconstruct(dummy, NULL); + } + continue; + } if (!loader) { AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet])); continue; @@ -1430,8 +1806,8 @@ Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors) if (fRawReader && reconstructor->HasDigitConversion()) { AliInfo(Form("converting raw data digits into root objects for %s", fgkDetectorName[iDet])); - AliCodeTimerAuto(Form("converting raw data digits into root objects for %s", - fgkDetectorName[iDet])); +// AliCodeTimerAuto(Form("converting raw data digits into root objects for %s", +// fgkDetectorName[iDet])); loader->LoadDigits("update"); loader->CleanDigits(); loader->MakeDigitsContainer(); @@ -1442,7 +1818,7 @@ Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors) } // local reconstruction AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet])); - AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet])); + //AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet])); loader->LoadRecPoints("update"); loader->CleanRecPoints(); loader->MakeRecPointsContainer(); @@ -1462,27 +1838,15 @@ Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors) } // In-loop QA for local reconstrucion - if (fRunQA && fInLoopQA) { - AliQADataMakerRec * qadm = GetQADataMaker(iDet); - if (qadm) { - //AliCodeTimerStart - //(Form("Running QA data maker for %s", fgkDetectorName[iDet])); - //AliInfo - //(Form("Running QA data maker for %s", fgkDetectorName[iDet])); - - qadm->Exec(AliQA::kRECPOINTS, clustersTree) ; - - //AliCodeTimerStop - //(Form("Running QA data maker for %s", fgkDetectorName[iDet])); - } - } - - loader->WriteRecPoints("OVERWRITE"); - loader->UnloadRecPoints(); - AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr); - } - - if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) { + TString detQAStr(fQADetectors) ; + if (fRunQA && fInLoopQA) + fQASteer->RunOneEventInOneDetector(iDet, clustersTree) ; + + loader->WriteRecPoints("OVERWRITE"); + loader->UnloadRecPoints(); + AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr); + } + if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) { AliError(Form("the following detectors were not found: %s", detStr.Data())); if (fStopOnError) return kFALSE; @@ -1508,11 +1872,22 @@ Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd) } if (fVertexer) { - if(fDiamondProfile) fVertexer->SetVtxStart(fDiamondProfile); AliInfo("running the ITS vertex finder"); - if (fLoader[0]) fLoader[0]->LoadRecPoints(); - vertex = fVertexer->FindVertexForCurrentEvent(fRunLoader->GetEventNumber()); - if (fLoader[0]) fLoader[0]->UnloadRecPoints(); + if (fLoader[0]) { + fLoader[0]->LoadRecPoints(); + TTree* cltree = fLoader[0]->TreeR(); + if (cltree) { + if(fDiamondProfile) fVertexer->SetVtxStart(fDiamondProfile); + vertex = fVertexer->FindVertexForCurrentEvent(cltree); + } + else { + AliError("Can't get the ITS cluster tree"); + } + fLoader[0]->UnloadRecPoints(); + } + else { + AliError("Can't get the ITS loader"); + } if(!vertex){ AliWarning("Vertex not found"); vertex = new AliESDVertex(); @@ -1690,9 +2065,6 @@ Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd) AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet])); return kFALSE; } - if (fCheckPointLevel > 1) { - WriteESD(esd, Form("%s.tracking", fgkDetectorName[iDet])); - } // preliminary PID in TPC needed by the ITS tracker if (iDet == 1) { GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd); @@ -1729,12 +2101,9 @@ Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd) AliError(Form("%s backward propagation failed", fgkDetectorName[iDet])); // return kFALSE; } - if (fCheckPointLevel > 1) { - WriteESD(esd, Form("%s.back", fgkDetectorName[iDet])); - } // unload clusters - if (iDet > 2) { // all except ITS, TPC, TRD + if (iDet > 3) { // all except ITS, TPC, TRD and TOF fTracker[iDet]->UnloadClusters(); fLoader[iDet]->UnloadRecPoints(); } @@ -1748,11 +2117,6 @@ Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd) //stop filling residuals for the "outer" detectors if (fRunGlobalQA) AliTracker::SetFillResiduals(kFALSE); - // write space-points to the ESD in case alignment data output - // is switched on - if (fWriteAlignmentData) - WriteAlignmentData(esd); - // pass 3: TRD + TPC + ITS refit inwards for (Int_t iDet = 2; iDet >= 0; iDet--) { @@ -1772,10 +2136,16 @@ Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd) AliError(Form("%s postprocessing failed", fgkDetectorName[iDet])); // return kFALSE; } - if (fCheckPointLevel > 1) { - WriteESD(esd, Form("%s.refit", fgkDetectorName[iDet])); - } AliSysInfo::AddStamp(Form("Tracking2%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr); + } + + // write space-points to the ESD in case alignment data output + // is switched on + if (fWriteAlignmentData) + WriteAlignmentData(esd); + + for (Int_t iDet = 3; iDet >= 0; iDet--) { + if (!fTracker[iDet]) continue; // unload clusters fTracker[iDet]->UnloadClusters(); AliSysInfo::AddStamp(Form("TUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,4, eventNr); @@ -1824,39 +2194,35 @@ Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors) if (!IsSelected(fgkDetectorName[iDet], detStr)) continue; AliReconstructor* reconstructor = GetReconstructor(iDet); if (!reconstructor) continue; - if (!ReadESD(esd, fgkDetectorName[iDet])) { - AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet])); - TTree* clustersTree = NULL; + AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet])); + TTree* clustersTree = NULL; + if (fLoader[iDet]) { + fLoader[iDet]->LoadRecPoints("read"); + clustersTree = fLoader[iDet]->TreeR(); + if (!clustersTree) { + AliError(Form("Can't get the %s clusters tree", + fgkDetectorName[iDet])); + if (fStopOnError) return kFALSE; + } + } + if (fRawReader && !reconstructor->HasDigitConversion()) { + reconstructor->FillESD(fRawReader, clustersTree, esd); + } else { + TTree* digitsTree = NULL; if (fLoader[iDet]) { - fLoader[iDet]->LoadRecPoints("read"); - clustersTree = fLoader[iDet]->TreeR(); - if (!clustersTree) { - AliError(Form("Can't get the %s clusters tree", + fLoader[iDet]->LoadDigits("read"); + digitsTree = fLoader[iDet]->TreeD(); + if (!digitsTree) { + AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet])); if (fStopOnError) return kFALSE; } } - if (fRawReader && !reconstructor->HasDigitConversion()) { - reconstructor->FillESD(fRawReader, clustersTree, esd); - } else { - TTree* digitsTree = NULL; - if (fLoader[iDet]) { - fLoader[iDet]->LoadDigits("read"); - digitsTree = fLoader[iDet]->TreeD(); - if (!digitsTree) { - AliError(Form("Can't get the %s digits tree", - fgkDetectorName[iDet])); - if (fStopOnError) return kFALSE; - } - } - reconstructor->FillESD(digitsTree, clustersTree, esd); - if (fLoader[iDet]) fLoader[iDet]->UnloadDigits(); - } - if (fLoader[iDet]) { - fLoader[iDet]->UnloadRecPoints(); - } - - if (fCheckPointLevel > 2) WriteESD(esd, fgkDetectorName[iDet]); + reconstructor->FillESD(digitsTree, clustersTree, esd); + if (fLoader[iDet]) fLoader[iDet]->UnloadDigits(); + } + if (fLoader[iDet]) { + fLoader[iDet]->UnloadRecPoints(); } } @@ -1881,61 +2247,27 @@ Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd) AliInfo("Filling trigger information into the ESD"); - AliCentralTrigger *aCTP = NULL; - if (fRawReader) { AliCTPRawStream input(fRawReader); if (!input.Next()) { - AliError("No valid CTP (trigger) DDL raw data is found ! The trigger information is not stored in the ESD !"); - return kFALSE; - } - esd->SetTriggerMask(input.GetClassMask()); - esd->SetTriggerCluster(input.GetClusterMask()); - - aCTP = new AliCentralTrigger(); - TString configstr(""); - if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB - AliError("No trigger configuration found in OCDB! The trigger classes information will no be stored in ESD!"); - delete aCTP; - return kFALSE; - } - } - else { - AliRunLoader *runloader = AliRunLoader::GetRunLoader(); - if (runloader) { - if (!runloader->LoadTrigger()) { - aCTP = runloader->GetTrigger(); - esd->SetTriggerMask(aCTP->GetClassMask()); - esd->SetTriggerCluster(aCTP->GetClusterMask()); - } - else { - AliWarning("No trigger can be loaded! The trigger information is not stored in the ESD !"); - return kFALSE; - } + AliWarning("No valid CTP (trigger) DDL raw data is found ! The trigger info is taken from the event header!"); } else { - AliError("No run loader is available! The trigger information is not stored in the ESD !"); - return kFALSE; + if (esd->GetTriggerMask() != input.GetClassMask()) + AliError(Form("Invalid trigger pattern found in CTP raw-data: %llx %llx", + input.GetClassMask(),esd->GetTriggerMask())); + if (esd->GetOrbitNumber() != input.GetOrbitID()) + AliError(Form("Invalid orbit id found in CTP raw-data: %x %x", + input.GetOrbitID(),esd->GetOrbitNumber())); + if (esd->GetBunchCrossNumber() != input.GetBCID()) + AliError(Form("Invalid bunch-crossing id found in CTP raw-data: %x %x", + input.GetBCID(),esd->GetBunchCrossNumber())); } - } - - // Now fill the trigger class names into AliESDRun object - AliTriggerConfiguration *config = aCTP->GetConfiguration(); - if (!config) { - AliError("No trigger configuration has been found! The trigger classes information will no be stored in ESD!"); - if (fRawReader) delete aCTP; - return kFALSE; - } - const TObjArray& classesArray = config->GetClasses(); - Int_t nclasses = classesArray.GetEntriesFast(); - for( Int_t j=0; jGetMask()); - esd->SetTriggerClass(trclass->GetName(),trindex); + // Here one has to add the filling of trigger inputs and + // interaction records + // ... } - - if (fRawReader) delete aCTP; return kTRUE; } @@ -1950,23 +2282,16 @@ Bool_t AliReconstruction::FillRawEventHeaderESD(AliESDEvent*& esd) // Filling information from RawReader Header // + if (!fRawReader) return kFALSE; + AliInfo("Filling information from RawReader Header"); - esd->SetBunchCrossNumber(0); - esd->SetOrbitNumber(0); - esd->SetPeriodNumber(0); - esd->SetTimeStamp(0); - esd->SetEventType(0); - const AliRawEventHeaderBase * eventHeader = fRawReader->GetEventHeader(); - if (eventHeader){ - const UInt_t *id = eventHeader->GetP("Id"); - esd->SetBunchCrossNumber((id)[1]&0x00000fff); - esd->SetOrbitNumber((((id)[0]<<20)&0xf00000)|(((id)[1]>>12)&0xfffff)); - esd->SetPeriodNumber(((id)[0]>>4)&0x0fffffff); + esd->SetBunchCrossNumber(fRawReader->GetBCID()); + esd->SetOrbitNumber(fRawReader->GetOrbitID()); + esd->SetPeriodNumber(fRawReader->GetPeriod()); - esd->SetTimeStamp((eventHeader->Get("Timestamp"))); - esd->SetEventType((eventHeader->Get("Type"))); - } + esd->SetTimeStamp(fRawReader->GetTimestamp()); + esd->SetEventType(fRawReader->GetType()); return kTRUE; } @@ -2028,19 +2353,9 @@ Bool_t AliReconstruction::InitRunLoader() CleanUp(); return kFALSE; } + fRunLoader->CdGAFile(); - if (gFile->GetKey(AliRunLoader::GetGAliceName())) { - if (fRunLoader->LoadgAlice() == 0) { - gAlice = fRunLoader->GetAliRun(); - AliTracker::SetFieldMap(gAlice->Field(),fUniformField); - } - } - if (!gAlice && !fRawReader) { - AliError(Form("no gAlice object found in file %s", - fGAliceFileName.Data())); - CleanUp(); - return kFALSE; - } + fRunLoader->LoadgAlice(); //PH This is a temporary fix to give access to the kinematics //PH that is needed for the labels of ITS clusters @@ -2050,8 +2365,6 @@ Bool_t AliReconstruction::InitRunLoader() } else { // galice.root does not exist if (!fRawReader) { AliError(Form("the file %s does not exist", fGAliceFileName.Data())); - CleanUp(); - return kFALSE; } fRunLoader = AliRunLoader::Open(fGAliceFileName.Data(), AliConfig::GetDefaultEventFolderName(), @@ -2079,13 +2392,20 @@ AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet) { // get the reconstructor object and the loader for a detector - if (fReconstructor[iDet]) return fReconstructor[iDet]; + if (fReconstructor[iDet]) { + if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) { + const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet); + fReconstructor[iDet]->SetRecoParam(par); + } + return fReconstructor[iDet]; + } // load the reconstructor object TPluginManager* pluginManager = gROOT->GetPluginManager(); TString detName = fgkDetectorName[iDet]; TString recName = "Ali" + detName + "Reconstructor"; - if (gAlice && !gAlice->GetDetector(detName) && (detName != "HLT")) return NULL; + + if (!fIsNewRunLoader && !fRunLoader->GetLoader(detName+"Loader") && (detName != "HLT")) return NULL; AliReconstructor* reconstructor = NULL; // first check if a plugin is defined for the reconstructor @@ -2154,6 +2474,10 @@ AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet) } } + if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) { + const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet); + reconstructor->SetRecoParam(par); + } return reconstructor; } @@ -2208,7 +2532,7 @@ Bool_t AliReconstruction::CreateTrackers(const TString& detectors) } //_____________________________________________________________________________ -void AliReconstruction::CleanUp(TFile* file, TFile* fileOld) +void AliReconstruction::CleanUp() { // delete trackers and the run loader and close and delete the file @@ -2218,122 +2542,59 @@ void AliReconstruction::CleanUp(TFile* file, TFile* fileOld) fLoader[iDet] = NULL; delete fTracker[iDet]; fTracker[iDet] = NULL; -// delete fQADataMaker[iDet]; -// fQADataMaker[iDet] = NULL; } + delete fRunInfo; + fRunInfo = NULL; + delete fVertexer; fVertexer = NULL; - if (ftVertexer) delete ftVertexer; + delete ftVertexer; ftVertexer = NULL; if(!(AliCDBManager::Instance()->GetCacheFlag())) { - delete fDiamondProfile; - fDiamondProfile = NULL; - delete fDiamondProfileTPC; - fDiamondProfileTPC = NULL; - delete fGRPList; - fGRPList = NULL; + delete fDiamondProfile; + fDiamondProfile = NULL; + delete fDiamondProfileTPC; + fDiamondProfileTPC = NULL; } - + delete fGRPData; + fGRPData = NULL; delete fRunLoader; fRunLoader = NULL; delete fRawReader; fRawReader = NULL; - if (fParentRawReader) delete fParentRawReader; + delete fParentRawReader; fParentRawReader=NULL; - if (file) { - file->Close(); - delete file; - } - - if (fileOld) { - fileOld->Close(); - delete fileOld; - gSystem->Unlink("AliESDs.old.root"); - } - -} - -//_____________________________________________________________________________ - -Bool_t AliReconstruction::ReadESD(AliESDEvent*& esd, const char* recStep) const -{ -// read the ESD event from a file - - if (!esd) return kFALSE; - char fileName[256]; - sprintf(fileName, "ESD_%d.%d_%s.root", - esd->GetRunNumber(), esd->GetEventNumberInFile(), recStep); - if (gSystem->AccessPathName(fileName)) return kFALSE; - - AliInfo(Form("reading ESD from file %s", fileName)); - AliDebug(1, Form("reading ESD from file %s", fileName)); - TFile* file = TFile::Open(fileName); - if (!file || !file->IsOpen()) { - AliError(Form("opening %s failed", fileName)); - delete file; - return kFALSE; - } - - gROOT->cd(); - delete esd; - esd = (AliESDEvent*) file->Get("ESD"); - file->Close(); - delete file; - return kTRUE; - -} - - - -//_____________________________________________________________________________ -void AliReconstruction::WriteESD(AliESDEvent* esd, const char* recStep) const -{ -// write the ESD event to a file - - if (!esd) return; - char fileName[256]; - sprintf(fileName, "ESD_%d.%d_%s.root", - esd->GetRunNumber(), esd->GetEventNumberInFile(), recStep); - - AliDebug(1, Form("writing ESD to file %s", fileName)); - TFile* file = TFile::Open(fileName, "recreate"); - if (!file || !file->IsOpen()) { - AliError(Form("opening %s failed", fileName)); - } else { - esd->Write("ESD"); - file->Close(); + if (ffile) { + ffile->Close(); + delete ffile; + ffile = NULL; } - delete file; } - void AliReconstruction::WriteAlignmentData(AliESDEvent* esd) { // Write space-points which are then used in the alignment procedures - // For the moment only ITS, TRD and TPC + // For the moment only ITS, TPC, TRD and TOF - // Load TOF clusters - if (fTracker[3]){ - fLoader[3]->LoadRecPoints("read"); - TTree* tree = fLoader[3]->TreeR(); - if (!tree) { - AliError(Form("Can't get the %s cluster tree", fgkDetectorName[3])); - return; - } - fTracker[3]->LoadClusters(tree); - } Int_t ntracks = esd->GetNumberOfTracks(); for (Int_t itrack = 0; itrack < ntracks; itrack++) { AliESDtrack *track = esd->GetTrack(itrack); Int_t nsp = 0; Int_t idx[200]; - for (Int_t iDet = 3; iDet >= 0; iDet--) - nsp += track->GetNcls(iDet); + for (Int_t iDet = 3; iDet >= 0; iDet--) {// TOF, TRD, TPC, ITS clusters + nsp += track->GetNcls(iDet); + + if (iDet==0) { // ITS "extra" clusters + track->GetClusters(iDet,idx); + for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nsp++; + } + } + if (nsp) { AliTrackPointArray *sp = new AliTrackPointArray(nsp); track->SetTrackPointArray(sp); @@ -2341,36 +2602,37 @@ void AliReconstruction::WriteAlignmentData(AliESDEvent* esd) for (Int_t iDet = 3; iDet >= 0; iDet--) { AliTracker *tracker = fTracker[iDet]; if (!tracker) continue; - Int_t nspdet = track->GetNcls(iDet); + Int_t nspdet = track->GetClusters(iDet,idx); + + if (iDet==0) // ITS "extra" clusters + for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nspdet++; + if (nspdet <= 0) continue; - track->GetClusters(iDet,idx); AliTrackPoint p; Int_t isp = 0; Int_t isp2 = 0; while (isp2 < nspdet) { - Bool_t isvalid; + Bool_t isvalid=kTRUE; + + Int_t index=idx[isp++]; + if (index < 0) continue; + TString dets = fgkDetectorName[iDet]; if ((fUseTrackingErrorsForAlignment.CompareTo(dets) == 0) || fUseTrackingErrorsForAlignment.BeginsWith(dets+" ") || fUseTrackingErrorsForAlignment.EndsWith(" "+dets) || fUseTrackingErrorsForAlignment.Contains(" "+dets+" ")) { - isvalid = tracker->GetTrackPointTrackingError(idx[isp2],p,track); + isvalid = tracker->GetTrackPointTrackingError(index,p,track); } else { - isvalid = tracker->GetTrackPoint(idx[isp2],p); + isvalid = tracker->GetTrackPoint(index,p); } isp2++; - const Int_t kNTPCmax = 159; - if (iDet==1 && isp2>kNTPCmax) break; // to be fixed if (!isvalid) continue; - sp->AddPoint(isptrack,&p); isptrack++; isp++; + sp->AddPoint(isptrack,&p); isptrack++; } } } } - if (fTracker[3]){ - fTracker[3]->UnloadClusters(); - fLoader[3]->UnloadRecPoints(); - } } //_____________________________________________________________________________ @@ -2395,7 +2657,7 @@ void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd) } -TNamed* AliReconstruction::CopyFileToTNamed(TString fPath,TString fName){ +TNamed* AliReconstruction::CopyFileToTNamed(TString fPath,TString pName){ // Dump a file content into a char in TNamed ifstream in; in.open(fPath.Data(),ios::in | ios::binary|ios::ate); @@ -2408,9 +2670,9 @@ TNamed* AliReconstruction::CopyFileToTNamed(TString fPath,TString fName){ in.read (memblock, kBytes); in.close(); TString fData(memblock,kBytes); - fn = new TNamed(fName,fData); + fn = new TNamed(pName,fData); printf("fData Size: %d \n",fData.Sizeof()); - printf("fName Size: %d \n",fName.Sizeof()); + printf("pName Size: %d \n",pName.Sizeof()); printf("fn Size: %d \n",fn->Sizeof()); delete[] memblock; } @@ -2421,105 +2683,26 @@ TNamed* AliReconstruction::CopyFileToTNamed(TString fPath,TString fName){ return fn; } -void AliReconstruction::TNamedToFile(TTree* fTree, TString fName){ +void AliReconstruction::TNamedToFile(TTree* fTree, TString pName){ // This is not really needed in AliReconstruction at the moment // but can serve as a template TList *fList = fTree->GetUserInfo(); - TNamed *fn = (TNamed*)fList->FindObject(fName.Data()); + TNamed *fn = (TNamed*)fList->FindObject(pName.Data()); printf("fn Size: %d \n",fn->Sizeof()); - TString fTmp(fn->GetName()); // to be 100% sure in principle fName also works + TString fTmp(fn->GetName()); // to be 100% sure in principle pName also works const char* cdata = fn->GetTitle(); printf("fTmp Size %d\n",fTmp.Sizeof()); int size = fn->Sizeof()-fTmp.Sizeof()-sizeof(UChar_t)-sizeof(Int_t); // see dfinition of TString::SizeOf()... printf("calculated size %d\n",size); - ofstream out(fName.Data(),ios::out | ios::binary); + ofstream out(pName.Data(),ios::out | ios::binary); out.write(cdata,size); out.close(); } -//_____________________________________________________________________________ -AliQADataMakerRec * AliReconstruction::GetQADataMaker(Int_t iDet) -{ - // get the quality assurance data maker object and the loader for a detector - - if (fQADataMaker[iDet]) - return fQADataMaker[iDet]; - - AliQADataMakerRec * qadm = NULL; - if (iDet == fgkNDetectors) { //Global QA - qadm = new AliGlobalQADataMaker(); - fQADataMaker[iDet] = qadm; - return qadm; - } - - // load the QA data maker object - TPluginManager* pluginManager = gROOT->GetPluginManager(); - TString detName = fgkDetectorName[iDet]; - TString qadmName = "Ali" + detName + "QADataMakerRec"; - if (gAlice && !gAlice->GetDetector(detName) && (detName != "HLT")) - return NULL; - - // first check if a plugin is defined for the quality assurance data maker - TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQADataMakerRec", detName); - // if not, add a plugin for it - if (!pluginHandler) { - AliDebug(1, Form("defining plugin for %s", qadmName.Data())); - TString libs = gSystem->GetLibraries(); - if (libs.Contains("lib" + detName + "base.so") || - (gSystem->Load("lib" + detName + "base.so") >= 0)) { - pluginManager->AddHandler("AliQADataMakerRec", detName, - qadmName, detName + "qadm", qadmName + "()"); - } else { - pluginManager->AddHandler("AliQADataMakerRec", detName, - qadmName, detName, qadmName + "()"); - } - pluginHandler = pluginManager->FindHandler("AliQADataMakerRec", detName); - } - if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) { - qadm = (AliQADataMakerRec *) pluginHandler->ExecPlugin(0); - } - - fQADataMaker[iDet] = qadm; - - return qadm; -} - -//_____________________________________________________________________________ -Bool_t AliReconstruction::RunQA(const char* detectors, AliESDEvent *& esd) -{ - // run the Quality Assurance data producer - - AliCodeTimerAuto("") - TString detStr = detectors; - for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { - if (!IsSelected(fgkDetectorName[iDet], detStr)) - continue; - AliQADataMakerRec * qadm = GetQADataMaker(iDet); - if (!qadm) - continue; - AliCodeTimerStart(Form("running quality assurance data maker for %s", fgkDetectorName[iDet])); - AliInfo(Form("running quality assurance data maker for %s", fgkDetectorName[iDet])); - - qadm->Exec(AliQA::kESDS, esd) ; - qadm->Increment() ; - - AliCodeTimerStop(Form("running quality assurance data maker for %s", fgkDetectorName[iDet])); - } - if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) { - AliError(Form("the following detectors were not found: %s", - detStr.Data())); - if (fStopOnError) - return kFALSE; - } - - return kTRUE; - -} - //_____________________________________________________________________________ void AliReconstruction::CheckQA() { @@ -2573,27 +2756,30 @@ Int_t AliReconstruction::GetDetIndex(const char* detector) Bool_t AliReconstruction::FinishPlaneEff() { // // Here execute all the necessary operationis, at the end of the tracking phase, - // in case that evaluation of PlaneEfficiencies was required for some detector. - // E.g., write into a DataBase file the PlaneEfficiency which have been evaluated. + // in case that evaluation of PlaneEfficiencies was required for some detector. + // E.g., write into a DataBase file the PlaneEfficiency which have been evaluated. // // This Preliminary version works only FOR ITS !!!!! // other detectors (TOF,TRD, etc. have to develop their specific codes) // // Input: none - // Return: kTRUE if all operations have been done properly, kFALSE otherwise + // Return: kTRUE if all operations have been done properly, kFALSE otherwise // Bool_t ret=kFALSE; //for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { - for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS + for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS //if (!IsSelected(fgkDetectorName[iDet], detStr)) continue; if(fTracker[iDet]) { - AliPlaneEff *planeeff=fTracker[iDet]->GetPlaneEff(); - ret=planeeff->WriteIntoCDB(); + AliPlaneEff *planeeff=fTracker[iDet]->GetPlaneEff(); + TString name=planeeff->GetName(); + name+=".root"; + TFile* pefile = TFile::Open(name, "RECREATE"); + ret=(Bool_t)planeeff->Write(); + pefile->Close(); if(planeeff->GetCreateHistos()) { - TString name="PlaneEffHisto"; - name+=fgkDetectorName[iDet]; - name+=".root"; - ret*=planeeff->WriteHistosToFile(name,"RECREATE"); + TString hname=planeeff->GetName(); + hname+="Histo.root"; + ret*=planeeff->WriteHistosToFile(hname,"RECREATE"); } } } @@ -2616,3 +2802,304 @@ Bool_t AliReconstruction::InitPlaneEff() { AliWarning(Form("Implementation of this method not yet done !! Method return kTRUE")); return kTRUE; } + +//_____________________________________________________________________________ +Bool_t AliReconstruction::InitAliEVE() +{ + // This method should be called only in case + // AliReconstruction is run + // within the alieve environment. + // It will initialize AliEVE in a way + // so that it can visualize event processed + // by AliReconstruction. + // The return flag shows whenever the + // AliEVE initialization was successful or not. + + TString macroStr; + macroStr.Form("%s/EVE/macros/alieve_online.C",gSystem->ExpandPathName("$ALICE_ROOT")); + AliInfo(Form("Loading AliEVE macro: %s",macroStr.Data())); + if (gROOT->LoadMacro(macroStr.Data()) != 0) return kFALSE; + + gROOT->ProcessLine("if (!gAliEveEvent) {gAliEveEvent = new AliEveEventManager();gAliEveEvent->SetAutoLoad(kTRUE);gAliEveEvent->AddNewEventCommand(\"alieve_online_on_new_event()\");gEve->AddEvent(gAliEveEvent);};"); + gROOT->ProcessLine("alieve_online_init()"); + + return kTRUE; +} + +//_____________________________________________________________________________ +void AliReconstruction::RunAliEVE() +{ + // Runs AliEVE visualisation of + // the current event. + // Should be executed only after + // successful initialization of AliEVE. + + AliInfo("Running AliEVE..."); + gROOT->ProcessLine(Form("gAliEveEvent->SetEvent((AliRunLoader*)%p,(AliRawReader*)%p,(AliESDEvent*)%p);",fRunLoader,fRawReader,fesd)); + gROOT->ProcessLine("gAliEveEvent->StartStopAutoLoadTimer();"); + gSystem->Run(); +} + +//_____________________________________________________________________________ +Bool_t AliReconstruction::SetRunQA(TString detAndAction) +{ + // Allows to run QA for a selected set of detectors + // and a selected set of tasks among RAWS, RECPOINTS and ESDS + // all selected detectors run the same selected tasks + + if (!detAndAction.Contains(":")) { + AliError( Form("%s is a wrong syntax, use \"DetectorList:ActionList\" \n", detAndAction.Data()) ) ; + fRunQA = kFALSE ; + return kFALSE ; + } + Int_t colon = detAndAction.Index(":") ; + fQADetectors = detAndAction(0, colon) ; + if (fQADetectors.Contains("ALL") ) + fQADetectors = fFillESD ; + fQATasks = detAndAction(colon+1, detAndAction.Sizeof() ) ; + if (fQATasks.Contains("ALL") ) { + fQATasks = Form("%d %d %d", AliQA::kRAWS, AliQA::kRECPOINTS, AliQA::kESDS) ; + } else { + fQATasks.ToUpper() ; + TString tempo("") ; + if ( fQATasks.Contains("RAW") ) + tempo = Form("%d ", AliQA::kRAWS) ; + if ( fQATasks.Contains("RECPOINT") ) + tempo += Form("%d ", AliQA::kRECPOINTS) ; + if ( fQATasks.Contains("ESD") ) + tempo += Form("%d ", AliQA::kESDS) ; + fQATasks = tempo ; + if (fQATasks.IsNull()) { + AliInfo("No QA requested\n") ; + fRunQA = kFALSE ; + return kTRUE ; + } + } + TString tempo(fQATasks) ; + tempo.ReplaceAll(Form("%d", AliQA::kRAWS), AliQA::GetTaskName(AliQA::kRAWS)) ; + tempo.ReplaceAll(Form("%d", AliQA::kRECPOINTS), AliQA::GetTaskName(AliQA::kRECPOINTS)) ; + tempo.ReplaceAll(Form("%d", AliQA::kESDS), AliQA::GetTaskName(AliQA::kESDS)) ; + AliInfo( Form("QA will be done on \"%s\" for \"%s\"\n", fQADetectors.Data(), tempo.Data()) ) ; + fRunQA = kTRUE ; + return kTRUE; +} + +//_____________________________________________________________________________ +Bool_t AliReconstruction::InitRecoParams() +{ + // The method accesses OCDB and retrieves all + // the available reco-param objects from there. + + Bool_t isOK = kTRUE; + + TString detStr = fLoadCDB; + for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { + + if (!IsSelected(fgkDetectorName[iDet], detStr)) continue; + + if (fRecoParam.GetDetRecoParamArray(iDet)) { + AliInfo(Form("Using custom reconstruction parameters for detector %s",fgkDetectorName[iDet])); + continue; + } + + AliInfo(Form("Loading reconstruction parameter objects for detector %s",fgkDetectorName[iDet])); + + AliCDBPath path(fgkDetectorName[iDet],"Calib","RecoParam"); + AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath()); + if(!entry){ + AliWarning(Form("Couldn't find RecoParam entry in OCDB for detector %s",fgkDetectorName[iDet])); + isOK = kFALSE; + } + else { + TObject *recoParamObj = entry->GetObject(); + if (dynamic_cast(recoParamObj)) { + // The detector has a normal TobjArray of AliDetectorRecoParam objects + // Registering them in AliRecoParam + fRecoParam.AddDetRecoParamArray(iDet,dynamic_cast(recoParamObj)); + } + else if (dynamic_cast(recoParamObj)) { + // The detector has only onse set of reco parameters + // Registering it in AliRecoParam + AliInfo(Form("Single set of reconstruction parameters found for detector %s",fgkDetectorName[iDet])); + dynamic_cast(recoParamObj)->SetAsDefault(); + fRecoParam.AddDetRecoParam(iDet,dynamic_cast(recoParamObj)); + } + else { + AliError(Form("No valid RecoParam object found in the OCDB for detector %s",fgkDetectorName[iDet])); + isOK = kFALSE; + } + entry->SetOwner(0); + AliCDBManager::Instance()->UnloadFromCache(path.GetPath()); + } + } + + if (AliDebugLevel() > 0) fRecoParam.Print(); + + return isOK; +} + +//_____________________________________________________________________________ +Bool_t AliReconstruction::GetEventInfo() +{ + // Fill the event info object + // ... + AliCodeTimerAuto("") + + AliCentralTrigger *aCTP = NULL; + if (fRawReader) { + fEventInfo.SetEventType(fRawReader->GetType()); + + ULong64_t mask = fRawReader->GetClassMask(); + fEventInfo.SetTriggerMask(mask); + UInt_t clmask = fRawReader->GetDetectorPattern()[0]; + fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(clmask)); + + aCTP = new AliCentralTrigger(); + TString configstr(""); + if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB + AliError("No trigger configuration found in OCDB! The trigger configuration information will not be used!"); + delete aCTP; + return kFALSE; + } + aCTP->SetClassMask(mask); + aCTP->SetClusterMask(clmask); + } + else { + fEventInfo.SetEventType(AliRawEventHeaderBase::kPhysicsEvent); + + if (fRunLoader && (!fRunLoader->LoadTrigger())) { + aCTP = fRunLoader->GetTrigger(); + fEventInfo.SetTriggerMask(aCTP->GetClassMask()); + fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(aCTP->GetClusterMask())); + } + else { + AliWarning("No trigger can be loaded! The trigger information will not be used!"); + return kFALSE; + } + } + + AliTriggerConfiguration *config = aCTP->GetConfiguration(); + if (!config) { + AliError("No trigger configuration has been found! The trigger configuration information will not be used!"); + if (fRawReader) delete aCTP; + return kFALSE; + } + + UChar_t clustmask = 0; + TString trclasses; + ULong64_t trmask = fEventInfo.GetTriggerMask(); + const TObjArray& classesArray = config->GetClasses(); + Int_t nclasses = classesArray.GetEntriesFast(); + for( Int_t iclass=0; iclass < nclasses; iclass++ ) { + AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At(iclass); + if (trclass) { + Int_t trindex = (Int_t)TMath::Log2(trclass->GetMask()); + fesd->SetTriggerClass(trclass->GetName(),trindex); + if (trmask & (1 << trindex)) { + trclasses += " "; + trclasses += trclass->GetName(); + trclasses += " "; + clustmask |= trclass->GetCluster()->GetClusterMask(); + } + } + } + fEventInfo.SetTriggerClasses(trclasses); + + // Set the information in ESD + fesd->SetTriggerMask(trmask); + fesd->SetTriggerCluster(clustmask); + + if (!aCTP->CheckTriggeredDetectors()) { + if (fRawReader) delete aCTP; + return kFALSE; + } + + if (fRawReader) delete aCTP; + + // We have to fill also the HLT decision here!! + // ... + + return kTRUE; +} + +const char *AliReconstruction::MatchDetectorList(const char *detectorList, UInt_t detectorMask) +{ + // Match the detector list found in the rec.C or the default 'ALL' + // to the list found in the GRP (stored there by the shuttle PP which + // gets the information from ECS) + static TString resultList; + TString detList = detectorList; + + resultList = ""; + + for(Int_t iDet = 0; iDet < (AliDAQ::kNDetectors-1); iDet++) { + if ((detectorMask >> iDet) & 0x1) { + TString det = AliDAQ::OfflineModuleName(iDet); + if ((detList.CompareTo("ALL") == 0) || + detList.BeginsWith("ALL ") || + detList.EndsWith(" ALL") || + detList.Contains(" ALL ") || + (detList.CompareTo(det) == 0) || + detList.BeginsWith(det) || + detList.EndsWith(det) || + detList.Contains( " "+det+" " )) { + if (!resultList.EndsWith(det + " ")) { + resultList += det; + resultList += " "; + } + } + } + } + + // HLT + if ((detectorMask >> AliDAQ::kHLTId) & 0x1) { + TString hltDet = AliDAQ::OfflineModuleName(AliDAQ::kNDetectors-1); + if ((detList.CompareTo("ALL") == 0) || + detList.BeginsWith("ALL ") || + detList.EndsWith(" ALL") || + detList.Contains(" ALL ") || + (detList.CompareTo(hltDet) == 0) || + detList.BeginsWith(hltDet) || + detList.EndsWith(hltDet) || + detList.Contains( " "+hltDet+" " )) { + resultList += hltDet; + } + } + + return resultList.Data(); + +} + +//______________________________________________________________________________ +void AliReconstruction::Abort(const char *method, EAbort what) +{ + // Abort processing. If what = kAbortProcess, the Process() loop will be + // aborted. If what = kAbortFile, the current file in a chain will be + // aborted and the processing will continue with the next file, if there + // is no next file then Process() will be aborted. Abort() can also be + // called from Begin(), SlaveBegin(), Init() and Notify(). After abort + // the SlaveTerminate() and Terminate() are always called. The abort flag + // can be checked in these methods using GetAbort(). + // + // The method is overwritten in AliReconstruction for better handling of + // reco specific errors + + if (!fStopOnError) return; + + CleanUp(); + + TString whyMess = method; + whyMess += " failed! Aborting..."; + + AliError(whyMess.Data()); + + fAbort = what; + TString mess = "Abort"; + if (fAbort == kAbortProcess) + mess = "AbortProcess"; + else if (fAbort == kAbortFile) + mess = "AbortFile"; + + Info(mess, whyMess.Data()); +} +