X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=HLT%2FBASE%2FAliHLTComponent.cxx;h=2d8f59780152c9353d226d27f00554af026b0847;hb=6f4231a1ef6790b65bc785fdc34c5e56c6e8c176;hp=f5b2902e0c33905b538c94e22151242e2cdbf01f;hpb=c57201be6d84bd3917f403ef27dff3d1716bcd90;p=u%2Fmrichter%2FAliRoot.git

diff --git a/HLT/BASE/AliHLTComponent.cxx b/HLT/BASE/AliHLTComponent.cxx
index f5b2902e0c3..2d8f5978015 100644
--- a/HLT/BASE/AliHLTComponent.cxx
+++ b/HLT/BASE/AliHLTComponent.cxx
@@ -36,6 +36,7 @@ using namespace std;
 #include "TObjectTable.h"
 #include "TClass.h"
 #include "TStopwatch.h"
+#include "TFormula.h"
 #include "AliHLTMemoryFile.h"
 #include "AliHLTMisc.h"
 #include <cassert>
@@ -90,6 +91,7 @@ AliHLTComponent::AliHLTComponent()
   fEventDoneDataSize(0),
   fCompressionLevel(ALIHLTCOMPONENT_DEFAULT_OBJECT_COMPRESSION)
   , fLastObjectSize(0)
+  , fpTriggerClasses(NULL)
 {
   // see header file for class documentation
   // or
@@ -130,6 +132,13 @@ AliHLTComponent::~AliHLTComponent()
   }
   if (fEventDoneData)
     delete [] reinterpret_cast<AliHLTUInt8_t*>( fEventDoneData );
+  fEventDoneData=NULL;
+
+  if (fpTriggerClasses) {
+    fpTriggerClasses->Delete();
+    delete fpTriggerClasses;
+  }
+  fpTriggerClasses=NULL;
 }
 
 AliHLTComponentHandler* AliHLTComponent::fgpComponentHandler=NULL;
@@ -151,7 +160,7 @@ int AliHLTComponent::UnsetGlobalComponentHandler()
   return SetGlobalComponentHandler(NULL,1);
 }
 
-int AliHLTComponent::Init(const AliHLTAnalysisEnvironment* comenv, void* environParam, int argc, const char** argv )
+int AliHLTComponent::SetComponentEnvironment(const AliHLTAnalysisEnvironment* comenv, void* environParam)
 {
   // see header file for function documentation
   HLTLogKeyword(fChainId.c_str());
@@ -162,6 +171,17 @@ int AliHLTComponent::Init(const AliHLTAnalysisEnvironment* comenv, void* environ
     fEnvironment.fStructSize=sizeof(AliHLTAnalysisEnvironment);
     fEnvironment.fParam=environParam;
   }
+  return iResult;
+}
+
+int AliHLTComponent::Init(const AliHLTAnalysisEnvironment* comenv, void* environParam, int argc, const char** argv )
+{
+  // see header file for function documentation
+  HLTLogKeyword(fChainId.c_str());
+  int iResult=0;
+  if (comenv) {
+    SetComponentEnvironment(comenv, environParam);
+  }
   fComponentArgs="";
   const char** pArguments=NULL;
   int iNofChildArgs=0;
@@ -253,11 +273,21 @@ int AliHLTComponent::Deinit()
   int iResult=0;
   iResult=DoDeinit();
   if (fpRunDesc) {
-    HLTWarning("did not receive EOR for run %d", fpRunDesc->fRunNo);
+    // TODO: the warning should be kept, but the condition is wrong since the
+    // AliHLTRunDesc is set before the SOR event in the SetRunDescription
+    // method. A couple of state flags should be defined but that is a bit more
+    // work to do. For the moment disable the warning (2009-07-01)
+    //HLTWarning("did not receive EOR for run %d", fpRunDesc->fRunNo);
     AliHLTRunDesc* pRunDesc=fpRunDesc;
     fpRunDesc=NULL;
     delete pRunDesc;
   }
+  if (fpTriggerClasses) {
+    fpTriggerClasses->Delete();
+    delete fpTriggerClasses;
+  }
+  fpTriggerClasses=NULL;
+
   fEventCount=0;
   return iResult;
 }
