X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=STEER%2FAliReconstruction.cxx;h=05fdd24e32820cc025fd91284e679501c1602160;hb=30cd6a86dcdd3c1f195019d83b1ab55fa0e52281;hp=a500963303fe2d19930577d934c821bd3ea6dfb7;hpb=ca13fb87ed1a96d8d699bf29ffe05d4e1101185e;p=u%2Fmrichter%2FAliRoot.git diff --git a/STEER/AliReconstruction.cxx b/STEER/AliReconstruction.cxx index a500963303f..05fdd24e328 100644 --- a/STEER/AliReconstruction.cxx +++ b/STEER/AliReconstruction.cxx @@ -105,110 +105,96 @@ // 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. // // // /////////////////////////////////////////////////////////////////////////////// +#include #include +#include +#include #include -#include -#include -#include -#include +#include #include +#include #include -#include -#include -#include #include +#include +#include +#include +#include +#include +#include +#include +#include -#include "AliReconstruction.h" +#include "AliAlignObj.h" +#include "AliCDBEntry.h" +#include "AliCDBManager.h" +#include "AliCDBStorage.h" +#include "AliCTPRawStream.h" +#include "AliCascadeVertexer.h" +#include "AliCentralTrigger.h" #include "AliCodeTimer.h" -#include "AliReconstructor.h" -#include "AliLog.h" -#include "AliRunLoader.h" -#include "AliRun.h" -#include "AliRawReaderFile.h" -#include "AliRawReaderDate.h" -#include "AliRawReaderRoot.h" -#include "AliRawEventHeaderBase.h" +#include "AliDAQ.h" +#include "AliDetectorRecoParam.h" +#include "AliESDCaloCells.h" +#include "AliESDCaloCluster.h" #include "AliESDEvent.h" #include "AliESDMuonTrack.h" -#include "AliESDfriend.h" +#include "AliESDPmdTrack.h" +#include "AliESDTagCreator.h" #include "AliESDVertex.h" #include "AliESDcascade.h" +#include "AliESDfriend.h" #include "AliESDkink.h" -#include "AliESDtrack.h" -#include "AliESDCaloCluster.h" -#include "AliESDCaloCells.h" -#include "AliMultiplicity.h" -#include "AliTracker.h" -#include "AliVertexer.h" -#include "AliVertexerTracks.h" -#include "AliV0vertexer.h" -#include "AliCascadeVertexer.h" -#include "AliHeader.h" -#include "AliGenEventHeader.h" -#include "AliPID.h" #include "AliESDpid.h" #include "AliESDtrack.h" -#include "AliESDPmdTrack.h" - -#include "AliESDTagCreator.h" -#include "AliAODTagCreator.h" - +#include "AliESDtrack.h" +#include "AliEventInfo.h" +#include "AliGRPObject.h" +#include "AliGRPRecoParam.h" +#include "AliGenEventHeader.h" #include "AliGeomManager.h" -#include "AliTrackPointArray.h" -#include "AliCDBManager.h" -#include "AliCDBStorage.h" -#include "AliCDBEntry.h" -#include "AliAlignObj.h" - -#include "AliCentralTrigger.h" -#include "AliTriggerConfiguration.h" -#include "AliTriggerClass.h" -#include "AliCTPRawStream.h" - -#include "AliQADataMakerRec.h" #include "AliGlobalQADataMaker.h" +#include "AliHeader.h" +#include "AliLog.h" +#include "AliMagF.h" +#include "AliMultiplicity.h" +#include "AliPID.h" +#include "AliPlaneEff.h" #include "AliQA.h" +#include "AliQADataMakerRec.h" #include "AliQADataMakerSteer.h" - -#include "AliPlaneEff.h" - -#include "AliSysInfo.h" // memory snapshots +#include "AliRawEvent.h" +#include "AliRawEventHeaderBase.h" #include "AliRawHLTManager.h" - -#include "AliMagWrapCheb.h" - -#include "AliDetectorRecoParam.h" +#include "AliRawReaderDate.h" +#include "AliRawReaderFile.h" +#include "AliRawReaderRoot.h" +#include "AliReconstruction.h" +#include "AliReconstructor.h" +#include "AliRun.h" #include "AliRunInfo.h" -#include "AliEventInfo.h" - -#include "AliDAQ.h" +#include "AliRunLoader.h" +#include "AliSysInfo.h" // memory snapshots +#include "AliTrackPointArray.h" +#include "AliTracker.h" +#include "AliTriggerClass.h" +#include "AliTriggerCluster.h" +#include "AliTriggerConfiguration.h" +#include "AliV0vertexer.h" +#include "AliVertexer.h" +#include "AliVertexerTracks.h" ClassImp(AliReconstruction) - //_____________________________________________________________________________ -const char* AliReconstruction::fgkDetectorName[AliReconstruction::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"}; +const char* AliReconstruction::fgkDetectorName[AliReconstruction::kNDetectors] = {"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), - +AliReconstruction::AliReconstruction(const char* gAliceFilename) : + TSelector(), fUniformField(kFALSE), - fForcedFieldMap(0x0), fRunVertexFinder(kTRUE), fRunVertexFinderTracks(kTRUE), fRunHLTTracking(kFALSE), @@ -218,7 +204,6 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename, fStopOnError(kFALSE), fWriteAlignmentData(kFALSE), fWriteESDfriend(kFALSE), - fWriteAOD(kFALSE), fFillTriggerESD(kTRUE), fCleanESD(kTRUE), @@ -230,18 +215,17 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename, fRunLocalReconstruction("ALL"), fRunTracking("ALL"), fFillESD("ALL"), + fLoadCDB(""), fUseTrackingErrorsForAlignment(""), fGAliceFileName(gAliceFilename), - fInput(""), + fRawInput(""), fEquipIdMap(""), fFirstEvent(0), fLastEvent(-1), - fNumberOfEventsPerFile(1), - fCheckPointLevel(0), + fNumberOfEventsPerFile((UInt_t)-1), fOptions(), fLoadAlignFromCDB(kTRUE), fLoadAlignData("ALL"), - fESDPar(""), fUseHLTData(), fRunInfo(NULL), fEventInfo(), @@ -252,11 +236,10 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename, fRecoParam(), - fVertexer(NULL), + fDiamondProfileSPD(NULL), fDiamondProfile(NULL), fDiamondProfileTPC(NULL), - fMeanVertexConstraint(kTRUE), - + fGRPData(NULL), fAlignObjArray(NULL), @@ -269,7 +252,6 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename, fQATasks("ALL"), fRunQA(kTRUE), fRunGlobalQA(kTRUE), - fInLoopQA(kFALSE), fSameQACycle(kFALSE), fRunPlaneEff(kFALSE), @@ -280,31 +262,31 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename, ffile(NULL), ftree(NULL), fhlttree(NULL), - ffileOld(NULL), - ftreeOld(NULL), - fhlttreeOld(NULL), ftVertexer(NULL), fIsNewRunLoader(kFALSE), - fRunAliEVE(kFALSE) + fRunAliEVE(kFALSE), + fChain(NULL) { // create reconstruction object with default parameters + gGeoManager = NULL; - for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { + for (Int_t iDet = 0; iDet < kNDetectors; iDet++) { fReconstructor[iDet] = NULL; fLoader[iDet] = NULL; fTracker[iDet] = NULL; - fQACycles[iDet] = 999999; } - fQASteer = new AliQADataMakerSteer("rec") ; + for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) { + fQACycles[iDet] = 999999 ; + fQAWriteExpert[iDet] = kFALSE ; + } + AliPID pid; } //_____________________________________________________________________________ AliReconstruction::AliReconstruction(const AliReconstruction& rec) : - TNamed(rec), - + TSelector(), fUniformField(rec.fUniformField), - fForcedFieldMap(0x0), fRunVertexFinder(rec.fRunVertexFinder), fRunVertexFinderTracks(rec.fRunVertexFinderTracks), fRunHLTTracking(rec.fRunHLTTracking), @@ -314,7 +296,6 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) : fStopOnError(rec.fStopOnError), fWriteAlignmentData(rec.fWriteAlignmentData), fWriteESDfriend(rec.fWriteESDfriend), - fWriteAOD(rec.fWriteAOD), fFillTriggerESD(rec.fFillTriggerESD), fCleanESD(rec.fCleanESD), @@ -326,18 +307,17 @@ 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), + 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(), @@ -346,13 +326,12 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) : fRawReader(NULL), fParentRawReader(NULL), - fRecoParam(), - - fVertexer(NULL), - fDiamondProfile(NULL), - fDiamondProfileTPC(NULL), - fMeanVertexConstraint(rec.fMeanVertexConstraint), + fRecoParam(rec.fRecoParam), + fDiamondProfileSPD(rec.fDiamondProfileSPD), + fDiamondProfile(rec.fDiamondProfile), + fDiamondProfileTPC(rec.fDiamondProfileTPC), + fGRPData(NULL), fAlignObjArray(rec.fAlignObjArray), @@ -361,11 +340,10 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) : fInitCDBCalled(rec.fInitCDBCalled), fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled), fQADetectors(rec.fQADetectors), - fQASteer(rec.fQASteer), + fQASteer(NULL), fQATasks(rec.fQATasks), fRunQA(rec.fRunQA), fRunGlobalQA(rec.fRunGlobalQA), - fInLoopQA(rec.fInLoopQA), fSameQACycle(rec.fSameQACycle), fRunPlaneEff(rec.fRunPlaneEff), @@ -375,38 +353,140 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) : ffile(NULL), ftree(NULL), fhlttree(NULL), - ffileOld(NULL), - ftreeOld(NULL), - fhlttreeOld(NULL), ftVertexer(NULL), fIsNewRunLoader(rec.fIsNewRunLoader), - fRunAliEVE(kFALSE) + fRunAliEVE(kFALSE), + fChain(NULL) { // copy constructor for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) { if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone()); } - for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { + for (Int_t iDet = 0; iDet < kNDetectors; iDet++) { fReconstructor[iDet] = NULL; fLoader[iDet] = NULL; fTracker[iDet] = NULL; - fQACycles[iDet] = rec.fQACycles[iDet]; + } + + for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) { + fQACycles[iDet] = rec.fQACycles[iDet]; + fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ; } + for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) { if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone()); } - - fForcedFieldMap=new AliMagWrapCheb(*((AliMagWrapCheb*)rec.fForcedFieldMap)); } //_____________________________________________________________________________ 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; + 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; + 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 < kNDetectors; iDet++) { + delete fReconstructor[iDet]; fReconstructor[iDet] = NULL; + delete fLoader[iDet]; fLoader[iDet] = NULL; + delete fTracker[iDet]; fTracker[iDet] = NULL; + } + + for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) { + fQACycles[iDet] = rec.fQACycles[iDet]; + fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ; + } + + delete fDiamondProfileSPD; fDiamondProfileSPD = NULL; + if (rec.fDiamondProfileSPD) fDiamondProfileSPD = new AliESDVertex(*rec.fDiamondProfileSPD); + delete fDiamondProfile; fDiamondProfile = NULL; + if (rec.fDiamondProfile) fDiamondProfile = new AliESDVertex(*rec.fDiamondProfile); + delete fDiamondProfileTPC; fDiamondProfileTPC = NULL; + if (rec.fDiamondProfileTPC) fDiamondProfileTPC = new AliESDVertex(*rec.fDiamondProfileTPC); + + delete fGRPData; fGRPData = NULL; + // if (rec.fGRPData) fGRPData = (TMap*)((rec.fGRPData)->Clone()); + if (rec.fGRPData) fGRPData = (AliGRPObject*)((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; + 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; } @@ -416,10 +496,14 @@ AliReconstruction::~AliReconstruction() // clean up CleanUp(); + delete fGRPData; fOptions.Delete(); + if (fAlignObjArray) { + fAlignObjArray->Delete(); + delete fAlignObjArray; + } fSpecCDBUri.Delete(); - delete fForcedFieldMap; - delete fQASteer ; + delete fQASteer; AliCodeTimer::Instance()->Print(); } @@ -429,6 +513,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; @@ -468,7 +553,7 @@ void AliReconstruction::InitCDB() AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"); man->SetSpecificStorage(obj->GetName(), obj->GetTitle()); } - + AliSysInfo::AddStamp("InitCDB"); } //_____________________________________________________________________________ @@ -488,7 +573,7 @@ void AliReconstruction::SetSpecificStorage(const char* calibType, const char* ur AliCDBPath aPath(calibType); if(!aPath.IsValid()){ // if calibType is not wildcard but it is a valid detector, add "/*" to make it a valid path - for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { + for (Int_t iDet = 0; iDet < kNDetectors; iDet++) { if(!strcmp(calibType, fgkDetectorName[iDet])) { aPath.SetPath(Form("%s/*", calibType)); AliInfo(Form("Path for specific storage set to %s", aPath.GetPath().Data())); @@ -503,7 +588,7 @@ void AliReconstruction::SetSpecificStorage(const char* calibType, const char* ur // // check that calibType refers to a "valid" detector name // Bool_t isDetector = kFALSE; -// for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { +// for (Int_t iDet = 0; iDet < kNDetectors; iDet++) { // TString detName = fgkDetectorName[iDet]; // if(aPath.GetLevel0() == detName) { // isDetector = kTRUE; @@ -534,40 +619,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(); @@ -600,13 +690,21 @@ Bool_t AliReconstruction::MisalignGeometry(const TString& detectors) TString detStr = detectors; TString loadAlObjsListOfDets = ""; - for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { - if (!IsSelected(fgkDetectorName[iDet], detStr)) continue; - loadAlObjsListOfDets += fgkDetectorName[iDet]; - loadAlObjsListOfDets += " "; + for (Int_t iDet = 0; iDet < kNDetectors; iDet++) { + if(!IsSelected(fgkDetectorName[iDet], detStr)) continue; + if(!strcmp(fgkDetectorName[iDet],"HLT")) continue; + + if(AliGeomManager::GetNalignable(fgkDetectorName[iDet]) != 0) + { + loadAlObjsListOfDets += fgkDetectorName[iDet]; + loadAlObjsListOfDets += " "; + } } // end loop over detectors - loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules + + if(AliGeomManager::GetNalignable("GRP") != 0) + 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 @@ -626,7 +724,10 @@ Bool_t AliReconstruction::MisalignGeometry(const TString& detectors) } } - delete fAlignObjArray; fAlignObjArray=0; + if (fAlignObjArray) { + fAlignObjArray->Delete(); + delete fAlignObjArray; fAlignObjArray=NULL; + } return kTRUE; } @@ -648,7 +749,7 @@ void AliReconstruction::SetInput(const char* input) // mem://: - events taken from DAQ monitoring libs online // or // mem:// - emulation of the above mode (via DATE monitoring libs) - fInput = input; + if (input) fRawInput = input; } //_____________________________________________________________________________ @@ -666,7 +767,15 @@ void AliReconstruction::SetRecoParam(const char* detector, AliDetectorRecoParam { // Set custom reconstruction parameters for a given detector // Single set of parameters for all the events - for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { + + // First check if the reco-params are global + if(!strcmp(detector, "GRP")) { + par->SetAsDefault(); + fRecoParam.AddDetRecoParam(kNDetectors,par); + return; + } + + for (Int_t iDet = 0; iDet < kNDetectors; iDet++) { if(!strcmp(detector, fgkDetectorName[iDet])) { par->SetAsDefault(); fRecoParam.AddDetRecoParam(iDet,par); @@ -677,7 +786,10 @@ void AliReconstruction::SetRecoParam(const char* detector, AliDetectorRecoParam } //_____________________________________________________________________________ -Bool_t AliReconstruction::SetFieldMap(Float_t l3Current, Float_t diCurrent, Float_t factor, const char *path) { +Bool_t AliReconstruction::SetFieldMap(Float_t l3Cur, Float_t diCur, Float_t l3Pol, + Float_t diPol, Float_t beamenergy, + const Char_t *beamtype, const Char_t *path) +{ //------------------------------------------------ // The magnetic field map, defined externally... // L3 current 30000 A -> 0.5 T @@ -691,53 +803,69 @@ Bool_t AliReconstruction::SetFieldMap(Float_t l3Current, Float_t diCurrent, Floa 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... + // + TString s=(l3Pol < 0) ? "L3: -" : "L3: +"; + // + AliMagF::BMap_t map = AliMagF::k5kG; + // + double fcL3,fcDip; + // + l3Cur = TMath::Abs(l3Cur); + if (TMath::Abs(l3Cur-l3NominalCurrent1)/l3NominalCurrent1 < tolerance) { + fcL3 = l3Cur/l3NominalCurrent1; + map = AliMagF::k5kG; + s += "0.5 T; "; + } else if (TMath::Abs(l3Cur-l3NominalCurrent2)/l3NominalCurrent2 < tolerance) { + fcL3 = l3Cur/l3NominalCurrent2; + map = AliMagF::k2kG; + s += "0.2 T; "; + } else if (l3Cur <= zero) { + fcL3 = 0; + map = AliMagF::k5kGUniform; + s += "0.0 T; "; fUniformField=kTRUE; // track with the uniform (zero) B field } else { - AliError(Form("Wrong L3 current (%f A)!",l3Current)); + AliError(Form("Wrong L3 current (%f A)!",l3Cur)); return kFALSE; } - - diCurrent = TMath::Abs(diCurrent); - if (TMath::Abs(diCurrent-diNominalCurrent)/diNominalCurrent < tolerance) { + // + diCur = TMath::Abs(diCur); + if (TMath::Abs(diCur-diNominalCurrent)/diNominalCurrent < tolerance) { // 3% current tolerance... - dipoleON=kTRUE; - s+="Dipole ON"; - } else - if (diCurrent < zero) { // some small current.. - dipoleON=kFALSE; - s+="Dipole OFF"; + fcDip = diCur/diNominalCurrent; + s += "Dipole ON"; + } else if (diCur <= zero) { // some small current.. + fcDip = 0.; + s += "Dipole OFF"; } else { - AliError(Form("Wrong dipole current (%f A)!",diCurrent)); + AliError(Form("Wrong dipole current (%f A)!",diCur)); return kFALSE; } - - delete fForcedFieldMap; - fForcedFieldMap= - new AliMagWrapCheb("B field map ",s,2,factor,10.,map,dipoleON,path); - - fForcedFieldMap->Print(); - - AliTracker::SetFieldMap(fForcedFieldMap,fUniformField); - + // + if (l3Pol!=diPol && (map==AliMagF::k5kG || map==AliMagF::k2kG) && fcDip!=0) { + AliError("L3 and Dipole polarities must be the same"); + return kFALSE; + } + // + if (l3Pol<0) fcL3 = -fcL3; + if (diPol<0) fcDip = -fcDip; + // + AliMagF::BeamType_t btype = AliMagF::kNoBeamField; + TString btypestr = beamtype; + btypestr.ToLower(); + TPRegexp protonBeam("(proton|p)\\s*-?\\s*\\1"); + TPRegexp ionBeam("(lead|pb|ion|a)\\s*-?\\s*\\1"); + if (btypestr.Contains(ionBeam)) btype = AliMagF::kBeamTypeAA; + else if (btypestr.Contains(protonBeam)) btype = AliMagF::kBeamTypepp; + else { + AliInfo(Form("Cannot determine the beam type from %s, assume no LHC magnet field",beamtype)); + } + + AliMagF* fld = new AliMagF("MagneticFieldMap", s.Data(), 2, fcL3, fcDip, 10., map, path, + btype,beamenergy,kTRUE); + TGeoGlobalMagField::Instance()->SetField( fld ); + TGeoGlobalMagField::Instance()->Lock(); + // return kTRUE; } @@ -748,56 +876,93 @@ Bool_t AliReconstruction::InitGRP() { //------------------------------------ AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/Data"); - if (entry) fGRPData = dynamic_cast(entry->GetObject()); + if (entry) { + + TMap* m = dynamic_cast(entry->GetObject()); // old GRP entry + + if (m) { + AliInfo("Found a TMap in GRP/GRP/Data, converting it into an AliGRPObject"); + m->Print(); + fGRPData = new AliGRPObject(); + fGRPData->ReadValuesFromMap(m); + } + + else { + AliInfo("Found an AliGRPObject in GRP/GRP/Data, reading it"); + fGRPData = dynamic_cast(entry->GetObject()); // new GRP entry + 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) { + TString lhcState = fGRPData->GetLHCState(); + if (lhcState==AliGRPObject::GetInvalidString()) { AliError("GRP/GRP/Data entry: missing value for the LHC state ! Using UNKNOWN"); + lhcState = "UNKNOWN"; } - TObjString *beamType= - dynamic_cast(fGRPData->GetValue("fAliceBeamType")); - if (!beamType) { + TString beamType = fGRPData->GetBeamType(); + if (beamType==AliGRPObject::GetInvalidString()) { AliError("GRP/GRP/Data entry: missing value for the beam type ! Using UNKNOWN"); + beamType = "UNKNOWN"; } - TObjString *beamEnergyStr= - dynamic_cast(fGRPData->GetValue("fAliceBeamEnergy")); - if (!beamEnergyStr) { + Float_t beamEnergy = fGRPData->GetBeamEnergy(); + if (beamEnergy==AliGRPObject::GetInvalidFloat()) { AliError("GRP/GRP/Data entry: missing value for the beam energy ! Using 0"); + beamEnergy = 0; } + // energy is provided in MeV*120 + beamEnergy /= 120E3; - TObjString *runType= - dynamic_cast(fGRPData->GetValue("fRunType")); - if (!runType) { + TString runType = fGRPData->GetRunType(); + if (runType==AliGRPObject::GetInvalidString()) { AliError("GRP/GRP/Data entry: missing value for the run type ! Using UNKNOWN"); + runType = "UNKNOWN"; } - TObjString *activeDetectors= - dynamic_cast(fGRPData->GetValue("fDetectorMask")); - if (!activeDetectors) { + Int_t activeDetectors = fGRPData->GetDetectorMask(); + if (activeDetectors==AliGRPObject::GetInvalidUInt()) { AliError("GRP/GRP/Data entry: missing value for the detector mask ! Using 1074790399"); + activeDetectors = 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); + fRunInfo = new AliRunInfo(lhcState, beamType, beamEnergy, runType, activeDetectors); + printf("qqqqqqqqqqqqqqqqqqqqqqq %s %s %f %s %d\n", lhcState.Data(), beamType.Data(), beamEnergy, runType.Data(), activeDetectors); + fRunInfo->Dump(); + // Process the list of active detectors - if (activeDetectors && activeDetectors->GetString().IsDigit()) { - UInt_t detMask = activeDetectors->GetString().Atoi(); + if (activeDetectors) { + UInt_t detMask = activeDetectors; fRunLocalReconstruction = MatchDetectorList(fRunLocalReconstruction,detMask); fRunTracking = MatchDetectorList(fRunTracking,detMask); fFillESD = MatchDetectorList(fFillESD,detMask); fQADetectors = MatchDetectorList(fQADetectors,detMask); + fLoadCDB.Form("%s %s %s %s", + fRunLocalReconstruction.Data(), + fRunTracking.Data(), + fFillESD.Data(), + fQADetectors.Data()); + fLoadCDB = MatchDetectorList(fLoadCDB,detMask); + if (!((detMask >> AliDAQ::DetectorID("ITSSPD")) & 0x1)) { + // switch off the vertexer + AliInfo("SPD is not in the list of active detectors. Vertexer switched off."); + fRunVertexFinder = kFALSE; + } + if (!((detMask >> AliDAQ::DetectorID("TRG")) & 0x1)) { + // switch off the reading of CTP raw-data payload + if (fFillTriggerESD) { + AliInfo("CTP is not in the list of active detectors. CTP data reading switched off."); + fFillTriggerESD = kFALSE; + } + } } AliInfo("==================================================================================="); @@ -805,17 +970,41 @@ Bool_t AliReconstruction::InitGRP() { 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 { + if ( TGeoGlobalMagField::Instance()->IsLocked() ) {AliInfo("Running with the externally locked B field !");} + else { // Construct the field map out of the information retrieved from GRP. - Bool_t ok = kTRUE; - // L3 + Float_t l3Current = fGRPData->GetL3Current((AliGRPObject::Stats)0); + if (l3Current == AliGRPObject::GetInvalidFloat()) { + AliError("GRP/GRP/Data entry: missing value for the L3 current !"); + ok = kFALSE; + } + + Char_t l3Polarity = fGRPData->GetL3Polarity(); + if (l3Polarity == AliGRPObject::GetInvalidChar()) { + AliError("GRP/GRP/Data entry: missing value for the L3 polarity !"); + ok = kFALSE; + } + + // Dipole + Float_t diCurrent = fGRPData->GetDipoleCurrent((AliGRPObject::Stats)0); + if (diCurrent == AliGRPObject::GetInvalidFloat()) { + AliError("GRP/GRP/Data entry: missing value for the dipole current !"); + ok = kFALSE; + } + + Char_t diPolarity = fGRPData->GetDipolePolarity(); + if (diPolarity == AliGRPObject::GetInvalidChar()) { + AliError("GRP/GRP/Data entry: missing value for the dipole polarity !"); + ok = kFALSE; + } + + /* TObjString *l3Current= dynamic_cast(fGRPData->GetValue("fL3Current")); if (!l3Current) { @@ -828,7 +1017,7 @@ Bool_t AliReconstruction::InitGRP() { AliError("GRP/GRP/Data entry: missing value for the L3 polarity !"); ok = kFALSE; } - + // Dipole TObjString *diCurrent= dynamic_cast(fGRPData->GetValue("fDipoleCurrent")); @@ -842,79 +1031,118 @@ Bool_t AliReconstruction::InitGRP() { 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..."); - } + if ( !SetFieldMap(l3Current, diCurrent, l3Polarity ? -1:1, diPolarity ? -1:1) ) + 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..."); - } - + else AliFatal("B field is neither set nor constructed from GRP ! Exitig..."); + + } + + //*** Get the diamond profiles from OCDB + entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD"); + if (entry) { + fDiamondProfileSPD = dynamic_cast (entry->GetObject()); + } else { + AliError("No SPD diamond profile found in OCDB!"); } - - //*** Get the diamond profile from OCDB entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex"); if (entry) { - fDiamondProfile = dynamic_cast (entry->GetObject()); + fDiamondProfile = dynamic_cast (entry->GetObject()); } else { AliError("No diamond profile found in OCDB!"); } entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC"); if (entry) { - fDiamondProfileTPC = dynamic_cast (entry->GetObject()); + fDiamondProfileTPC = dynamic_cast (entry->GetObject()); } else { - AliError("No diamond profile found in OCDB!"); + AliError("No TPC diamond profile found in OCDB!"); } return kTRUE; } +//_____________________________________________________________________________ +Bool_t AliReconstruction::LoadCDB() +{ + AliCodeTimerAuto(""); + + AliCDBManager::Instance()->Get("GRP/CTP/Config"); + + TString detStr = fLoadCDB; + for (Int_t iDet = 0; iDet < kNDetectors; 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(""); - 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++; + 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 { + chain->Process(this); + } + } + else { + Begin(NULL); + if (GetAbort() != TSelector::kContinue) return kFALSE; + SlaveBegin(NULL); + if (GetAbort() != TSelector::kContinue) return kFALSE; + //******* The loop over events + AliInfo("Starting looping 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; } - - if (!FinishRun()) return kFALSE; return kTRUE; } //_____________________________________________________________________________ -Bool_t AliReconstruction::InitRun(const char* input) +void AliReconstruction::InitRawReader(const char* input) { - // 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(""); - // Overwrite the previous setting - if (input) fInput = input; - + // Init raw-reader and // set the input in case of raw data - fRawReader = AliRawReader::Create(fInput.Data()); + if (input) fRawInput = input; + fRawReader = AliRawReader::Create(fRawInput.Data()); if (!fRawReader) AliInfo("Reconstruction will run over digits"); @@ -932,196 +1160,312 @@ Bool_t AliReconstruction::InitRun(const char* input) 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) { + Abort("LoadGeometry", TSelector::kAbortProcess); + return; + } + AliSysInfo::AddStamp("LoadGeom"); TString detsToCheck=fRunLocalReconstruction; - if(!AliGeomManager::CheckSymNamesLUT(detsToCheck.Data())) - AliFatalClass("Current loaded geometry differs in the definition of symbolic names!"); - if (!gGeoManager) if (fStopOnError) return kFALSE; + 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"); + if (!InitGRP()) { + Abort("InitGRP", TSelector::kAbortProcess); + return; + } + AliSysInfo::AddStamp("InitGRP"); - if (!InitGRP()) return kFALSE; + if (!LoadCDB()) { + Abort("LoadCDB", TSelector::kAbortProcess); + return; + } + AliSysInfo::AddStamp("LoadCDB"); // Read the reconstruction parameters from OCDB if (!InitRecoParams()) { - if (fStopOnError) { - CleanUp(); - return kFALSE; - } + AliWarning("Not all detectors have correct RecoParam objects initialized"); } - AliSysInfo::AddStamp("ReadRecoParam"); + AliSysInfo::AddStamp("InitRecoParams"); - ftVertexer = new AliVertexerTracks(AliTracker::GetBz()); - if(fDiamondProfile && fMeanVertexConstraint) ftVertexer->SetVtxStart(fDiamondProfile); + 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*)TGeoGlobalMagField::Instance()->GetField(); + magFieldMap->SetName("MagneticFieldMap"); + fInput->Add(magFieldMap); + } - // get vertexer - if (fRunVertexFinder && !CreateVertexer()) { - if (fStopOnError) { - CleanUp(); - return kFALSE; +} + +//_____________________________________________________________________________ +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")) { + TGeoGlobalMagField::Instance()->SetField(map); + } + 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"); } - AliSysInfo::AddStamp("Vertexer"); + + // get the run loader + if (!InitRunLoader()) { + Abort("InitRunLoader", TSelector::kAbortProcess); + return; + } + AliSysInfo::AddStamp("LoadLoader"); + + ftVertexer = new AliVertexerTracks(AliTracker::GetBz()); // 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; + } + } + else { + if (!(ffile = outProofFile->OpenFile("RECREATE"))) { + Abort(Form("Problems opening output PROOF file: %s/%s", + outProofFile->GetDir(), outProofFile->GetFileName()), + 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;} - } - ftree = new TTree("esdTree", "Tree with ESD objects"); fesd = new AliESDEvent(); fesd->CreateStdContent(); - fesd->WriteToTree(ftree); - - fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects"); - fhltesd = new AliESDEvent(); - fhltesd->CreateStdContent(); - fhltesd->WriteToTree(fhlttree); - + fesd->WriteToTree(ftree); if (fWriteESDfriend) { + // careful: + // Since we add the branch manually we must + // book and add it after WriteToTree + // otherwise it is created twice, + // once via writetotree and once here. + // The case for AliESDfriend is now + // caught also in AlIESDEvent::WriteToTree but + // be careful when changing the name (AliESDfriend is not + // a TNamed so we had to hardwire it) fesdf = new AliESDfriend(); TBranch *br=ftree->Branch("ESDfriend.","AliESDfriend", &fesdf); br->SetFile("AliESDfriends.root"); fesd->AddObject(fesdf); } + ftree->GetUserInfo()->Add(fesd); + fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects"); + fhltesd = new AliESDEvent(); + fhltesd->CreateStdContent(); + // read the ESD template from CDB + // HLT is allowed to put non-std content to its ESD, the non-std + // objects need to be created before invocation of WriteToTree in + // order to create all branches. Initialization is done from an + // ESD layout template in CDB + AliCDBManager* man = AliCDBManager::Instance(); + AliCDBPath hltESDConfigPath("HLT/ConfigHLT/esdLayout"); + AliCDBEntry* hltESDConfig=NULL; + if (man->GetId(hltESDConfigPath)!=NULL && + (hltESDConfig=man->Get(hltESDConfigPath))!=NULL) { + AliESDEvent* pESDLayout=dynamic_cast(hltESDConfig->GetObject()); + if (pESDLayout) { + // init all internal variables from the list of objects + pESDLayout->GetStdContent(); + + // copy content and create non-std objects + *fhltesd=*pESDLayout; + fhltesd->Reset(); + } else { + AliError(Form("error setting hltEsd layout from %s: invalid object type", + hltESDConfigPath.GetPath().Data())); + } + } - if (fRawReader) fRawReader->RewindEvents(); + fhltesd->WriteToTree(fhlttree); + fhlttree->GetUserInfo()->Add(fhltesd); - ProcInfo_t ProcInfo; - gSystem->GetProcInfo(&ProcInfo); - AliInfo(Form("Current memory usage %d %d", ProcInfo.fMemResident, ProcInfo.fMemVirtual)); + ProcInfo_t procInfo; + gSystem->GetProcInfo(&procInfo); + AliInfo(Form("Current memory usage %d %d", procInfo.fMemResident, procInfo.fMemVirtual)); //QA - if ( !fInLoopQA ) { - if (fRunQA && fRawReader && fQATasks.Contains(Form("%d", AliQA::kRAWS))) { - fQASteer->Run(fQADetectors, fRawReader) ; - fSameQACycle = kTRUE ; + //Initialize the QA and start of cycle + if (fRunQA) { + fQASteer = new AliQADataMakerSteer("rec") ; + fQASteer->SetActiveDetectors(fQADetectors) ; + for (Int_t det = 0 ; det < AliQA::kNDET ; det++) { + fQASteer->SetCycleLength(AliQA::DETECTORINDEX_t(det), fQACycles[det]) ; + fQASteer->SetWriteExpert(AliQA::DETECTORINDEX_t(det)) ; } + if (!fRawReader && fQATasks.Contains(AliQA::kRAWS)) + fQATasks.ReplaceAll(Form("%d",AliQA::kRAWS), "") ; + fQASteer->SetTasks(fQATasks) ; + fQASteer->InitQADataMaker(AliCDBManager::Instance()->GetRun()) ; } - - //Initialize the QA and start of cycle for out-of-cycle QA - if (fRunQA) { - TString detStr(fQADetectors) ; - for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { - if (!IsSelected(fgkDetectorName[iDet], detStr)) - continue; - AliQADataMaker *qadm = fQASteer->GetQADataMaker(iDet); - if (!qadm) - continue; - AliInfo(Form("Initializing the QA data maker for %s", fgkDetectorName[iDet])); - if (fQATasks.Contains(Form("%d", AliQA::kRAWS))) ; - qadm->Init(AliQA::kRAWS, AliCDBManager::Instance()->GetRun()); - if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS))) - qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun()); - if (fQATasks.Contains(Form("%d", AliQA::kESDS))) - qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun()); - if (!fInLoopQA) { - if (fQATasks.Contains(Form("%d", AliQA::kRAWS))) { - qadm->StartOfCycle(AliQA::kRAWS, fSameQACycle); - fSameQACycle = kTRUE; - } - 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; - } - } + + if (fRunGlobalQA) { + Bool_t sameCycle = kFALSE ; + if (!fQASteer) fQASteer = new AliQADataMakerSteer("rec") ; + AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL); + AliInfo(Form("Initializing the global QA data maker")); + if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS))) { + qadm->StartOfCycle(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun(), sameCycle) ; + TObjArray **arr=qadm->Init(AliQA::kRECPOINTS); + AliTracker::SetResidualsArray(arr); + sameCycle = kTRUE ; } - if (fRunGlobalQA) { - 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 (fQATasks.Contains(Form("%d", AliQA::kESDS))) { - qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun()); - } - if (!fInLoopQA) { - fSameQACycle = kFALSE; - 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; - } - } + if (fQATasks.Contains(Form("%d", AliQA::kESDS))) { + qadm->StartOfCycle(AliQA::kESDS, AliCDBManager::Instance()->GetRun(), sameCycle) ; + qadm->Init(AliQA::kESDS); } } //Initialize the Plane Efficiency framework if (fRunPlaneEff && !InitPlaneEff()) { - if(fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;} + Abort("InitPlaneEff", TSelector::kAbortProcess); + return; } if (strcmp(gProgName,"alieve") == 0) fRunAliEVE = InitAliEVE(); - return kTRUE; + return; +} + +//_____________________________________________________________________________ +Bool_t AliReconstruction::Process(Long64_t entry) +{ + // run the reconstruction over a single entry + // from the chain with raw data + AliCodeTimerAuto(""); + + 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; + + return fStatus; +} + +//_____________________________________________________________________________ +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 @@ -1132,90 +1476,45 @@ 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) { - fhltesd->ReadFromTree(fhlttreeOld); - fhlttreeOld->GetEntry(iEvent); - fhlttree->Fill(); - } return kTRUE; } AliInfo(Form("processing event %d", iEvent)); + fRunLoader->GetEvent(iEvent); + // Fill Event-info object GetEventInfo(); fRecoParam.SetEventSpecie(fRunInfo,fEventInfo); + AliInfo(Form("Current event specie: %s",fRecoParam.PrintEventSpecie())); - //Start of cycle for the in-loop QA - if (fInLoopQA && fRunQA) { - TString detStr(fQADetectors); - fSameQACycle = kFALSE ; - for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { - if (!IsSelected(fgkDetectorName[iDet], detStr)) - continue; - AliQADataMaker *qadm = fQASteer->GetQADataMaker(iDet); - if (!qadm) - continue; - if (fQATasks.Contains(Form("%d", AliQA::kRAWS))) { - qadm->StartOfCycle(AliQA::kRAWS, fSameQACycle); - fSameQACycle = kTRUE; - } - 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; + // Set the reco-params + { + TString detStr = fLoadCDB; + for (Int_t iDet = 0; iDet < kNDetectors; iDet++) { + if (!IsSelected(fgkDetectorName[iDet], detStr)) continue; + AliReconstructor *reconstructor = GetReconstructor(iDet); + if (reconstructor && fRecoParam.GetDetRecoParamArray(iDet)) { + const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet); + reconstructor->SetRecoParam(par); + if (fRunQA) { + fQASteer->SetRecoParam(iDet, par) ; + } } } - if (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); - - 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) { - for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { - TString detStr(fQADetectors); - if (!IsSelected(fgkDetectorName[iDet], detStr)) - continue; - AliQADataMaker *qadm = fQASteer->GetQADataMaker(iDet); - if (!qadm) - continue; - if (fQATasks.Contains(Form("%d", AliQA::kRAWS))) - qadm->Exec(AliQA::kRAWS, fRawReader) ; - } - } - + if (fRunQA) { + fQASteer->SetEventSpecie(fRecoParam.GetEventSpecie()) ; + fQASteer->RunOneEvent(fRawReader) ; + } // local single event reconstruction if (!fRunLocalReconstruction.IsNull()) { TString detectors=fRunLocalReconstruction; @@ -1223,12 +1522,12 @@ Bool_t AliReconstruction::RunEvent(Int_t iEvent) // ;-( IsSelected changes the string if (IsSelected("HLT", detectors) && !RunLocalEventReconstruction("HLT")) { - if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;} + if (fStopOnError) {CleanUp(); return kFALSE;} } detectors=fRunLocalReconstruction; detectors.ReplaceAll("HLT", ""); if (!RunLocalEventReconstruction(detectors)) { - if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;} + if (fStopOnError) {CleanUp(); return kFALSE;} } } @@ -1241,18 +1540,18 @@ Bool_t AliReconstruction::RunEvent(Int_t iEvent) fesd->SetMagneticField(AliTracker::GetBz()); fhltesd->SetMagneticField(AliTracker::GetBz()); - + // Set most probable pt, for B=0 tracking + // Get the global reco-params. They are atposition 16 inside the array of detectors in fRecoParam + const AliGRPRecoParam *grpRecoParam = dynamic_cast(fRecoParam.GetDetRecoParam(kNDetectors)); + if (grpRecoParam) AliExternalTrackParam::SetMostProbablePt(grpRecoParam->GetMostProbablePt()); // Fill raw-data error log into the ESD if (fRawReader) FillRawDataErrorLog(iEvent,fesd); // vertex finder if (fRunVertexFinder) { - if (!ReadESD(fesd, "vertex")) { - if (!RunVertexFinder(fesd)) { - if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;} - } - if (fCheckPointLevel > 0) WriteESD(fesd, "vertex"); + if (!RunVertexFinder(fesd)) { + if (fStopOnError) {CleanUp(); return kFALSE;} } } @@ -1260,18 +1559,15 @@ 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;} } } @@ -1282,20 +1578,20 @@ Bool_t AliReconstruction::RunEvent(Int_t iEvent) // ;-( IsSelected changes the string if (IsSelected("HLT", detectors) && !FillESD(fhltesd, "HLT")) { - if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;} + 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;} } } @@ -1328,7 +1620,7 @@ Bool_t AliReconstruction::RunEvent(Int_t iEvent) UShort_t *selectedIdx=new UShort_t[ntracks]; for (Int_t itrack=0; itrackGetTrack(itrack); @@ -1339,7 +1631,7 @@ Bool_t AliReconstruction::RunEvent(Int_t iEvent) ok = kFALSE; if (tpcTrack) ok = AliTracker:: - PropagateTrackTo(tpcTrack,kRadius,track->GetMass(),kMaxStep,kTRUE); + PropagateTrackTo(tpcTrack,kRadius,track->GetMass(),kMaxStep,kFALSE); if (ok) { Int_t n=trkArray.GetEntriesFast(); @@ -1351,7 +1643,7 @@ Bool_t AliReconstruction::RunEvent(Int_t iEvent) if (track->IsOn(AliESDtrack::kITSrefit)) continue; AliTracker:: - PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kTRUE); + PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kFALSE); track->RelateToVertex(fesd->GetPrimaryVertexSPD(), kBz, kVeryBig); } @@ -1359,24 +1651,32 @@ Bool_t AliReconstruction::RunEvent(Int_t iEvent) // // 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(); - if(fDiamondProfile && fMeanVertexConstraint) { - ftVertexer->SetVtxStart(fDiamondProfile); - } else { - ftVertexer->SetConstraintOff(); + ftVertexer->SetITSMode(); + ftVertexer->SetConstraintOff(); + // get cuts for vertexer from AliGRPRecoParam + if (grpRecoParam) { + Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts(); + Double_t *cutsVertexer = new Double_t[nCutsVertexer]; + grpRecoParam->GetVertexerTracksCutsITS(cutsVertexer); + ftVertexer->SetCuts(cutsVertexer); + delete [] cutsVertexer; cutsVertexer = NULL; + if(fDiamondProfile && grpRecoParam->GetVertexerTracksConstraintITS()) + ftVertexer->SetVtxStart(fDiamondProfile); } AliESDVertex *pvtx=ftVertexer->FindPrimaryVertex(fesd); if (pvtx) { if (pvtx->GetStatus()) { - fesd->SetPrimaryVertex(pvtx); + fesd->SetPrimaryVertexTracks(pvtx); for (Int_t i=0; iGetTrack(i); t->RelateToVertex(pvtx, kBz, kVeryBig); @@ -1385,11 +1685,17 @@ Bool_t AliReconstruction::RunEvent(Int_t iEvent) } // TPC-only primary vertex - ftVertexer->SetITSrefitNotRequired(); - if(fDiamondProfileTPC && fMeanVertexConstraint) { - ftVertexer->SetVtxStart(fDiamondProfileTPC); - } else { - ftVertexer->SetConstraintOff(); + ftVertexer->SetTPCMode(); + ftVertexer->SetConstraintOff(); + // get cuts for vertexer from AliGRPRecoParam + if (grpRecoParam) { + Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts(); + Double_t *cutsVertexer = new Double_t[nCutsVertexer]; + grpRecoParam->GetVertexerTracksCutsTPC(cutsVertexer); + ftVertexer->SetCuts(cutsVertexer); + delete [] cutsVertexer; cutsVertexer = NULL; + if(fDiamondProfileTPC && grpRecoParam->GetVertexerTracksConstraintTPC()) + ftVertexer->SetVtxStart(fDiamondProfileTPC); } pvtx=ftVertexer->FindPrimaryVertex(&trkArray,selectedIdx); if (pvtx) { @@ -1423,24 +1729,30 @@ Bool_t AliReconstruction::RunEvent(Int_t iEvent) // write ESD if (fCleanESD) CleanESD(fesd); - if (fRunQA) { - if (fRunGlobalQA) { - AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL); - if (qadm && fQATasks.Contains(Form("%d", AliQA::kESDS))) - qadm->Exec(AliQA::kESDS, fesd); - } - } + if (fRunQA) { + fQASteer->SetEventSpecie(fRecoParam.GetEventSpecie()) ; + fQASteer->RunOneEvent(fesd) ; + } + if (fRunGlobalQA) { + AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL); + qadm->SetEventSpecie(fRecoParam.GetEventSpecie()) ; + if (qadm && fQATasks.Contains(Form("%d", AliQA::kESDS))) + qadm->Exec(AliQA::kESDS, fesd); + } if (fWriteESDfriend) { - fesdf->~AliESDfriend(); - new (fesdf) AliESDfriend(); // Reset... + // fesdf->~AliESDfriend(); + // new (fesdf) AliESDfriend(); // Reset... fesd->GetESDfriend(fesdf); } ftree->Fill(); // Auto-save the ESD tree in case of prompt reco @P2 - if (fRawReader && fRawReader->UseAutoSaveESD()) + if (fRawReader && fRawReader->UseAutoSaveESD()) { ftree->AutoSave("SaveSelf"); + TFile *friendfile = (TFile *)(gROOT->GetListOfFiles()->FindObject("AliESDfriends.root")); + if (friendfile) friendfile->Save(); + } // write HLT ESD fhlttree->Fill(); @@ -1448,7 +1760,6 @@ Bool_t AliReconstruction::RunEvent(Int_t iEvent) // call AliEVE if (fRunAliEVE) RunAliEVE(); - if (fCheckPointLevel > 0) WriteESD(fesd, "final"); fesd->Reset(); fhltesd->Reset(); if (fWriteESDfriend) { @@ -1456,53 +1767,26 @@ Bool_t AliReconstruction::RunEvent(Int_t iEvent) new (fesdf) AliESDfriend(); // Reset... } - ProcInfo_t ProcInfo; - gSystem->GetProcInfo(&ProcInfo); - AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, ProcInfo.fMemResident, ProcInfo.fMemVirtual)); + ProcInfo_t procInfo; + gSystem->GetProcInfo(&procInfo); + AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, procInfo.fMemResident, procInfo.fMemVirtual)); - - // End of cycle for the in-loop - if (fInLoopQA && fRunQA) { - RunQA(fesd); - for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { - if (!IsSelected(fgkDetectorName[iDet], fQADetectors)) - continue; - AliQADataMaker * qadm = fQASteer->GetQADataMaker(iDet); - if (!qadm) - continue; - if (fQATasks.Contains(Form("%d", AliQA::kRAWS))) - qadm->EndOfCycle(AliQA::kRAWS); - if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS))) - qadm->EndOfCycle(AliQA::kRECPOINTS); - if (fQATasks.Contains(Form("%d", AliQA::kESDS))) - qadm->EndOfCycle(AliQA::kESDS); - qadm->Finish(); - } - } - if (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(); - } - } - fEventInfo.Reset(); - for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { + for (Int_t iDet = 0; iDet < kNDetectors; iDet++) { if (fReconstructor[iDet]) fReconstructor[iDet]->SetRecoParam(NULL); } + if (fRunQA || fRunGlobalQA) + fQASteer->Increment() ; + 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(""); @@ -1513,9 +1797,6 @@ Bool_t AliReconstruction::FinishRun() fRunLoader->Write(0, TObject::kOverwrite); } - ftree->GetUserInfo()->Add(fesd); - fhlttree->GetUserInfo()->Add(fhltesd); - const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap(); const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds(); @@ -1537,8 +1818,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())); } @@ -1546,13 +1827,6 @@ Bool_t AliReconstruction::FinishRun() ftree->GetUserInfo()->Add(cdbListCopy); - if(fESDPar.Contains("ESD.par")){ - AliInfo("Attaching ESD.par to Tree"); - TNamed *fn = CopyFileToTNamed(fESDPar.Data(),"ESD.par"); - ftree->GetUserInfo()->Add(fn); - } - - ffile->cd(); if (fWriteESDfriend) @@ -1566,103 +1840,36 @@ Bool_t AliReconstruction::FinishRun() AliWarning("Finish PlaneEff evaluation failed"); } + // End of cycle for the in-loop + if (fRunQA) + fQASteer->EndOfCycle() ; + + if (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(ffile, ffileOld); + CleanUp(); +} - if (fWriteAOD) { - AliWarning("AOD creation not supported anymore during reconstruction. See ANALYSIS/AliAnalysisTaskESDfilter.cxx instead."); - } - +//_____________________________________________________________________________ +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,fGRPData); - if (fWriteAOD) { - AliWarning("AOD tag creation not supported anymore during reconstruction."); - } - - //Finish QA and end of cycle for out-of-loop QA - if (!fInLoopQA) { - if (fRunQA) { - if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS))) - fQASteer->Run(fRunLocalReconstruction.Data(), AliQA::kRECPOINTS, fSameQACycle); - //fQASteer->Reset() ; - if (fQATasks.Contains(Form("%d", AliQA::kESDS))) - fQASteer->Run(fRunLocalReconstruction.Data(), AliQA::kESDS, fSameQACycle); - if (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(); - } - } - } - } - + esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData, AliQA::Instance()->GetQA(), AliQA::Instance()->GetEventSpecies(), AliQA::kNDET, AliRecoParam::kNSpecies); + // 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; } //_____________________________________________________________________________ @@ -1674,7 +1881,7 @@ Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors) AliCodeTimerAuto("") TString detStr = detectors; - for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { + for (Int_t iDet = 0; iDet < kNDetectors; iDet++) { if (!IsSelected(fgkDetectorName[iDet], detStr)) continue; AliReconstructor* reconstructor = GetReconstructor(iDet); if (!reconstructor) continue; @@ -1729,28 +1936,15 @@ Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors) loader->UnloadDigits(); } - // In-loop QA for local reconstrucion TString detQAStr(fQADetectors) ; - if (fRunQA && fInLoopQA && IsSelected(fgkDetectorName[iDet], detQAStr) ) { - AliQADataMaker * qadm = fQASteer->GetQADataMaker(iDet); - if (qadm) { - //AliCodeTimerStart - //(Form("Running QA data maker for %s", fgkDetectorName[iDet])); - //AliInfo - //(Form("Running QA data maker for %s", fgkDetectorName[iDet])); - - if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS))) - qadm->Exec(AliQA::kRECPOINTS, clustersTree) ; - //AliCodeTimerStop - //(Form("Running QA data maker for %s", fgkDetectorName[iDet])); - } + if (fRunQA) { + fQASteer->SetEventSpecie(fRecoParam.GetEventSpecie()) ; + fQASteer->RunOneEventInOneDetector(iDet, clustersTree) ; } - - loader->WriteRecPoints("OVERWRITE"); - loader->UnloadRecPoints(); - AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr); + 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())); @@ -1767,63 +1961,52 @@ Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd) AliCodeTimerAuto("") + AliVertexer *vertexer = CreateVertexer(); + if (!vertexer) return kFALSE; + + AliInfo("running the ITS vertex finder"); AliESDVertex* vertex = NULL; - Double_t vtxPos[3] = {0, 0, 0}; - Double_t vtxErr[3] = {0.07, 0.07, 0.1}; - TArrayF mcVertex(3); - if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) { - fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex); - for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i]; - } - - if (fVertexer) { - AliInfo("running the ITS vertex finder"); - 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(); + if (fLoader[0]) { + fLoader[0]->LoadRecPoints(); + TTree* cltree = fLoader[0]->TreeR(); + if (cltree) { + if(fDiamondProfileSPD) vertexer->SetVtxStart(fDiamondProfileSPD); + vertex = vertexer->FindVertexForCurrentEvent(cltree); } else { - AliError("Can't get the ITS loader"); + AliError("Can't get the ITS cluster tree"); } - if(!vertex){ - AliWarning("Vertex not found"); - vertex = new AliESDVertex(); - vertex->SetName("default"); - } - else { - vertex->SetName("reconstructed"); - } - - } else { - AliInfo("getting the primary vertex from MC"); - vertex = new AliESDVertex(vtxPos, vtxErr); + fLoader[0]->UnloadRecPoints(); } - - if (vertex) { - vertex->GetXYZ(vtxPos); - vertex->GetSigmaXYZ(vtxErr); - } else { - AliWarning("no vertex reconstructed"); - vertex = new AliESDVertex(vtxPos, vtxErr); + else { + AliError("Can't get the ITS loader"); + } + if(!vertex){ + AliWarning("Vertex not found"); + vertex = new AliESDVertex(); + vertex->SetName("default"); + } + else { + vertex->SetName("reconstructed"); } + + Double_t vtxPos[3]; + Double_t vtxErr[3]; + vertex->GetXYZ(vtxPos); + vertex->GetSigmaXYZ(vtxErr); + esd->SetPrimaryVertexSPD(vertex); // if SPD multiplicity has been determined, it is stored in the ESD - AliMultiplicity *mult = fVertexer->GetMultiplicity(); + AliMultiplicity *mult = vertexer->GetMultiplicity(); if(mult)esd->SetMultiplicity(mult); - for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { + for (Int_t iDet = 0; iDet < kNDetectors; iDet++) { if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr); } delete vertex; + delete vertexer; + return kTRUE; } @@ -1842,7 +2025,7 @@ Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd) AliInfo("running HLT tracking"); // Get a pointer to the HLT reconstructor - AliReconstructor *reconstructor = GetReconstructor(fgkNDetectors-1); + AliReconstructor *reconstructor = GetReconstructor(kNDetectors-1); if (!reconstructor) return kFALSE; // TPC + ITS @@ -1947,7 +2130,9 @@ Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd) if (fReconstructor[11] && fLoader[11]) { fLoader[11]->LoadRecPoints("READ"); TTree *treeR = fLoader[11]->TreeR(); - GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd); + if (treeR) { + GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd); + } } // pass 1: TPC + ITS inwards @@ -1970,9 +2155,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); @@ -1983,7 +2165,7 @@ Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd) // pass 2: ALL backwards - for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { + for (Int_t iDet = 0; iDet < kNDetectors; iDet++) { if (!fTracker[iDet]) continue; AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet])); @@ -2003,15 +2185,12 @@ Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd) // run tracking if (iDet>1) // start filling residuals for the "outer" detectors - if (fRunGlobalQA) AliTracker::SetFillResiduals(kTRUE); + if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE); if (fTracker[iDet]->PropagateBack(esd) != 0) { AliError(Form("%s backward propagation failed", fgkDetectorName[iDet])); // return kFALSE; } - if (fCheckPointLevel > 1) { - WriteESD(esd, Form("%s.back", fgkDetectorName[iDet])); - } // unload clusters if (iDet > 3) { // all except ITS, TPC, TRD and TOF @@ -2026,7 +2205,7 @@ Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd) AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr); } //stop filling residuals for the "outer" detectors - if (fRunGlobalQA) AliTracker::SetFillResiduals(kFALSE); + if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE); // pass 3: TRD + TPC + ITS refit inwards @@ -2036,7 +2215,7 @@ Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd) // run tracking if (iDet<2) // start filling residuals for TPC and ITS - if (fRunGlobalQA) AliTracker::SetFillResiduals(kTRUE); + if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE); if (fTracker[iDet]->RefitInward(esd) != 0) { AliError(Form("%s inward refit failed", fgkDetectorName[iDet])); @@ -2047,9 +2226,6 @@ 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); } @@ -2067,7 +2243,7 @@ Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd) AliSysInfo::AddStamp(Form("RUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,5, eventNr); } // stop filling residuals for TPC and ITS - if (fRunGlobalQA) AliTracker::SetFillResiduals(kFALSE); + if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE); eventNr++; return kTRUE; @@ -2104,43 +2280,39 @@ Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors) static Int_t eventNr=0; TString detStr = detectors; - for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { + for (Int_t iDet = 0; iDet < kNDetectors; iDet++) { 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(); } } @@ -2259,7 +2431,7 @@ Bool_t AliReconstruction::InitRunLoader() if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists // load all base libraries to get the loader classes TString libs = gSystem->GetLibraries(); - for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { + for (Int_t iDet = 0; iDet < kNDetectors; iDet++) { TString detName = fgkDetectorName[iDet]; if (detName == "HLT") continue; if (libs.Contains("lib" + detName + "base.so")) continue; @@ -2283,8 +2455,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(), @@ -2402,30 +2572,32 @@ AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet) } //_____________________________________________________________________________ -Bool_t AliReconstruction::CreateVertexer() +AliVertexer* AliReconstruction::CreateVertexer() { // create the vertexer +// Please note that the caller is the owner of the +// vertexer - fVertexer = NULL; + AliVertexer* vertexer = NULL; AliReconstructor* itsReconstructor = GetReconstructor(0); if (itsReconstructor) { - fVertexer = itsReconstructor->CreateVertexer(); + vertexer = itsReconstructor->CreateVertexer(); } - if (!fVertexer) { + if (!vertexer) { AliWarning("couldn't create a vertexer for ITS"); - if (fStopOnError) return kFALSE; } - return kTRUE; + return vertexer; } //_____________________________________________________________________________ Bool_t AliReconstruction::CreateTrackers(const TString& detectors) { // create the trackers + AliInfo("Creating trackers"); TString detStr = detectors; - for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { + for (Int_t iDet = 0; iDet < kNDetectors; iDet++) { if (!IsSelected(fgkDetectorName[iDet], detStr)) continue; AliReconstructor* reconstructor = GetReconstructor(iDet); if (!reconstructor) continue; @@ -2452,110 +2624,45 @@ 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 - for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { + for (Int_t iDet = 0; iDet < kNDetectors; iDet++) { delete fReconstructor[iDet]; fReconstructor[iDet] = NULL; fLoader[iDet] = NULL; delete fTracker[iDet]; fTracker[iDet] = NULL; } - if (fRunInfo) delete fRunInfo; + 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 fGRPData; - fGRPData = NULL; + delete fDiamondProfileSPD; + fDiamondProfileSPD = NULL; + delete fDiamondProfile; + fDiamondProfile = NULL; + delete fDiamondProfileTPC; + fDiamondProfileTPC = 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 @@ -2567,7 +2674,7 @@ void AliReconstruction::WriteAlignmentData(AliESDEvent* esd) AliESDtrack *track = esd->GetTrack(itrack); Int_t nsp = 0; Int_t idx[200]; - for (Int_t iDet = 3; iDet >= 0; iDet--) {// TOF, TRD, TPC, ITS clusters + for (Int_t iDet = 5; iDet >= 0; iDet--) {// TOF, TRD, TPC, ITS clusters nsp += track->GetNcls(iDet); if (iDet==0) { // ITS "extra" clusters @@ -2580,7 +2687,7 @@ void AliReconstruction::WriteAlignmentData(AliESDEvent* esd) AliTrackPointArray *sp = new AliTrackPointArray(nsp); track->SetTrackPointArray(sp); Int_t isptrack = 0; - for (Int_t iDet = 3; iDet >= 0; iDet--) { + for (Int_t iDet = 5; iDet >= 0; iDet--) { AliTracker *tracker = fTracker[iDet]; if (!tracker) continue; Int_t nspdet = track->GetClusters(iDet,idx); @@ -2609,6 +2716,7 @@ void AliReconstruction::WriteAlignmentData(AliESDEvent* esd) } isp2++; if (!isvalid) continue; + if (iDet==0 && (isp-1)>=6) p.SetExtra(); sp->AddPoint(isptrack,&p); isptrack++; } } @@ -2638,121 +2746,43 @@ void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd) } -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); - Int_t kBytes = (Int_t)in.tellg(); - printf("Size: %d \n",kBytes); - TNamed *fn = 0; - if(in.good()){ - char* memblock = new char [kBytes]; - in.seekg (0, ios::beg); - in.read (memblock, kBytes); - in.close(); - TString fData(memblock,kBytes); - fn = new TNamed(pName,fData); - printf("fData Size: %d \n",fData.Sizeof()); - printf("pName Size: %d \n",pName.Sizeof()); - printf("fn Size: %d \n",fn->Sizeof()); - delete[] memblock; - } - else{ - AliInfo(Form("Could not Open %s\n",fPath.Data())); - } - - return fn; -} - -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(pName.Data()); - printf("fn Size: %d \n",fn->Sizeof()); - - 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(pName.Data(),ios::out | ios::binary); - out.write(cdata,size); - out.close(); - -} - -//_____________________________________________________________________________ -Bool_t AliReconstruction::RunQA(AliESDEvent *& esd) -{ - // run the Quality Assurance data producer - - AliCodeTimerAuto("") - TString detStr = fQADetectors ; - for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { - if (!IsSelected(fgkDetectorName[iDet], detStr)) - continue; - AliQADataMaker * qadm = fQASteer->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])); - - if (fQATasks.Contains(Form("%d", AliQA::kESDS))) { - 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() { // check the QA of SIM for this run and remove the detectors // with status Fatal - TString newRunLocalReconstruction ; - TString newRunTracking ; - TString newFillESD ; - - for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) { - TString detName(AliQA::GetDetName(iDet)) ; - AliQA * qa = AliQA::Instance(AliQA::DETECTORINDEX_t(iDet)) ; - if ( qa->IsSet(AliQA::DETECTORINDEX_t(iDet), AliQA::kSIM, AliQA::kFATAL)) { - AliInfo(Form("QA status for %s in Hits and/or SDIGITS and/or Digits was Fatal; No reconstruction performed", detName.Data())) ; - } else { - if ( fRunLocalReconstruction.Contains(AliQA::GetDetName(iDet)) || - fRunLocalReconstruction.Contains("ALL") ) { - newRunLocalReconstruction += detName ; - newRunLocalReconstruction += " " ; - } - if ( fRunTracking.Contains(AliQA::GetDetName(iDet)) || - fRunTracking.Contains("ALL") ) { - newRunTracking += detName ; - newRunTracking += " " ; - } - if ( fFillESD.Contains(AliQA::GetDetName(iDet)) || - fFillESD.Contains("ALL") ) { - newFillESD += detName ; - newFillESD += " " ; - } - } - } - fRunLocalReconstruction = newRunLocalReconstruction ; - fRunTracking = newRunTracking ; - fFillESD = newFillESD ; +// TString newRunLocalReconstruction ; +// TString newRunTracking ; +// TString newFillESD ; +// +// for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) { +// TString detName(AliQA::GetDetName(iDet)) ; +// AliQA * qa = AliQA::Instance(AliQA::DETECTORINDEX_t(iDet)) ; +// if ( qa->IsSet(AliQA::DETECTORINDEX_t(iDet), AliQA::kSIM, specie, AliQA::kFATAL)) { +// AliInfo(Form("QA status for %s %s in Hits and/or SDIGITS and/or Digits was Fatal; No reconstruction performed", +// detName.Data(), AliRecoParam::GetEventSpecieName(es))) ; +// } else { +// if ( fRunLocalReconstruction.Contains(AliQA::GetDetName(iDet)) || +// fRunLocalReconstruction.Contains("ALL") ) { +// newRunLocalReconstruction += detName ; +// newRunLocalReconstruction += " " ; +// } +// if ( fRunTracking.Contains(AliQA::GetDetName(iDet)) || +// fRunTracking.Contains("ALL") ) { +// newRunTracking += detName ; +// newRunTracking += " " ; +// } +// if ( fFillESD.Contains(AliQA::GetDetName(iDet)) || +// fFillESD.Contains("ALL") ) { +// newFillESD += detName ; +// newFillESD += " " ; +// } +// } +// } +// fRunLocalReconstruction = newRunLocalReconstruction ; +// fRunTracking = newRunTracking ; +// fFillESD = newFillESD ; } //_____________________________________________________________________________ @@ -2760,7 +2790,7 @@ Int_t AliReconstruction::GetDetIndex(const char* detector) { // return the detector index corresponding to detector Int_t index = -1 ; - for (index = 0; index < fgkNDetectors ; index++) { + for (index = 0; index < kNDetectors ; index++) { if ( strcmp(detector, fgkDetectorName[index]) == 0 ) break ; } @@ -2780,7 +2810,7 @@ Bool_t AliReconstruction::FinishPlaneEff() { // 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 < kNDetectors; iDet++) { for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS //if (!IsSelected(fgkDetectorName[iDet], detStr)) continue; if(fTracker[iDet]) { @@ -2834,7 +2864,7 @@ Bool_t AliReconstruction::InitAliEVE() 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("if (!AliEveEventManager::GetMaster()){new AliEveEventManager();AliEveEventManager::GetMaster()->AddNewEventCommand(\"alieve_online_on_new_event()\");gEve->AddEvent(AliEveEventManager::GetMaster());};"); gROOT->ProcessLine("alieve_online_init()"); return kTRUE; @@ -2849,8 +2879,7 @@ void AliReconstruction::RunAliEVE() // 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();"); + gROOT->ProcessLine(Form("AliEveEventManager::GetMaster()->SetEvent((AliRunLoader*)0x%lx,(AliRawReader*)0x%lx,(AliESDEvent*)0x%lx,(AliESDfriend*)0x%lx);",fRunLoader,fRawReader,fesd,fesdf)); gSystem->Run(); } @@ -2870,7 +2899,7 @@ Bool_t AliReconstruction::SetRunQA(TString detAndAction) fQADetectors = detAndAction(0, colon) ; if (fQADetectors.Contains("ALL") ) fQADetectors = fFillESD ; - fQATasks = detAndAction(colon+1, detAndAction.Sizeof() ) ; + fQATasks = detAndAction(colon+1, detAndAction.Sizeof() ) ; if (fQATasks.Contains("ALL") ) { fQATasks = Form("%d %d %d", AliQA::kRAWS, AliQA::kRECPOINTS, AliQA::kESDS) ; } else { @@ -2890,9 +2919,9 @@ Bool_t AliReconstruction::SetRunQA(TString detAndAction) } } 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)) ; + 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; @@ -2906,14 +2935,17 @@ Bool_t AliReconstruction::InitRecoParams() Bool_t isOK = kTRUE; - for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { + TString detStr = fLoadCDB; + for (Int_t iDet = 0; iDet < kNDetectors; iDet++) { + + if (!IsSelected(fgkDetectorName[iDet], detStr)) continue; if (fRecoParam.GetDetRecoParamArray(iDet)) { AliInfo(Form("Using custom reconstruction parameters for detector %s",fgkDetectorName[iDet])); continue; } - AliDebug(1, Form("Loading RecoParam objects for detector: %s",fgkDetectorName[iDet])); + AliInfo(Form("Loading reconstruction parameter objects for detector %s",fgkDetectorName[iDet])); AliCDBPath path(fgkDetectorName[iDet],"Calib","RecoParam"); AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath()); @@ -2931,7 +2963,7 @@ Bool_t AliReconstruction::InitRecoParams() else if (dynamic_cast(recoParamObj)) { // The detector has only onse set of reco parameters // Registering it in AliRecoParam - AliInfo(Form("Single set of reco parameters found for detector %s",fgkDetectorName[iDet])); + AliInfo(Form("Single set of reconstruction parameters found for detector %s",fgkDetectorName[iDet])); dynamic_cast(recoParamObj)->SetAsDefault(); fRecoParam.AddDetRecoParam(iDet,dynamic_cast(recoParamObj)); } @@ -2940,9 +2972,12 @@ Bool_t AliReconstruction::InitRecoParams() isOK = kFALSE; } entry->SetOwner(0); + AliCDBManager::Instance()->UnloadFromCache(path.GetPath()); } } + if (AliDebugLevel() > 0) fRecoParam.Print(); + return isOK; } @@ -2993,6 +3028,7 @@ Bool_t AliReconstruction::GetEventInfo() return kFALSE; } + UChar_t clustmask = 0; TString trclasses; ULong64_t trmask = fEventInfo.GetTriggerMask(); const TObjArray& classesArray = config->GetClasses(); @@ -3000,17 +3036,23 @@ Bool_t AliReconstruction::GetEventInfo() 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()); + Int_t trindex = TMath::Nint(TMath::Log2(trclass->GetMask())); fesd->SetTriggerClass(trclass->GetName(),trindex); + if (fRawReader) fRawReader->LoadTriggerClass(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; @@ -3038,12 +3080,15 @@ const char *AliReconstruction::MatchDetectorList(const char *detectorList, UInt_ if ((detectorMask >> iDet) & 0x1) { TString det = AliDAQ::OfflineModuleName(iDet); if ((detList.CompareTo("ALL") == 0) || - detList.BeginsWith("ALL ") || - detList.EndsWith(" ALL") || - detList.Contains(" ALL ") || + ((detList.BeginsWith("ALL ") || + detList.EndsWith(" ALL") || + detList.Contains(" ALL ")) && + !(detList.BeginsWith("-"+det+" ") || + detList.EndsWith(" -"+det) || + detList.Contains(" -"+det+" "))) || (detList.CompareTo(det) == 0) || - detList.BeginsWith(det) || - detList.EndsWith(det) || + detList.BeginsWith(det+" ") || + detList.EndsWith(" "+det) || detList.Contains( " "+det+" " )) { if (!resultList.EndsWith(det + " ")) { resultList += det; @@ -3057,12 +3102,15 @@ const char *AliReconstruction::MatchDetectorList(const char *detectorList, UInt_ 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.BeginsWith("ALL ") || + detList.EndsWith(" ALL") || + detList.Contains(" ALL ")) && + !(detList.BeginsWith("-"+hltDet+" ") || + detList.EndsWith(" -"+hltDet) || + detList.Contains(" -"+hltDet+" "))) || (detList.CompareTo(hltDet) == 0) || - detList.BeginsWith(hltDet) || - detList.EndsWith(hltDet) || + detList.BeginsWith(hltDet+" ") || + detList.EndsWith(" "+hltDet) || detList.Contains( " "+hltDet+" " )) { resultList += hltDet; } @@ -3071,3 +3119,37 @@ const char *AliReconstruction::MatchDetectorList(const char *detectorList, UInt_ 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()); +} +