X-Git-Url: http://git.uio.no/git/?p=u%2Fmrichter%2FAliRoot.git;a=blobdiff_plain;f=HLT%2Frec%2FAliHLTReconstructor.cxx;h=7fdab9b0316b38dcbc244db92d128dd30ced95d0;hp=c409c782097deb225bb07b87de12c26903ff6ec6;hb=03ed6463b5267b974da6df1fbb3a4f32bd37984e;hpb=3dd8541e6259dd360fb0e44f5535ca09a53d522c diff --git a/HLT/rec/AliHLTReconstructor.cxx b/HLT/rec/AliHLTReconstructor.cxx index c409c782097..7fdab9b0316 100644 --- a/HLT/rec/AliHLTReconstructor.cxx +++ b/HLT/rec/AliHLTReconstructor.cxx @@ -1,11 +1,10 @@ // $Id$ //************************************************************************** -//* This file is property of and copyright by the ALICE HLT Project * +//* This file is property of and copyright by the * //* ALICE Experiment at CERN, All rights reserved. * //* * //* Primary Authors: Matthias Richter * -//* for The ALICE HLT Project. * //* * //* Permission to use, copy, modify and distribute this software and its * //* documentation strictly for non-commercial purposes is hereby granted * @@ -16,15 +15,21 @@ //* provided "as is" without express or implied warranty. * //************************************************************************** -/** @file AliHLTReconstructor.cxx - @author Matthias Richter - @date - @brief Binding class for HLT reconstruction in AliRoot. */ +// @file AliHLTReconstructor.cxx +// @author Matthias Richter +// @date +// @brief Binding class for HLT reconstruction in AliRoot +// Implements bot the interface to run HLT chains embedded into +// AliReconstruction and the unpacking and treatment of HLTOUT #include #include #include "TFile.h" #include "TTree.h" +#include "TObject.h" +#include "TObjArray.h" +#include "TClass.h" +#include "TStreamerInfo.h" #include "AliHLTReconstructor.h" #include "AliLog.h" #include "AliRawReader.h" @@ -33,25 +38,40 @@ #include "AliHLTOUTRawReader.h" #include "AliHLTOUTDigitReader.h" #include "AliHLTEsdManager.h" - +#include "AliHLTPluginBase.h" +#include "AliHLTMisc.h" +#include "AliCDBManager.h" +#include "AliCDBEntry.h" +#include "AliHLTMessage.h" +#include "AliCentralTrigger.h" +#include "AliTriggerConfiguration.h" +#include "AliTriggerClass.h" +#include "AliTriggerCluster.h" +#include "AliDAQ.h" +#include "AliRunLoader.h" +#include "AliRunInfo.h" + +class AliCDBEntry; + +/** ROOT macro for the implementation of ROOT specific class methods */ ClassImp(AliHLTReconstructor) AliHLTReconstructor::AliHLTReconstructor() - : - AliReconstructor(), - AliHLTReconstructorBase(), - fFctProcessHLTOUT(NULL), - fpEsdManager(NULL) + : AliReconstructor() + , fpEsdManager(NULL) + , fpPluginBase(new AliHLTPluginBase) + , fFlags(0) + , fProcessingStep(kProcessingStepUndefined) { //constructor } AliHLTReconstructor::AliHLTReconstructor(const char* options) - : - AliReconstructor(), - AliHLTReconstructorBase(), - fFctProcessHLTOUT(NULL), - fpEsdManager(NULL) + : AliReconstructor() + , fpEsdManager(NULL) + , fpPluginBase(new AliHLTPluginBase) + , fFlags(0) + , fProcessingStep(kProcessingStepUndefined) { //constructor if (options) Init(options); @@ -61,17 +81,22 @@ AliHLTReconstructor::~AliHLTReconstructor() { //destructor - AliHLTSystem* pSystem=GetInstance(); + if (fpEsdManager) AliHLTEsdManager::Delete(fpEsdManager); + fpEsdManager=NULL; + + if (fpPluginBase) { + AliHLTSystem* pSystem=fpPluginBase->GetInstance(); if (pSystem) { - AliDebug(0, Form("delete HLT system: status %#x", pSystem->GetStatusFlags())); + AliDebug(0, Form("terminate HLT system: status %#x", pSystem->GetStatusFlags())); if (pSystem->CheckStatus(AliHLTSystem::kStarted)) { // send specific 'event' to execute the stop sequence pSystem->Reconstruct(0, NULL, NULL); } } + delete fpPluginBase; + } + fpPluginBase=NULL; - if (fpEsdManager) delete fpEsdManager; - fpEsdManager=NULL; } void AliHLTReconstructor::Init(const char* options) @@ -84,7 +109,12 @@ void AliHLTReconstructor::Init(const char* options) void AliHLTReconstructor::Init() { // init the reconstructor - AliHLTSystem* pSystem=GetInstance(); + if (!fpPluginBase) { + AliError("internal memory error: can not get AliHLTSystem instance from plugin"); + return; + } + + AliHLTSystem* pSystem=fpPluginBase->GetInstance(); if (!pSystem) { AliError("can not create AliHLTSystem object"); return; @@ -94,10 +124,11 @@ void AliHLTReconstructor::Init() return; } + TString esdManagerOptions; + // the options scan has been moved to AliHLTSystem, the old code // here is kept to be able to run an older version of the HLT code // with newer AliRoot versions. - TString libs(""); TString option = GetOption(); TObjArray* pTokens=option.Tokenize(" "); option=""; @@ -119,9 +150,19 @@ void AliHLTReconstructor::Init() } } else if (token.Contains("alilog=off")) { pSystem->SwitchAliLog(0); - } else if (token.BeginsWith("lib") && token.EndsWith(".so")) { - libs+=token; - libs+=" "; + } else if (token.CompareTo("ignore-hltout")==0) { + fFlags|=kAliHLTReconstructorIgnoreHLTOUT; + } else if (token.CompareTo("run-online-config")==0) { + fFlags|=kAliHLTReconstructorIgnoreHLTOUT; + if (option.Length()>0) option+=" "; + option+=token; + } else if (token.CompareTo("ignore-ctp")==0) { + fFlags|=kAliHLTReconstructorIgnoreCTP; + } else if (token.Contains("esdmanager=")) { + token.ReplaceAll("esdmanager=", ""); + token.ReplaceAll(","," "); + token.ReplaceAll("'",""); + esdManagerOptions=token; } else { if (option.Length()>0) option+=" "; option+=token; @@ -130,24 +171,24 @@ void AliHLTReconstructor::Init() delete pTokens; } - if (!libs.IsNull() && - (!pSystem->CheckStatus(AliHLTSystem::kLibrariesLoaded)) && - (pSystem->LoadComponentLibraries(libs.Data())<0)) { - AliError("error while loading HLT libraries"); - return; + TString ecsParam; + TString ctpParam; + if ((fFlags&kAliHLTReconstructorIgnoreCTP)==0 && + BuildCTPTriggerClassString(ctpParam)>=0) { + if (!ecsParam.IsNull()) ecsParam+=";"; + ecsParam+="CTP_TRIGGER_CLASS="; + ecsParam+=ctpParam; + } + + if (!ecsParam.IsNull()) { + option+=" ECS="; + option+=ecsParam; } if (!pSystem->CheckStatus(AliHLTSystem::kReady)) { - typedef int (*AliHLTSystemSetOptions)(AliHLTSystem* pInstance, const char* options); - gSystem->Load("libHLTinterface.so"); - AliHLTSystemSetOptions pFunc=(AliHLTSystemSetOptions)(gSystem->DynFindSymbol("libHLTinterface.so", "AliHLTSystemSetOptions")); - if (pFunc) { - if ((pFunc)(pSystem, option.Data())<0) { + pSystem->SetDetectorMask(GetRunInfo()->GetDetectorMask()); + if (pSystem->ScanOptions(option.Data())<0) { AliError("error setting options for HLT system"); - return; - } - } else if (option.Length()>0) { - AliError(Form("version of HLT system does not support the options \'%s\'", option.Data())); return; } if ((pSystem->Configure())<0) { @@ -156,52 +197,163 @@ void AliHLTReconstructor::Init() } } - gSystem->Load("libHLTinterface.so"); - fFctProcessHLTOUT=gSystem->DynFindSymbol("libHLTinterface.so", "AliHLTSystemProcessHLTOUT"); + fpEsdManager=AliHLTEsdManager::New(); + if (fpEsdManager) { + fpEsdManager->SetOption(esdManagerOptions.Data()); + } - fpEsdManager=new AliHLTEsdManager; + AliHLTMisc::Instance().InitStreamerInfos(fgkCalibStreamerInfoEntry); +} + +void AliHLTReconstructor::Terminate() +{ + /// overloaded from AliReconstructor: terminate event processing + + // indicate step 'Terminate' + SetProcessingStep(kProcessingStepTerminate); + + if (fpPluginBase) { + AliHLTSystem* pSystem=fpPluginBase->GetInstance(); + if (pSystem) { + // 2012-04-02 + // clean up the HLTOUT instance if still existing, currently FinishEvent + // is not called at the end of the event processing and the cleanup + // needs to be done here to avoid a warning message. Later it can be + // declared a malfunction if the HLTOUT instance is still existing at + // this point. + AliHLTOUT* pHLTOUT=NULL; + pSystem->InvalidateHLTOUT(&pHLTOUT); + if (pHLTOUT) { + pHLTOUT->Reset(); + delete pHLTOUT; + pHLTOUT=NULL; + } + + AliDebug(0, Form("terminate HLT system: status %#x", pSystem->GetStatusFlags())); + if (pSystem->CheckStatus(AliHLTSystem::kStarted)) { + // send specific 'event' to execute the stop sequence + pSystem->Reconstruct(0, NULL, NULL); + } + } + } +} + +void AliHLTReconstructor::FinishEvent() +{ + /// overloaded from AliReconstructor: finish current event + if (!fpPluginBase) return; + + // indicate step 'FinishEvent' + SetProcessingStep(kProcessingStepFinishEvent); + + AliInfo("finishing event"); + AliHLTSystem* pSystem=fpPluginBase->GetInstance(); + if (pSystem) { + // this is the end of the lifetime of the HLTOUT instance + // called after all other modules have been reconstructed + AliHLTOUT* pHLTOUT=NULL; + pSystem->InvalidateHLTOUT(&pHLTOUT); + if (pHLTOUT) { + pHLTOUT->Reset(); + delete pHLTOUT; + pHLTOUT=NULL; + } + } } -void AliHLTReconstructor::Reconstruct(AliRawReader* /*rawReader*/, TTree* /*clustersTree*/) const +const char* AliHLTReconstructor::fgkCalibStreamerInfoEntry="HLT/Calib/StreamerInfo"; + +void AliHLTReconstructor::Reconstruct(AliRawReader* rawReader, TTree* /*clustersTree*/) const { // reconstruction of real data without writing of ESD // For each event, HLT reconstruction chains can be executed and // added to the existing HLTOUT data // The HLTOUT data is finally processed in FillESD - AliHLTSystem* pSystem=GetInstance(); - AliInfo("running raw data reconstruction"); -} -void AliHLTReconstructor::FillESD(AliRawReader* rawReader, TTree* /*clustersTree*/, - AliESDEvent* esd) const -{ - // reconstruct real data and fill ESD - if (!rawReader || !esd) { - AliError("missing raw reader or esd object"); + if (!fpPluginBase) { + AliError("internal memory error: can not get AliHLTSystem instance from plugin"); return; } - //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! - // code needs to be moved back to Reconstruct as soon es HLT loader is implemented int iResult=0; - AliHLTSystem* pSystem=GetInstance(); + AliHLTSystem* pSystem=fpPluginBase->GetInstance(); + if (pSystem) { + AliHLTOUT* pHLTOUT=NULL; + pSystem->InvalidateHLTOUT(&pHLTOUT); + if (pHLTOUT) { + // at this stage we always have a new event, regardless state of + // fProcessingStep; build the HLTOUT instance from scratch + pHLTOUT->Reset(); + delete pHLTOUT; + pHLTOUT=NULL; + } if (pSystem->CheckStatus(AliHLTSystem::kError)) { - AliError("HLT system in error state"); + // this is the highest level where an error can be detected, no error + // codes can be returned + AliFatal("HLT system in error state"); return; } if (!pSystem->CheckStatus(AliHLTSystem::kReady)) { AliError("HLT system in wrong state"); return; } + + // indicate the local reconstruction step + SetProcessingStep(kProcessingStepLocal); + + // init the HLTOUT instance for the current event + // not nice. Have to query the global run loader to get the current event no. + Int_t eventNo=-1; + AliRunLoader* runloader = AliRunLoader::Instance(); + if (runloader) { + eventNo=runloader->GetEventNumber(); + } + if (eventNo>=0) { + AliRawReader* input=NULL; + if ((fFlags&kAliHLTReconstructorIgnoreHLTOUT) == 0 ) { + input=rawReader; + } + pHLTOUT=new AliHLTOUTRawReader(input, eventNo, fpEsdManager); + if (pHLTOUT) { + if (pHLTOUT->Init()>=0) { + pSystem->InitHLTOUT(pHLTOUT); + } else { + AliError("error : initialization of HLTOUT handler failed"); + } + } else { + AliError("memory allocation failed: can not create AliHLTOUT object"); + } + } else { + AliError("can not get event number"); + } + if ((iResult=pSystem->Reconstruct(1, NULL, rawReader))>=0) { } } - //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +} + +void AliHLTReconstructor::FillESD(AliRawReader* rawReader, TTree* /*clustersTree*/, + AliESDEvent* esd) const +{ + // reconstruct real data and fill ESD + if (!rawReader || !esd) { + AliError("missing raw reader or esd object"); + return; + } + + if (!fpPluginBase) { + AliError("internal memory error: can not get AliHLTSystem instance from plugin"); + return; + } + + AliHLTSystem* pSystem=fpPluginBase->GetInstance(); if (pSystem) { if (pSystem->CheckStatus(AliHLTSystem::kError)) { - AliError("HLT system in error state"); + // this is the highest level where an error can be detected, no error + // codes can be returned + AliFatal("HLT system in error state"); return; } if (!pSystem->CheckStatus(AliHLTSystem::kReady)) { @@ -210,10 +362,38 @@ void AliHLTReconstructor::FillESD(AliRawReader* rawReader, TTree* /*clustersTree } pSystem->FillESD(-1, NULL, esd); - AliHLTOUTRawReader* pHLTOUT=new AliHLTOUTRawReader(rawReader, esd->GetEventNumberInFile(), fpEsdManager); - if (pHLTOUT) { - ProcessHLTOUT(pHLTOUT, esd); + // the HLTOUT handler has either been created in the AliHLTReconstructor::Reconstruct + // step of this event or is created now. In either case the instance is deleted after + // the processing + AliHLTOUT* pHLTOUT=NULL; + pSystem->InvalidateHLTOUT(&pHLTOUT); + if (pHLTOUT && fProcessingStep!=kProcessingStepLocal) { + // this is a new event, if local reconstruction would have been executed + // the HLTOUT instance would have been created for the current event already, + // in all other cases one has to create the HLTOUT instance here + pHLTOUT->Reset(); delete pHLTOUT; + pHLTOUT=NULL; + } + if (!pHLTOUT) { + AliRawReader* input=NULL; + if ((fFlags&kAliHLTReconstructorIgnoreHLTOUT) == 0 ) { + input=rawReader; + } + pHLTOUT=new AliHLTOUTRawReader(input, esd->GetEventNumberInFile(), fpEsdManager); + } + + // indicate step 'ESD filling' + SetProcessingStep(kProcessingStepESD); + + if (pHLTOUT) { + ProcessHLTOUT(pHLTOUT, esd, (pSystem->GetGlobalLoggingLevel()&kHLTLogDebug)!=0); + // 2012-03-30: a change in the module sequence of AliReconstruction is soon + // going to be applied: HLT reconstruction is executed fully (i.e. both local + // reconstruction and FillESD) before all the other modules. In order to make the + // HLTOUT data available for other modules it is kept here and released in the method + // FinishEvent + pSystem->InitHLTOUT(pHLTOUT); } else { AliError("error creating HLTOUT handler"); } @@ -224,9 +404,55 @@ void AliHLTReconstructor::Reconstruct(TTree* /*digitsTree*/, TTree* /*clustersTr { // reconstruct simulated data - // all reconstruction has been moved to FillESD - //AliReconstructor::Reconstruct(digitsTree,clustersTree); - AliInfo("running digit data reconstruction"); + AliHLTSystem* pSystem=fpPluginBase->GetInstance(); + + if (pSystem) { + // create the HLTOUT instance in order to be available for other detector reconstruction + // first cleanup any existing instance + AliHLTOUT* pHLTOUT=NULL; + pSystem->InvalidateHLTOUT(&pHLTOUT); + if (pHLTOUT) { + // at this stage we always have a new event, regardless state of + // fProcessingStep; build the HLTOUT instance from scratch + pHLTOUT->Reset(); + delete pHLTOUT; + pHLTOUT=NULL; + } + + // indicate the local reconstruction step + SetProcessingStep(kProcessingStepLocal); + + // not nice. Have to query the global run loader to get the current event no. + // This is related to the missing AliLoader for HLT. + // Since AliReconstruction can not provide a digits tree, the file needs to be accessed + // explicitely, and the corresponding event needs to be selected. + Int_t eventNo=-1; + AliRunLoader* runloader = AliRunLoader::Instance(); + if (runloader) { + eventNo=runloader->GetEventNumber(); + } + if (eventNo>=0) { + const char* digitfile=NULL; + if ((fFlags&kAliHLTReconstructorIgnoreHLTOUT) == 0 ) { + digitfile="HLT.Digits.root"; + } + + pHLTOUT=new AliHLTOUTDigitReader(eventNo, fpEsdManager, digitfile); + if (pHLTOUT) { + if (pHLTOUT->Init()>=0) { + pSystem->InitHLTOUT(pHLTOUT); + } else { + AliError("error : initialization of HLTOUT handler failed"); + } + } else { + AliError("memory allocation failed: can not create AliHLTOUT object"); + } + } else { + AliError("can not get event number"); + } + + // all data processing happens in FillESD + } } void AliHLTReconstructor::FillESD(TTree* /*digitsTree*/, TTree* /*clustersTree*/, AliESDEvent* esd) const @@ -239,7 +465,12 @@ void AliHLTReconstructor::FillESD(TTree* /*digitsTree*/, TTree* /*clustersTree*/ TString option = GetOption(); if (!option.IsNull() && (option.Contains("config=") || option.Contains("chains="))) { - AliWarning(Form("HLT reconstruction of simulated data takes place in AliSimulation\n" + AliWarning(Form("You are trying to run a custom HLT chain on digits data.\n\n" + "HLT reconstruction can be run embedded into AliReconstruction from\n" + "raw data (real or simulated)). Reconstruction of digit data takes\n" + "place in AliSimulation, appropriate input conversion is needed to\n" + "feed data from the detector digits into the HLT chain.\n" + "Consider running embedded into AliSimulation.\n" " /*** run macro *****************************************/\n" " AliSimulation sim;\n" " sim.SetRunHLT(\"%s\");\n" @@ -248,12 +479,20 @@ void AliHLTReconstructor::FillESD(TTree* /*digitsTree*/, TTree* /*clustersTree*/ " sim.SetMakeSDigits(\"\");\n" " sim.SetMakeDigitsFromHits(\"\");\n" " sim.Run();\n" - " /*********************************************************/", option.Data())); + " /*********************************************************/\n\n", + option.Data())); } - AliHLTSystem* pSystem=GetInstance(); + if (!fpPluginBase) { + AliError("internal memory error: can not get AliHLTSystem instance from plugin"); + return; + } + + AliHLTSystem* pSystem=fpPluginBase->GetInstance(); if (pSystem) { if (pSystem->CheckStatus(AliHLTSystem::kError)) { - AliError("HLT system in error state"); + // this is the highest level where an error can be detected, no error + // codes can be returned + AliFatal("HLT system in error state"); return; } if (!pSystem->CheckStatus(AliHLTSystem::kReady)) { @@ -261,21 +500,54 @@ void AliHLTReconstructor::FillESD(TTree* /*digitsTree*/, TTree* /*clustersTree*/ return; } - AliHLTOUTDigitReader* pHLTOUT=new AliHLTOUTDigitReader(esd->GetEventNumberInFile(), fpEsdManager); - if (pHLTOUT) { - ProcessHLTOUT(pHLTOUT, esd); + // the HLTOUT handler has either been created in the AliHLTReconstructor::Reconstruct + // step of this event or is created now. In either case the instance is deleted after + // the processing + AliHLTOUT* pHLTOUT=NULL; + pSystem->InvalidateHLTOUT(&pHLTOUT); + if (pHLTOUT && fProcessingStep!=kProcessingStepLocal) { + // this is a new event, if local reconstruction would have been executed + // the HLTOUT instance would have been created for the current event already, + // in all other cases one has to create the HLTOUT instance here + pHLTOUT->Reset(); delete pHLTOUT; + pHLTOUT=NULL; + } + if (!pHLTOUT) { + const char* digitfile=NULL; + if ((fFlags&kAliHLTReconstructorIgnoreHLTOUT) == 0 ) { + digitfile="HLT.Digits.root"; + } + pHLTOUT=new AliHLTOUTDigitReader(esd->GetEventNumberInFile(), fpEsdManager, digitfile); + } + + // indicate step 'ESD filling' + SetProcessingStep(kProcessingStepESD); + + if (pHLTOUT) { + ProcessHLTOUT(pHLTOUT, esd, (pSystem->GetGlobalLoggingLevel()&kHLTLogDebug)!=0); + // 2012-03-30: a change in the module sequence of AliReconstruction is soon + // going to be applied: HLT reconstruction is executed fully (i.e. both local + // reconstruction and FillESD) before all the other modules. In order to make the + // HLTOUT data available for other modules it is kept here and released in the method + // FinishEvent + pSystem->InitHLTOUT(pHLTOUT); } else { AliError("error creating HLTOUT handler"); } } } -void AliHLTReconstructor::ProcessHLTOUT(AliHLTOUT* pHLTOUT, AliESDEvent* esd) const +void AliHLTReconstructor::ProcessHLTOUT(AliHLTOUT* pHLTOUT, AliESDEvent* esd, bool bVerbose) const { // treatment of simulated or real HLTOUT data if (!pHLTOUT) return; - AliHLTSystem* pSystem=GetInstance(); + if (!fpPluginBase) { + AliError("internal memory error: can not get AliHLTSystem instance from plugin"); + return; + } + + AliHLTSystem* pSystem=fpPluginBase->GetInstance(); if (!pSystem) { AliError("error getting HLT system instance"); return; @@ -286,13 +558,38 @@ void AliHLTReconstructor::ProcessHLTOUT(AliHLTOUT* pHLTOUT, AliESDEvent* esd) co return; } - if (fFctProcessHLTOUT) { - typedef int (*AliHLTSystemProcessHLTOUT)(AliHLTSystem* pInstance, AliHLTOUT* pHLTOUT, AliESDEvent* esd); - AliHLTSystemProcessHLTOUT pFunc=(AliHLTSystemProcessHLTOUT)fFctProcessHLTOUT; - if ((pFunc)(pSystem, pHLTOUT, esd)<0) { - AliError("error processing HLTOUT"); + if (bVerbose) + PrintHLTOUTContent(pHLTOUT); + + int blockindex=pHLTOUT->SelectFirstDataBlock(kAliHLTDataTypeStreamerInfo); + if (blockindex>=0) { + const AliHLTUInt8_t* pBuffer=NULL; + AliHLTUInt32_t size=0; + if (pHLTOUT->GetDataBuffer(pBuffer, size)>=0) { + TObject* pObject=AliHLTMessage::Extract(pBuffer, size); + if (pObject) { + TObjArray* pArray=dynamic_cast(pObject); + if (pArray) { + AliHLTMisc::Instance().InitStreamerInfos(pArray); + } else { + AliError(Form("wrong class type of streamer info list: expected TObjArray, but object is of type %s", pObject->Class()->GetName())); + } + } else { + AliError(Form("failed to extract object from data block of type %s", AliHLTComponent::DataType2Text(kAliHLTDataTypeStreamerInfo).c_str())); + } + } else { + AliError(Form("failed to get data buffer for block of type %s", AliHLTComponent::DataType2Text(kAliHLTDataTypeStreamerInfo).c_str())); } } + + if (pSystem->ProcessHLTOUT(pHLTOUT, esd)<0) { + AliError("error processing HLTOUT"); + } + + if (bVerbose && esd) { + AliInfo("HLT ESD content:"); + esd->Print(); + } } void AliHLTReconstructor::ProcessHLTOUT(const char* digitFile, AliESDEvent* pEsd) const @@ -318,8 +615,7 @@ void AliHLTReconstructor::ProcessHLTOUT(const char* digitFile, AliESDEvent* pEsd AliHLTOUTDigitReader* pHLTOUT=new AliHLTOUTDigitReader(event, fpEsdManager, digitFile); if (pHLTOUT) { AliInfo(Form("event %d", event)); - ProcessHLTOUT(pHLTOUT, pEsd); - PrintHLTOUTContent(pHLTOUT); + ProcessHLTOUT(pHLTOUT, pEsd, true); delete pHLTOUT; } else { AliError("error creating HLTOUT handler"); @@ -337,8 +633,21 @@ void AliHLTReconstructor::ProcessHLTOUT(AliRawReader* pRawReader, AliESDEvent* p AliHLTOUTRawReader* pHLTOUT=new AliHLTOUTRawReader(pRawReader, event, fpEsdManager); if (pHLTOUT) { AliInfo(Form("event %d", event)); - ProcessHLTOUT(pHLTOUT, pEsd); - PrintHLTOUTContent(pHLTOUT); + // the two event fields contain: period - orbit - bunch crossing counter + // id[0] id[1] + // |32 0|32 0| + // + // | 28 bit | 24 bit | 12| + // period orbit bcc + AliHLTUInt64_t eventId=0; + const UInt_t* rawreaderEventId=pRawReader->GetEventId(); + if (rawreaderEventId) { + eventId=rawreaderEventId[0]; + eventId=eventId<<32; + eventId|=rawreaderEventId[1]; + } + AliInfo(Form("Event Id from rawreader:\t 0x%016llx", eventId)); + ProcessHLTOUT(pHLTOUT, pEsd, true); delete pHLTOUT; } else { AliError("error creating HLTOUT handler"); @@ -352,6 +661,7 @@ void AliHLTReconstructor::PrintHLTOUTContent(AliHLTOUT* pHLTOUT) const if (!pHLTOUT) return; int iResult=0; + AliInfo(Form("Event Id from hltout:\t 0x%016llx", pHLTOUT->EventId())); for (iResult=pHLTOUT->SelectFirstDataBlock(); iResult>=0; iResult=pHLTOUT->SelectNextDataBlock()) { @@ -367,3 +677,55 @@ void AliHLTReconstructor::PrintHLTOUTContent(AliHLTOUT* pHLTOUT) const AliInfo(Form(" %s 0x%x: size %d", AliHLTComponent::DataType2Text(dt).c_str(), spec, size)); } } + +int AliHLTReconstructor::BuildCTPTriggerClassString(TString& triggerclasses) const +{ + // build the CTP trigger class string from the OCDB entry of the CTP trigger + int iResult=0; + + triggerclasses.Clear(); + AliCentralTrigger* pCTP = new AliCentralTrigger(); + AliTriggerConfiguration *config=NULL; + TString configstr(""); + if (pCTP->LoadConfiguration(configstr) && + (config = pCTP->GetConfiguration())!=NULL) { + const TObjArray& classesArray = config->GetClasses(); + int nclasses = classesArray.GetEntriesFast(); + for( int iclass=0; iclass < nclasses; iclass++ ) { + AliTriggerClass* trclass = NULL; + if (classesArray.At(iclass) && (trclass=dynamic_cast(classesArray.At(iclass)))!=NULL) { + TString entry; + int trindex = TMath::Nint(TMath::Log2(trclass->GetMask())); + entry.Form("%02d:%s:", trindex, trclass->GetName()); + AliTriggerCluster* cluster=NULL; + TObject* clusterobj=config->GetClusters().FindObject(trclass->GetCluster()); + if (clusterobj && (cluster=dynamic_cast(clusterobj))!=NULL) { + TString detectors=cluster->GetDetectorsInCluster(); + TObjArray* pTokens=detectors.Tokenize(" "); + if (pTokens) { + for (int dix=0; dixGetEntriesFast(); dix++) { + int id=AliDAQ::DetectorID(((TObjString*)pTokens->At(dix))->GetString()); + if (id>=0) { + TString detstr; detstr.Form("%s%02d", dix>0?"-":"", id); + entry+=detstr; + } else { + AliError(Form("invalid detector name extracted from trigger cluster: %s (%s)", ((TObjString*)pTokens->At(dix))->GetString().Data(), detectors.Data())); + iResult=-EPROTO; + break; + } + } + delete pTokens; + } + } else { + AliError(Form("can not find trigger cluster %s in config", trclass->GetCluster()?trclass->GetCluster()->GetName():"NULL")); + iResult=-EPROTO; + break; + } + if (!triggerclasses.IsNull()) triggerclasses+=","; + triggerclasses+=entry; + } + } + } + + return iResult; +}