@@ -266,11 +296,14 @@ int AliHLTComponent::InitCDB(const char* cdbPath, AliHLTComponentHandler* pHandl
 {
   // see header file for function documentation
   int iResult=0;
+  HLTInfo("Using CDB: %s", cdbPath);
   if (pHandler) {
   // I have to think about separating the library handling from the
-  // component handler. Requiring the component hanlder here is not
+  // component handler. Requiring the component handler here is not
   // the cleanest solution.
-  // We presume the library already to be loaded
+  // We presume the library already to be loaded, which is the case
+  // because it is loaded in the initialization of the logging functionality
+  //
   // find the symbol
   AliHLTMiscInitCDB_t pFunc=(AliHLTMiscInitCDB_t)pHandler->FindSymbol(ALIHLTMISC_LIBRARY, ALIHLTMISC_INIT_CDB);
   if (pFunc) {
@@ -363,6 +396,100 @@ int AliHLTComponent::SetComponentDescription(const char* desc)
   return iResult;
 }
 
+int AliHLTComponent::ConfigureFromArgumentString(int argc, const char** argv)
+{
+  // see header file for function documentation
+  int iResult=0;
+  vector<const char*> array;
+  TObjArray choppedArguments;
+  TString argument="";
+  int i=0;
+  for (i=0; i<argc && iResult>=0; i++) {
+    argument=argv[i];
+    if (argument.IsNull()) continue;
+    TObjArray* pTokens=argument.Tokenize(" ");
+    if (pTokens) {
+      if (pTokens->GetEntriesFast()>0) {
+	for (int n=0; n<pTokens->GetEntriesFast(); n++) {
+	  choppedArguments.AddLast(pTokens->At(n));
+	  TString data=((TObjString*)pTokens->At(n))->GetString();
+	  if (!data.IsNull()) {
+	    array.push_back(data.Data());
+	  }
+	}
+	pTokens->SetOwner(kFALSE);
+      }
+      delete pTokens;
+    }
+  }
+
+  for (i=0; (unsigned)i<array.size() && iResult>=0;) {
+    int result=ScanConfigurationArgument(array.size()-i, &array[i]);
+    if (result==0) {
+      HLTWarning("unknown component argument %s", array[i]);
+      i++;
+    } else if (result>0) {
+      i+=result;
+    } else {
+      iResult=result;
+      if (iResult==-EINVAL) {
+	HLTError("unknown argument %s", array[i]);
+      } else if (iResult==-EPROTO) {
+	HLTError("missing/wrong parameter for argument %s (%s)", array[i], (array.size()>(unsigned)i+1)?array[i+1]:"missing");
+      } else {
+	HLTError("scan of argument %s failed (%d)", array[i], iResult);
+      }
+    }
+  }
+
+  return iResult;
+}
+
+int AliHLTComponent::ConfigureFromCDBTObjString(const char* entries)
+{
+  // see header file for function documentation
+  int iResult=0;
+  TString arguments;
+  TString confEntries=entries;
+  TObjArray* pTokens=confEntries.Tokenize(" ");
+  if (pTokens) {
+    for (int n=0; n<pTokens->GetEntriesFast(); n++) {
+      const char* path=((TObjString*)pTokens->At(n))->GetString().Data();
+      const char* chainId=GetChainId();
+      HLTInfo("configure from entry %s, chain id %s", path, (chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
+      TObject* pOCDBObject = LoadAndExtractOCDBObject(path);
+      if (pOCDBObject) {
+	TObjString* pString=dynamic_cast<TObjString*>(pOCDBObject);
+	if (pString) {
+	  HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
+	  arguments+=pString->GetString().Data();
+	  arguments+=" ";
+	} else {
+	  HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
+	  iResult=-EINVAL;
+	}
+      } else {
+	HLTError("can not fetch object \"%s\" from OCDB", path);
+	iResult=-ENOENT;
+      }
+    }
+    delete pTokens;
+  }
+  if (iResult>=0 && !arguments.IsNull())  {
+    const char* array=arguments.Data();
+    iResult=ConfigureFromArgumentString(1, &array);
+  }
+  return iResult;
+}
+
+TObject* AliHLTComponent::LoadAndExtractOCDBObject(const char* path, int version, int subVersion)
+{
+  // see header file for function documentation
+  AliCDBEntry* pEntry=AliHLTMisc::Instance().LoadOCDBEntry(path, GetRunNo(), version, subVersion);
+  if (!pEntry) return NULL;
+  return AliHLTMisc::Instance().ExtractObject(pEntry);
+}
+
 int AliHLTComponent::DoInit( int /*argc*/, const char** /*argv*/)
 {
   // default implementation, childs can overload
@@ -391,6 +518,14 @@ int AliHLTComponent::ReadPreprocessorValues(const char* /*modules*/)
   return 0;
 }
 
+int AliHLTComponent::ScanConfigurationArgument(int /*argc*/, const char** /*argv*/)
+{
+  // default implementation, childs can overload
+  HLTLogKeyword("dummy");
+  HLTWarning("The function needs to be implemented by the component");
+  return 0;
+}
+
 int AliHLTComponent::StartOfRun()
 {
   // default implementation, childs can overload
@@ -540,9 +675,11 @@ int AliHLTComponent::ReserveEventDoneData( unsigned long size )
   // see header file for function documentation
   int iResult=0;
 
-  
-  if (size>fEventDoneDataSize) {
-    AliHLTComponentEventDoneData* newEDD = reinterpret_cast<AliHLTComponentEventDoneData*>( new AliHLTUInt8_t[ sizeof(AliHLTComponentEventDoneData)+size ] );
+  unsigned long capacity=fEventDoneDataSize;
+  if (fEventDoneData) capacity-=sizeof(AliHLTComponentEventDoneData)+fEventDoneData->fDataSize;
+  if (size>capacity) {
+    unsigned long newSize=sizeof(AliHLTComponentEventDoneData)+size+(fEventDoneDataSize-capacity);
+    AliHLTComponentEventDoneData* newEDD = reinterpret_cast<AliHLTComponentEventDoneData*>( new AliHLTUInt8_t[newSize] );
     if (!newEDD)
       return -ENOMEM;
     newEDD->fStructSize = sizeof(AliHLTComponentEventDoneData);
@@ -554,7 +691,7 @@ int AliHLTComponent::ReserveEventDoneData( unsigned long size )
       delete [] reinterpret_cast<AliHLTUInt8_t*>( fEventDoneData );
     }
     fEventDoneData = newEDD;
-    fEventDoneDataSize = size;
+    fEventDoneDataSize = newSize;
   }
   return iResult;
 
@@ -1440,6 +1577,7 @@ int AliHLTComponent::ProcessEvent( const AliHLTComponentEventData& evtData,
     int indexUpdtDCSEvent=-1;
     int indexSOREvent=-1;
     int indexEOREvent=-1;
+    int indexECSParamBlock=-1;
     for (unsigned int i=0; i<evtData.fBlockCnt && iResult>=0; i++) {
       if (fpInputBlocks[i].fDataType==kAliHLTDataTypeSOR) {
 	indexSOREvent=i;
@@ -1490,6 +1628,8 @@ int AliHLTComponent::ProcessEvent( const AliHLTComponentEventData& evtData,
       } else if (fpInputBlocks[i].fDataType==kAliHLTDataTypeComponentTable) {
 	forwardedBlocks.push_back(fpInputBlocks[i]);
 	parentComponentTables.push_back(fpInputBlocks[i].fSpecification);
+      } else if (fpInputBlocks[i].fDataType==kAliHLTDataTypeECSParam) {
+	indexECSParamBlock=i;
       } else {
 	// the processing function is called if there is at least one
 	// non-steering data block. Steering blocks are not filtered out
@@ -1523,6 +1663,26 @@ int AliHLTComponent::ProcessEvent( const AliHLTComponentEventData& evtData,
       } else {
 	iResult=-ENOMEM;
       }
+
+      if (indexECSParamBlock>=0) {
+	if (fpInputBlocks[indexECSParamBlock].fSize>0) {
+	  const char* param=reinterpret_cast<const char*>(fpInputBlocks[indexECSParamBlock].fPtr);
+	  TString paramString;
+	  if (param[fpInputBlocks[indexECSParamBlock].fSize-1]!=0) {
+	    HLTWarning("ECS parameter string not terminated");
+	    paramString.Insert(0, param, fpInputBlocks[indexECSParamBlock].fSize);
+	    paramString+="";
+	  } else {
+	    paramString=param;
+	  }
+	  ScanECSParam(paramString.Data());
+	} else {
+	  HLTWarning("empty ECS parameter received");
+	}
+      } else {
+	// TODO: later on we might throw a warning here since the CTP trigger classes
+	// should be mandatory
+      }
     }
     if (indexEOREvent>=0) {
       bAddComponentTableEntry=true;
@@ -1654,6 +1814,8 @@ int AliHLTComponent::ProcessEvent( const AliHLTComponentEventData& evtData,
     // no output blocks, set size to 0
     size=0;
   }
+
+  // reset the internal EventData struct
   FillEventData(fCurrentEventData);
   return iResult;
 }
@@ -2178,3 +2340,131 @@ int AliHLTComponent::LoggingVarargs(AliHLTComponentLogSeverity severity,
 
   return iResult;
 }
+
+int AliHLTComponent::ScanECSParam(const char* ecsParam)
+{
+  // see header file for function documentation
+
+  // format of the parameter string from ECS
+  // <command>;<parameterkey>=<parametervalue>;<parameterkey>=<parametervalue>;...
+  // search for a subset of the parameterkeys
+  int iResult=0;
+  TString string=ecsParam;
+  TObjArray* parameter=string.Tokenize(";");
+  if (parameter) {
+    for (int i=0; i<parameter->GetEntries(); i++) {
+      TString entry=((TObjString*)parameter->At(i))->GetString();
+      HLTDebug("scanning ECS entry: %s", entry.Data());
+      TObjArray* entryParams=entry.Tokenize("=");
+      if (entryParams) {
+	if (entryParams->GetEntries()>1) {
+	  if ((((TObjString*)entryParams->At(0))->GetString()).CompareTo("CTP_TRIGGER_CLASS")==0) {
+	    int result=InitCTPTriggerClasses((((TObjString*)entryParams->At(1))->GetString()).Data());
+	    if (iResult>=0 && result<0) iResult=result;
+	  } else {
+	    // TODO: scan the other parameters
+	    // e.g. consistency check of run number
+	  }
+	}
+	delete entryParams;
+      }
+    }
+    delete parameter;
+  }
+
+  return iResult;
+}
+
+int AliHLTComponent::InitCTPTriggerClasses(const char* ctpString)
+{
+  // see header file for function documentation
+  if (!ctpString) return -EINVAL;
+
+  if (fpTriggerClasses) {
+    fpTriggerClasses->Delete();
+  } else {
+    fpTriggerClasses=new TObjArray(gkNCTPTriggerClasses);
+  }
+  if (!fpTriggerClasses) return -ENOMEM;
+
+  // general format of the CTP_TRIGGER_CLASS parameter
+  // <bit position>:<Trigger class identifier string>:<detector-id-nr>-<detector-id-nr>-...,<bit position>:<Trigger class identifier string>:<detector-id-nr>-<detector-id-nr>-...,...
+  // the detector ids are ignored for the moment
+  HLTDebug(": %s", ctpString);
+  TString string=ctpString;
+  TObjArray* classEntries=string.Tokenize(",");
+  if (classEntries) {
+    for (int i=0; i<classEntries->GetEntries(); i++) {
+      TString entry=((TObjString*)classEntries->At(i))->GetString();
+      TObjArray* entryParams=entry.Tokenize(":");
+      if (entryParams) {
+	if (entryParams->GetEntries()==3 &&
+	    (((TObjString*)entryParams->At(0))->GetString()).IsDigit()) {
+	  int index=(((TObjString*)entryParams->At(0))->GetString()).Atoi();
+	  if (index<gkNCTPTriggerClasses) {
+	    fpTriggerClasses->AddAt(new TNamed("TriggerClass", (((TObjString*)entryParams->At(1))->GetString()).Data()), index);
+	  } else {
+	    // the trigger bitfield is fixed to 50 bits (gkNCTPTriggerClasses)
+	    HLTError("invalid trigger class entry %s, index width of trigger bitfield", entry.Data());
+	  }
+	} else {
+	  HLTError("invalid trigger class entry %s", entry.Data());
+	}
+	delete entryParams;
+      }
+    }
+    delete classEntries;
+  }
+  return 0;
+}
+
+bool AliHLTComponent::EvaluateCTPTriggerClass(const char* expression, AliHLTComponentTriggerData& trigData) const
+{
+  // see header file for function documentation
+  if (!fpTriggerClasses) {
+    HLTError("trigger classes not initialized");
+    return false;
+  }
+
+  if (trigData.fDataSize != sizeof(AliHLTEventTriggerData)) {
+    HLTError("invalid trigger data size: %d expected %d", trigData.fDataSize, sizeof(AliHLTEventTriggerData));
+    return false;
+  }
+
+  // trigger mask is 50 bit wide and is stored in word 5 and 6 of the CDH
+  AliHLTEventTriggerData* evtData=reinterpret_cast<AliHLTEventTriggerData*>(trigData.fData);
+  AliHLTUInt64_t triggerMask=evtData->fCommonHeader[6];
+  triggerMask<<=32;
+  triggerMask|=evtData->fCommonHeader[5];
+
+  // use a TFormula to interprete the expression
+  // all classname are replaced by '[n]' which means the n'th parameter in the formula
+  // the parameters are set to 0 or 1 depending on the bit in the trigger mask
+  //
+  // TODO: this will most likely fail for class names like 'base', 'baseA', 'baseB'
+  // the class names must be fully unique, none must be contained as substring in
+  // another class name. Probably not needed for the moment but needs to be extended.
+  vector<Double_t> par;
+  TString condition=expression;
+  for (int i=0; i<gkNCTPTriggerClasses; i++) {
+    if (fpTriggerClasses->At(i)) {
+      TString className=fpTriggerClasses->At(i)->GetTitle();
+      //HLTDebug("checking trigger class %s", className.Data());
+      if (condition.Contains(className)) {
+	TString replace; replace.Form("[%d]", par.size());
+	//HLTDebug("replacing %s with %s in \"%s\"", className.Data(), replace.Data(), condition.Data());
+	condition.ReplaceAll(className, replace);
+	if (triggerMask&((AliHLTUInt64_t)0x1<<i)) par.push_back(1.0);
+	else par.push_back(0.0);
+      }
+    }
+  }
+
+  TFormula form("trigger expression", condition);
+  if (form.Compile()!=0) {
+    HLTError("invalid expression %s", expression);
+    return false;
+  }
+  if (form.EvalPar(&par[0], &par[0])>0.5) return true;
+  return false;
+}