common base class for HLT reconstruction classes and global system instance implemented
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 20 Feb 2008 22:32:17 +0000 (22:32 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 20 Feb 2008 22:32:17 +0000 (22:32 +0000)
HLT/BASE/AliHLTOUT.cxx
HLT/BASE/AliHLTOUT.h
HLT/libHLTrec.pkg
HLT/rec/AliHLTOUTRawReader.cxx
HLT/rec/AliHLTReconstructor.cxx
HLT/rec/AliHLTReconstructor.h
HLT/rec/AliHLTReconstructorBase.cxx [new file with mode: 0644]
HLT/rec/AliHLTReconstructorBase.h [new file with mode: 0644]
HLT/rec/AliRawReaderHLT.cxx
HLT/rec/AliRawReaderHLT.h

index 21a1ea3..af453dc 100644 (file)
@@ -226,7 +226,7 @@ int AliHLTOUT::InitHandlers()
   // see header file for class documentation
   int iResult=0;
   AliHLTOUTIndexList remnants;
-  for (iResult=SelectFirstDataBlock(kAliHLTAnyDataType, kAliHLTVoidDataSpec); iResult>=0; iResult=SelectNextDataBlock()) {
+  for (int havedata=SelectFirstDataBlock(kAliHLTAnyDataType, kAliHLTVoidDataSpec); havedata>=0; havedata=SelectNextDataBlock()) {
     remnants.push_back(GetDataBlockIndex());
     AliHLTComponentDataType dt=kAliHLTVoidDataType;
     AliHLTUInt32_t spec=kAliHLTVoidDataSpec;
@@ -276,7 +276,7 @@ int AliHLTOUT::InsertHandler(const AliHLTOUTHandlerListEntry &entry)
   if (element==fDataHandlers.end()) {
     fDataHandlers.push_back(entry);
   } else {
-    
+    element->AddIndex(const_cast<AliHLTOUTHandlerListEntry&>(entry));
   }
   return iResult;
 }
@@ -357,8 +357,19 @@ AliHLTUInt32_t AliHLTOUT::AliHLTOUTHandlerListEntry::operator[](int i) const
 bool AliHLTOUT::AliHLTOUTHandlerListEntry::operator==(const AliHLTOUTHandlerListEntry& entry) const
 {
   // see header file for class documentation
-  assert(0); // not yet implemented
-  return false;
+  if (entry.fpHandler!=fpHandler || fpHandler==NULL) return false;
+  assert(entry.fpAgent==fpAgent);
+  if (entry.fpAgent!=fpAgent) return false;
+  return true;
+}
+
+void AliHLTOUT::AliHLTOUTHandlerListEntry::AddIndex(AliHLTOUT::AliHLTOUTHandlerListEntry &desc)
+{
+  // see header file for class documentation
+  AliHLTOUTIndexList::iterator element;
+  for (element=desc.fBlocks.begin(); element!=desc.fBlocks.end(); element++) {
+    AddIndex(*element);
+  }  
 }
 
 void AliHLTOUT::AliHLTOUTHandlerListEntry::AddIndex(AliHLTUInt32_t index)
@@ -370,6 +381,10 @@ void AliHLTOUT::AliHLTOUTHandlerListEntry::AddIndex(AliHLTUInt32_t index)
 bool AliHLTOUT::AliHLTOUTHandlerListEntry::HasIndex(AliHLTUInt32_t index)
 {
   // see header file for class documentation
+  AliHLTOUTIndexList::iterator element;
+  for (element=fBlocks.begin(); element!=fBlocks.end(); element++) {
+    if (*element==index) return true;
+  }
   return false;
 }
 
index 3fdd32a..d844b07 100644 (file)
@@ -265,12 +265,31 @@ class AliHLTOUT : public AliHLTLogging {
     operator AliHLTModuleAgent::AliHLTOUTHandlerDesc&() {return *fpHandlerDesc;}
     operator AliHLTModuleAgent*() const {return fpAgent;}
 
+    /**
+     * Two list entries are considered to be equal if the handlers
+     * are equal.
+     */
     bool operator==(const AliHLTOUTHandlerListEntry& entry) const;
 
     AliHLTUInt32_t operator[](int i) const;
 
+    /**
+     * Add a block index to this descriptor.
+     * One descriptor can serve multiple blocks if the agent returns the
+     * same handler for all of the blocks. Instead of creating a new entry
+     * the block index ist just added
+     */
     void AddIndex(AliHLTUInt32_t index);
 
+    /**
+     * Add all indexes of the descriptor.
+     */
+    void AddIndex(AliHLTOUTHandlerListEntry &desc);
+
+    /**
+     * Check if an index is served by this descriptor.
+     * @return true if the index is in the table
+     */
     bool HasIndex(AliHLTUInt32_t index);
 
   private:
index 7bef44a..e156d12 100644 (file)
@@ -6,6 +6,7 @@ include $(MODDIR)/hlt.conf
 LIBHLTREC_VERSION := 0
 
 CLASS_HDRS:=   AliHLTReconstructor.h \
+               AliHLTReconstructorBase.h \
                AliRawReaderHLT.h \
                AliHLTOUTRawReader.h
 
index 61b0c07..5d9c970 100644 (file)
@@ -72,7 +72,8 @@ int AliHLTOUTRawReader::GenerateIndex()
     while (fpRawreader->ReadNextData(pSrc) && pSrc!=NULL && iResult>=0) {
       AliHLTUInt32_t id=(fpRawreader->GetEquipmentId())<<fgkIdShift;
       int size=fpRawreader->GetDataSize();
-      AliHLTHOMERReader* pReader=fpManager->OpenReaderBuffer(pSrc, size);
+      int offset=sizeof(AliHLTOUT::AliHLTOUTEventHeader);
+      AliHLTHOMERReader* pReader=fpManager->OpenReaderBuffer(pSrc+offset, size-offset);
       if (pReader) {
        iResult=ScanReader(pReader, id);
        fpManager->DeleteReader(pReader);
index 2125f5b..59d0623 100644 (file)
@@ -32,7 +32,7 @@ ClassImp(AliHLTReconstructor)
 AliHLTReconstructor::AliHLTReconstructor()
   : 
   AliReconstructor(),
-  fpSystem(NULL)
+  AliHLTReconstructorBase()
 { 
   //constructor
 }
@@ -41,26 +41,25 @@ AliHLTReconstructor::~AliHLTReconstructor()
 { 
   //destructor
 
-  if (fpSystem) {
-    AliDebug(0, Form("delete HLT system: status %#x", fpSystem->GetStatusFlags()));
-    if (fpSystem->CheckStatus(AliHLTSystem::kReady)) {
+  AliHLTSystem* pSystem=GetInstance();
+  if (pSystem) {
+    AliDebug(0, Form("delete HLT system: status %#x", pSystem->GetStatusFlags()));
+    if (pSystem->CheckStatus(AliHLTSystem::kReady)) {
       // send specific 'event' to execute the stop sequence
-      fpSystem->Reconstruct(0, NULL, NULL);
+      pSystem->Reconstruct(0, NULL, NULL);
     }
-    delete fpSystem;
   }
-  fpSystem=NULL;
 }
 
 void AliHLTReconstructor::Init()
 {
   // init the reconstructor
-  if (!fpSystem) fpSystem=new AliHLTSystem;
-  if (!fpSystem) {
+  AliHLTSystem* pSystem=GetInstance();
+  if (!pSystem) {
     AliError("can not create AliHLTSystem object");
     return;
   }
-  if (fpSystem->CheckStatus(AliHLTSystem::kError)) {
+  if (pSystem->CheckStatus(AliHLTSystem::kError)) {
     AliError("HLT system in error state");
     return;
   }
@@ -79,17 +78,17 @@ void AliHLTReconstructor::Init()
       if (token.Contains("loglevel=")) {
        TString param=token.ReplaceAll("loglevel=", "");
        if (param.IsDigit()) {
-         fpSystem->SetGlobalLoggingLevel((AliHLTComponentLogSeverity)param.Atoi());
+         pSystem->SetGlobalLoggingLevel((AliHLTComponentLogSeverity)param.Atoi());
        } else if (param.BeginsWith("0x") &&
                   param.Replace(0,2,"",0).IsHex()) {
          int severity=0;
          sscanf(param.Data(),"%x", &severity);
-         fpSystem->SetGlobalLoggingLevel((AliHLTComponentLogSeverity)severity);
+         pSystem->SetGlobalLoggingLevel((AliHLTComponentLogSeverity)severity);
        } else {
          AliWarning("wrong parameter for option \'loglevel=\', (hex) number expected");
        }
       } else if (token.Contains("alilog=off")) {
-       fpSystem->SwitchAliLog(0);
+       pSystem->SwitchAliLog(0);
       } else if (token.BeginsWith("lib") && token.EndsWith(".so")) {
        libs+=token;
        libs+=" ";
@@ -102,18 +101,18 @@ void AliHLTReconstructor::Init()
   }
 
   if (!libs.IsNull() &&
-      (!fpSystem->CheckStatus(AliHLTSystem::kLibrariesLoaded)) &&
-      (fpSystem->LoadComponentLibraries(libs.Data())<0)) {
+      (!pSystem->CheckStatus(AliHLTSystem::kLibrariesLoaded)) &&
+      (pSystem->LoadComponentLibraries(libs.Data())<0)) {
     AliError("error while loading HLT libraries");
     return;
   }
 
-  if (!fpSystem->CheckStatus(AliHLTSystem::kReady)) {
+  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)(fpSystem, option.Data())<0) {
+      if ((pFunc)(pSystem, option.Data())<0) {
       AliError("error setting options for HLT system");
       return;  
       }
@@ -121,7 +120,7 @@ void AliHLTReconstructor::Init()
       AliError(Form("version of HLT system does not support the options \'%s\'", option.Data()));
       return;
     }
-    if ((fpSystem->Configure())<0) {
+    if ((pSystem->Configure())<0) {
       AliError("error during HLT system configuration");
       return;
     }
@@ -149,17 +148,18 @@ void AliHLTReconstructor::FillESD(AliRawReader* rawReader, TTree* /*clustersTree
 {
   // reconstruct real data and fill ESD
   int iResult=0;
-  if (fpSystem) {
-    if (fpSystem->CheckStatus(AliHLTSystem::kError)) {
+  AliHLTSystem* pSystem=GetInstance();
+  if (pSystem) {
+    if (pSystem->CheckStatus(AliHLTSystem::kError)) {
       AliError("HLT system in error state");
       return;
     }
-    if (!fpSystem->CheckStatus(AliHLTSystem::kReady)) {
+    if (!pSystem->CheckStatus(AliHLTSystem::kReady)) {
       AliError("HLT system in wrong state");
       return;
     }
-    if ((iResult=fpSystem->Reconstruct(1, NULL, rawReader))>=0) {
-      fpSystem->FillESD(-1, NULL, esd);
+    if ((iResult=pSystem->Reconstruct(1, NULL, rawReader))>=0) {
+      pSystem->FillESD(-1, NULL, esd);
     }
   }
 }
index 794af6c..c423a15 100644 (file)
@@ -19,6 +19,7 @@
                                                                           */
 
 #include "AliReconstructor.h"
+#include "AliHLTReconstructorBase.h"
 
 class AliHLTSystem;
 class AliRawReader;
@@ -53,7 +54,7 @@ class AliESDEvent;
  * For further information on the AliRoot reconstruction refer to the AliRoot
  * documentation, namely <tt>AliReconstruction</tt>.
  */
-class AliHLTReconstructor: public AliReconstructor {
+class AliHLTReconstructor: public AliReconstructor, public AliHLTReconstructorBase {
 public:
   AliHLTReconstructor();
   /** destructor */
@@ -102,9 +103,7 @@ private:
   /** assignment operator prohibited */
   AliHLTReconstructor& operator=(const AliHLTReconstructor& src);
 
-  AliHLTSystem* fpSystem; //! HLT steering object
-
-  ClassDef(AliHLTReconstructor, 3)   // class for the HLT reconstruction
+  ClassDef(AliHLTReconstructor, 4)   // class for the HLT reconstruction
 };
 
 typedef AliHLTReconstructor AliL3Reconstructor; // for backward compatibility
diff --git a/HLT/rec/AliHLTReconstructorBase.cxx b/HLT/rec/AliHLTReconstructorBase.cxx
new file mode 100644 (file)
index 0000000..5fab10f
--- /dev/null
@@ -0,0 +1,64 @@
+// $Id$
+
+//**************************************************************************
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//*                                                                        *
+//* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
+//*                  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   *
+//* without fee, provided that the above copyright notice appears in all   *
+//* copies and that both the copyright notice and this permission notice   *
+//* appear in the supporting documentation. The authors make no claims     *
+//* about the suitability of this software for any purpose. It is          *
+//* provided "as is" without express or implied warranty.                  *
+//**************************************************************************
+
+/** @file   AliHLTReconstructionBase.cxx
+    @author Matthias Richter
+    @date   
+    @brief  Base class for HLT reconstruction classes.
+*/
+
+#include "AliHLTReconstructorBase.h"
+#include "AliHLTSystem.h"
+
+/** ROOT macro for the implementation of ROOT specific class methods */
+ClassImp(AliHLTReconstructorBase)
+
+AliHLTReconstructorBase::AliHLTReconstructorBase()
+{
+  // see header file for class documentation
+  // or
+  // refer to README to build package
+  // or
+  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
+  fNofInstances++;
+}
+
+AliHLTReconstructorBase::~AliHLTReconstructorBase()
+{
+  // see header file for class documentation
+  if (--fNofInstances<=0) delete fpSystem;
+  fpSystem=NULL;
+}
+
+void AliHLTReconstructorBase::InitInstance()
+{
+  // see header file for class documentation
+  if (!fpSystem) fpSystem=new AliHLTSystem;
+}
+
+AliHLTSystem* AliHLTReconstructorBase::GetInstance()
+{
+  // see header file for class documentation
+  if (!fpSystem) InitInstance();
+  return fpSystem;
+}
+
+
+AliHLTSystem* AliHLTReconstructorBase::fpSystem=NULL;
+
+int AliHLTReconstructorBase::fNofInstances=0;
diff --git a/HLT/rec/AliHLTReconstructorBase.h b/HLT/rec/AliHLTReconstructorBase.h
new file mode 100644 (file)
index 0000000..69eb99d
--- /dev/null
@@ -0,0 +1,61 @@
+// $Id$
+
+#ifndef ALIHLTRECONSTRUCTORBASE_H
+#define ALIHLTRECONSTRUCTORBASE_H
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//* See cxx source for full Copyright notice                               *
+
+/** @file   AliHLTReconstructorBase.h
+    @author Matthias Richter
+    @date   
+    @brief  Base class for HLT reconstruction classes.
+*/
+
+// see below for class documentation
+// or
+// refer to README to build package
+// or
+// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
+
+#include "TObject.h"
+
+class AliHLTSystem;
+
+/**
+ * @class AliHLTReconstructorBase
+ * Base class for HLT reconstruction classes. AliHLTReconstructor and
+ * AliRawReaderHLT both use the global AliHLTSystem instance. This
+ * base class hosts the global instance.
+ */
+class AliHLTReconstructorBase {
+ public:
+  AliHLTReconstructorBase();
+  /** destructor */
+  virtual ~AliHLTReconstructorBase();
+
+  /**
+   * Init the global AliHLTSystem instance.
+   */
+  static void InitInstance();
+
+  /**
+   * Get the global AliHLTSystem instance.
+   */
+  static AliHLTSystem* GetInstance();
+
+ protected:
+
+ private:
+  /** copy constructor prohibited */
+  AliHLTReconstructorBase(const AliHLTReconstructorBase& src);
+  /** assignment operator prohibited */
+  AliHLTReconstructorBase& operator=(const AliHLTReconstructorBase& src);
+
+  static AliHLTSystem* fpSystem; //! HLT steering object
+
+  static int fNofInstances;
+
+  ClassDef(AliHLTReconstructorBase, 0)   // base class for the HLT reconstruction
+};
+#endif
index 5b91776..60e1222 100644 (file)
@@ -33,6 +33,7 @@
 #include "AliHLTModuleAgent.h"
 #include "AliHLTOUTHandler.h"
 #include "AliHLTOUTHandlerEquId.h"
+#include "AliHLTSystem.h"
 #include "AliLog.h"
 #include "AliDAQ.h"            // RAW, for detector names and equipment ids
 #include "TObjString.h"
@@ -44,8 +45,10 @@ ClassImp(AliRawReaderHLT)
 AliRawReaderHLT::AliRawReaderHLT(AliRawReader* pRawreader, const char* options)
   :
   AliRawReader(),
+  AliHLTReconstructorBase(),
   fpParentReader(pRawreader),
   fOptions(),
+  fSystemOptions(),
   fpData(NULL),
   fDataSize(0),
   fOffset(0),
@@ -413,6 +416,9 @@ int AliRawReaderHLT::ScanOptions(const char* options)
       int detId=AliDAQ::DetectorID(argument.Data());
       if (detId>=0) {
        fDetectors.push_back(detId);
+      } else {
+       if (!fSystemOptions.IsNull()) fSystemOptions+=" ";
+       fSystemOptions+=argument;
       }
     }
     delete pTokens;
@@ -428,6 +434,10 @@ Bool_t   AliRawReaderHLT::ReadNextHLTData()
   if (!fpHLTOUT) {
     fpHLTOUT=new AliHLTOUTRawReader(fpParentReader);
     if (result=(fpHLTOUT!=NULL)) {
+      AliHLTSystem* pSystem=GetInstance();
+      if (pSystem) {
+       pSystem->ScanOptions(fSystemOptions.Data());
+      }
       if (result=(fpHLTOUT->Init()>=0)) {
        result=fpHLTOUT->SelectFirstDataBlock(kAliHLTAnyDataType, kAliHLTVoidDataSpec,
                                              AliHLTModuleAgent::kRawReader)>=0;
index 7faebb4..57a1373 100644 (file)
@@ -21,6 +21,7 @@
 
 #include "AliHLTDataTypes.h"
 #include "AliRawReader.h"      // RAW, base class
+#include "AliHLTReconstructorBase.h"
 #include "TString.h"
 #include <vector>
 
@@ -31,7 +32,7 @@ class AliHLTOUTHandler;
  * @class AliRawReaderHLT
  * Handler of HLTOUT data for AliRawReader input.
  */
-class AliRawReaderHLT : public AliRawReader {
+class AliRawReaderHLT : public AliRawReader, public AliHLTReconstructorBase {
  public:
   /** constructor */
   AliRawReaderHLT(AliRawReader* pParentReader, const char* options=NULL);
@@ -116,6 +117,9 @@ class AliRawReaderHLT : public AliRawReader {
   /** options */
   TString fOptions; //!transient
 
+  /** system options = options w/o detector strings */
+  TString fSystemOptions; //!transient
+
   /** current data set, either extracted from the HLT stream or parent raw reader */
   const AliHLTUInt8_t* fpData; // !transient
 
@@ -140,7 +144,7 @@ class AliRawReaderHLT : public AliRawReader {
   /** instance of the data handler providing the current data buffer */
   AliHLTOUTHandler* fpDataHandler; // !transient
 
-  ClassDef(AliRawReaderHLT, 2)
+  ClassDef(AliRawReaderHLT, 3)
 };
 
 #define ALIHLTREC_LIBRARY                   "libHLTrec.so"