- moved the writing of the data to DumpEvent() instead of FillESD()
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 15 Apr 2010 06:53:18 +0000 (06:53 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 15 Apr 2010 06:53:18 +0000 (06:53 +0000)
- bugfix: handle the SOR correctly if only one DDL link is defined as output
- bugfix: argument scan - use correct function call of the base class

HLT/sim/AliHLTOUTComponent.cxx
HLT/sim/AliHLTOUTComponent.h

index f459afe..f6b99c0 100644 (file)
@@ -105,7 +105,7 @@ int AliHLTOUTComponent::DoInit( int argc, const char** argv )
 {
   // see header file for class documentation
   int iResult=0;
-  if ((iResult=ScanConfigurationArgument(argc, argv))<0) return -iResult;
+  if ((iResult=ConfigureFromArgumentString(argc, argv))<0) return iResult;
 
   // Make sure there is no library manager before we try and create a new one.
   if (fpLibManager) {
@@ -263,6 +263,7 @@ int AliHLTOUTComponent::DumpEvent( const AliHLTComponentEventData& evtData,
   int iResult=0;
   HLTInfo("write %d output block(s)", evtData.fBlockCnt);
   int writerNo=0;
+  int blockCount=0;
   AliHLTUInt32_t eventType=gkAliEventTypeUnknown;
   bool bIsDataEvent=IsDataEvent(&eventType);
   if (iResult>=0) {
@@ -317,12 +318,19 @@ int AliHLTOUTComponent::DumpEvent( const AliHLTComponentEventData& evtData,
       // different fields in the homer header, which is an array of 64 bit
       // words.
       fWriters[writerNo]->AddBlock(homerHeader, blocks[n].fPtr);
+      blockCount++;
     }
   }
 
-  if (iResult>=0 && !bIsDataEvent) {
+  if (iResult>=0 && !bIsDataEvent && fNofDDLs>=2) {
     // data blocks from a special event are kept to be added to the
-    // following event.
+    // following event. In the current implementation at least 2 DDLs
+    // are required to allow to keep the blocks of the SOR event and
+    // include it in the first event. If only one writer is available
+    // the blocks are ignored. For the moment this is not expexted to
+    // be a problem since components should not gererate anything on
+    // SOR/EOR. The only case is the list of AliHLTComponentTableEntry
+    // transmitted for component statistics in debug mode.
     if (fReservedWriter>=0) {
       HLTWarning("overriding previous buffer of non-data event data blocks");
     }
@@ -331,23 +339,38 @@ int AliHLTOUTComponent::DumpEvent( const AliHLTComponentEventData& evtData,
     // TODO: not yet clear whether it is smart to send the event id of
     // this special event or if it should be set from the id of the
     // following event where the data will be added
-    if ((bufferSize=FillOutputBuffer(evtData.fEventID, fWriters[writerNo], pBuffer))>0) {
+    if (blockCount>0 && (bufferSize=FillOutputBuffer(evtData.fEventID, fWriters[writerNo], pBuffer))>0) {
       fReservedWriter=writerNo;
       fReservedData=bufferSize;
     }
     fWriters[writerNo]->Clear();
+  } else if (iResult>=0 && !bIsDataEvent && fNofDDLs<2 && blockCount>0) {
+    HLTWarning("ignoring %d block(s) for special event of type %d: at least 2 DDLs are required", blockCount, eventType);
+  }
+
+  if (iResult>=0 && bIsDataEvent) {
+    iResult=Write(GetEventCount(), GetRunLoader());
   }
 
   return iResult;
 }
 
+
 int AliHLTOUTComponent::FillESD(int eventNo, AliRunLoader* runLoader, AliESDEvent* /*esd*/)
 {
   // see header file for class documentation
+  // 2010-04-14 nothing to do any more. The data is written at the end of
+  // DumpEvent
+  return 0;
+}
+
+int AliHLTOUTComponent::Write(int eventNo, AliRunLoader* runLoader)
+{
+  // see header file for class documentation
   int iResult=0;
 
   if (fWriters.size()==0) return 0;
-  
+
   if (fReservedWriter>=0) {
     if (fgOptions&kWriteDigits) WriteDigitArray(fReservedWriter, &fBuffer[0], fReservedData);
     if (fgOptions&kWriteRawFiles) WriteRawFile(eventNo, runLoader, fReservedWriter, &fBuffer[0], fReservedData);
index 722523a..9963867 100644 (file)
@@ -49,6 +49,11 @@ typedef vector<AliHLTMonitoringWriter*> AliHLTMonitoringWriterPVector;
  * \li -links      <i> n   </i> <br>
  *      number of output ddl links
  * \li -digitfile  <i> name   </i> <br>
+ *      name of the digit file to write (default HLT.Digits.root)
+ * \li -rawout[=on,off]  <br>
+ *      switch raw output on/off (default on)
+ * \li -digitout[=on,off]  <br>
+ *      switch digit output on/off (default on)
  *
  * <h2>Configuration:</h2>
  * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
@@ -133,14 +138,31 @@ class AliHLTOUTComponent : public AliHLTOfflineDataSink  {
 
   /**
    * Fill ESD for one event.
+   * Empty now, data written in Write() at the end of DumpEvent()
    * @param eventNo       event No. \em Note: this is an internal enumeration of the
    *                      processed events.
    * @param runLoader     the AliRoot runloader
-   * @param esd           an AliESDEvent instance
    * @return neg. error code if failed 
    */
   int FillESD(int eventNo, AliRunLoader* runLoader, AliESDEvent* esd);
 
+  /**
+   * Write the ecoded HLTOUT data to raw and digits files.
+   * Originally data was written in the FillESD function of the
+   * AliHLTOfflineInterface. Mainly for the sake of availability of the
+   * AliLoader. This concept has not turned out to be succesful and the
+   * development went a slightly different direction with the concept of
+   * HLTOUT handlers.
+   * 2010-04-14 change the original FillESD() to Write(), keep the body
+   * of the function
+   *
+   * @param eventNo       event No. \em Note: this is an internal enumeration of the
+   *                      processed events.
+   * @param runLoader     the AliRoot runloader
+   * @return neg. error code if failed 
+   */
+  int Write(int eventNo, AliRunLoader* runLoader);
+
  private:
   /** copy constructor prohibited */
   AliHLTOUTComponent(const AliHLTOUTComponent&);