- improvements in AliHLTFilePublisher/Writer
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 6 Feb 2007 15:31:11 +0000 (15:31 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 6 Feb 2007 15:31:11 +0000 (15:31 +0000)
- small fix in component handler to pipe log messages during registration
  of standard components into right log channel
- the ProcessEvent method is now a method of the component base class,
  the actual processing method to implement is DoProcessing
- new standard component AliHLTRootFileWriterComponent added
- TPCLib: AliHLTTPCEsdWriterComponent added, conversion of AliHLTTPCTrack
  to AliTPCtrack implemented (not finished)
- small fixes in stand-alone build system (libAliHLTPHOS.pkg, *LinkDef.h)

35 files changed:
HLT/BASE/AliHLTComponent.cxx
HLT/BASE/AliHLTComponent.h
HLT/BASE/AliHLTComponentHandler.cxx
HLT/BASE/AliHLTComponentHandler.h
HLT/BASE/AliHLTDataSink.cxx
HLT/BASE/AliHLTDataSink.h
HLT/BASE/AliHLTDataSource.cxx
HLT/BASE/AliHLTDataSource.h
HLT/BASE/AliHLTDataTypes.h
HLT/BASE/AliHLTFilePublisher.cxx
HLT/BASE/AliHLTFilePublisher.h
HLT/BASE/AliHLTFileWriter.cxx
HLT/BASE/AliHLTFileWriter.h
HLT/BASE/AliHLTLogging.cxx
HLT/BASE/AliHLTLogging.h
HLT/BASE/AliHLTProcessor.cxx
HLT/BASE/AliHLTProcessor.h
HLT/BASE/AliHLTRootFileWriterComponent.cxx [new file with mode: 0644]
HLT/BASE/AliHLTRootFileWriterComponent.h [new file with mode: 0644]
HLT/BASE/AliHLT_C_Component_WrapperInterface.cxx
HLT/BASE/HLTbaseLinkDef.h
HLT/ChangeLog
HLT/Makefile.am
HLT/PHOS/Makefile.am
HLT/TPCLib/AliHLTTPCEsdWriterComponent.cxx [new file with mode: 0644]
HLT/TPCLib/AliHLTTPCEsdWriterComponent.h [new file with mode: 0644]
HLT/TPCLib/AliHLTTPCGlobalMergerComponent.h
HLT/TPCLib/AliHLTTPCPad.cxx
HLT/TPCLib/AliHLTTPCTrack.cxx
HLT/TPCLib/AliHLTTPCTrack.h
HLT/TPCLib/AliHLTTPCTrackArray.cxx
HLT/TPCLib/AliHLTTPCTrackArray.h
HLT/TPCLib/Makefile.am
HLT/libHLTbase.pkg
HLT/make.dict

index d7b31e325c3463fc0b57a2358822ddfcac9853b1..4677cacbfd5a95aac6dfca932e9931d0a794c547 100644 (file)
@@ -36,7 +36,8 @@ ClassImp(AliHLTComponent)
 AliHLTComponent::AliHLTComponent()
   :
   fEnvironment(),
-  fCurrentEvent(0)
+  fCurrentEvent(0),
+  fEventCount(-1)
 { 
   memset(&fEnvironment, 0, sizeof(AliHLTComponentEnvironment));
   if (fpComponentHandler)
@@ -71,6 +72,7 @@ int AliHLTComponent::Init( AliHLTComponentEnvironment* environ, void* environ_pa
     fEnvironment.fParam=environ_param;
   }
   iResult=DoInit(argc, argv);
+  if (iResult>=0) fEventCount=0;
   return iResult;
 }
 
@@ -104,12 +106,21 @@ void AliHLTComponent::DataType2Text( const AliHLTComponentDataType& type, char o
 string AliHLTComponent::DataType2Text( const AliHLTComponentDataType& type )
 {
   string out("");
+  
   if (type==kAliHLTVoidDataType) {
     out="VOID:VOID";
   } else {
-    out.append(type.fOrigin, kAliHLTComponentDataTypefOriginSize);
+    // some gymnastics in order to avoid a '0' which is part of either or both
+    // ID and origin terminating the whole string. Unfortunately, string doesn't
+    // stop appending at the '0' if the number of elements to append was 
+    // explicitely specified
+    string tmp("");
+    tmp.append(type.fOrigin, kAliHLTComponentDataTypefOriginSize);
+    out.append(tmp.c_str());
     out.append(":");
-    out.append(type.fID, kAliHLTComponentDataTypefIDsize);
+    tmp="";
+    tmp.append(type.fID, kAliHLTComponentDataTypefIDsize);
+    out.append(tmp.c_str());
   }
   return out;
 }
@@ -237,6 +248,32 @@ void AliHLTComponent::PrintComponentDataTypeInfo(const AliHLTComponentDataType&
    else msg+="\\0";
   }
   msg+="\"";
-  HLTMessage(msg.Data());
+  AliHLTLogging::Message(NULL, kHLTLogNone, NULL , NULL, msg.Data());
 }
 
+int AliHLTComponent::GetEventCount()
+{
+  return fEventCount;
+}
+
+int AliHLTComponent::IncrementEventCounter()
+{
+  if (fEventCount>=0) fEventCount++;
+  return fEventCount;
+}
+
+int AliHLTComponent::ProcessEvent( const AliHLTComponentEventData& evtData,
+                                  const AliHLTComponentBlockData* blocks, 
+                                  AliHLTComponentTriggerData& trigData,
+                                  AliHLTUInt8_t* outputPtr, 
+                                  AliHLTUInt32_t& size,
+                                  AliHLTUInt32_t& outputBlockCnt, 
+                                  AliHLTComponentBlockData*& outputBlocks,
+                                  AliHLTComponentEventDoneData*& edd )
+{
+  int iResult=0;
+  fCurrentEvent=evtData.fEventID;
+  iResult=DoProcessing(evtData, blocks, trigData, outputPtr, size, outputBlockCnt, outputBlocks, edd);
+  IncrementEventCounter();
+  return iResult;
+}
index 710db3f8912b7047e44538a97fde2776626258d6..4712f0f31bee3a05e31f386d48163fbadaf406cf 100644 (file)
@@ -94,6 +94,28 @@ class AliHLTComponent : public AliHLTLogging {
 
   /**
    * Processing of one event.
+   * The method is the entrance of the event processing. The parameters are
+   * cached for uses with the high-level interface and the DoProcessing
+   * implementation is called.
+   *
+   * @param evtData
+   * @param blocks
+   * @param trigData
+   * @param outputPtr
+   * @param size
+   * @param outputBlockCnt  out: size of the output block array, set by the component
+   * @param outputBlocks    out: the output block array is allocated internally
+   * @param edd
+   * @return neg. error code if failed
+   */
+  int ProcessEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
+                           AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
+                           AliHLTUInt32_t& size, AliHLTUInt32_t& outputBlockCnt, 
+                           AliHLTComponentBlockData*& outputBlocks,
+                           AliHLTComponentEventDoneData*& edd );
+
+  /**
+   * Internal processing of one event.
    * The method is pure virtual and implemented by the child classes 
    * - @ref AliHLTProcessor
    * - @ref AliHLTDataSource
@@ -109,7 +131,7 @@ class AliHLTComponent : public AliHLTLogging {
    * @param edd
    * @return neg. error code if failed
    */
-  virtual int ProcessEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
+  virtual int DoProcessing( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
                            AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
                            AliHLTUInt32_t& size, AliHLTUInt32_t& outputBlockCnt, 
                            AliHLTComponentBlockData*& outputBlocks,
@@ -293,7 +315,21 @@ class AliHLTComponent : public AliHLTLogging {
    */
   void DataType2Text(const AliHLTComponentDataType& type, char output[kAliHLTComponentDataTypefIDsize+kAliHLTComponentDataTypefOriginSize+2]);
 
+  /**
+   * Get event number.
+   * @return value of the internal event counter
+   */
+  int GetEventCount();
+
  private:
+  /**
+   * Increment the internal event counter.
+   * To be used by the friend classes AliHLTProcessor, AliHLTDataSource
+   * and AliHLTDataSink.
+   * @return new value of the internal event counter
+   */
+  int IncrementEventCounter();
+
   /** The global component handler instance */
   static AliHLTComponentHandler* fpComponentHandler;
   /** The environment where the component is running in */
@@ -305,6 +341,9 @@ class AliHLTComponent : public AliHLTLogging {
    */
   AliHLTEventID_t fCurrentEvent;
 
-  ClassDef(AliHLTComponent, 0)
+  /** internal event no */
+  int fEventCount;
+
+  ClassDef(AliHLTComponent, 1)
 };
 #endif
index 8d3796444fdbb9bccc31932d95fe415d5382be01..b840d469e4a880e445ce2089edf609abe9924454 100644 (file)
@@ -40,6 +40,7 @@ using namespace std;
 // the standard components
 #include "AliHLTFilePublisher.h"
 #include "AliHLTFileWriter.h"
+#include "AliHLTRootFileWriterComponent.h"
 
 /** ROOT macro for the implementation of ROOT specific class methods */
 ClassImp(AliHLTComponentHandler)
@@ -56,6 +57,22 @@ AliHLTComponentHandler::AliHLTComponentHandler()
   AddStandardComponents();
 }
 
+AliHLTComponentHandler::AliHLTComponentHandler(AliHLTComponentEnvironment* pEnv)
+  :
+  fComponentList(),
+  fScheduleList(),
+  fLibraryList(),
+  fEnvironment(),
+  fStandardList()
+{
+  if (pEnv) {
+    memcpy(&fEnvironment, pEnv, sizeof(AliHLTComponentEnvironment));
+    AliHLTLogging::Init(pEnv->fLoggingFunc);
+  }  else
+    memset(&fEnvironment, 0, sizeof(AliHLTComponentEnvironment));
+  AddStandardComponents();
+}
+
 AliHLTComponentHandler::~AliHLTComponentHandler()
 {
   UnloadLibraries();
@@ -274,6 +291,7 @@ int AliHLTComponentHandler::AddStandardComponents()
   AliHLTComponent::SetGlobalComponentHandler(this);
   fStandardList.push_back(new AliHLTFilePublisher);
   fStandardList.push_back(new AliHLTFileWriter);
+  fStandardList.push_back(new AliHLTRootFileWriterComponent);
   AliHLTComponent::UnsetGlobalComponentHandler();
   iResult=RegisterScheduledComponents();
   return iResult;
index 1cdd33f41c0ed3ea09d0c17ee9cb28ca7c4f06d9..4be1c12632ac4d7e320c953a8da24460befa3a90 100644 (file)
@@ -35,6 +35,8 @@ class AliHLTComponentHandler : public AliHLTLogging {
  public:
   /** standard constructor */
   AliHLTComponentHandler();
+  /** constructor */
+  AliHLTComponentHandler(AliHLTComponentEnvironment* pEnv);
   /** destructor */
   virtual ~AliHLTComponentHandler();
 
index 1896275d25b8e626c57e294e14ff4c5c277047d6..65acccb3de354cc66f0de6fe1742610ccf7b67fe 100644 (file)
@@ -52,7 +52,7 @@ void AliHLTDataSink::GetOutputDataSize( unsigned long& constBase, double& inputM
   inputMultiplier=0;
 }
 
-int AliHLTDataSink::ProcessEvent( const AliHLTComponentEventData& evtData,
+int AliHLTDataSink::DoProcessing( const AliHLTComponentEventData& evtData,
                                    const AliHLTComponentBlockData* blocks, 
                                    AliHLTComponentTriggerData& trigData,
                                    AliHLTUInt8_t* outputPtr, 
index 42cf4701efdbca77338d608415f66040a3c72451..e5ebad5bb05320088468f7ee11cc5271c9b55faf 100644 (file)
@@ -43,7 +43,7 @@ class AliHLTDataSink : public AliHLTComponent {
    * preparation of data structures. The call is redirected to DumpEvent.
    * @return neg. error code if failed
    */
-  int ProcessEvent( const AliHLTComponentEventData& evtData,
+  int DoProcessing( const AliHLTComponentEventData& evtData,
                    const AliHLTComponentBlockData* blocks, 
                    AliHLTComponentTriggerData& trigData,
                    AliHLTUInt8_t* outputPtr, 
index 2ad38bf1287d29ad3d8c41dc3fd0108cdd2473c1..c605d278f06a5ae338c912c5f383cfb5908b2baa 100644 (file)
@@ -43,7 +43,7 @@ void AliHLTDataSource::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
 }
 
 
-int AliHLTDataSource::ProcessEvent( const AliHLTComponentEventData& evtData,
+int AliHLTDataSource::DoProcessing( const AliHLTComponentEventData& evtData,
                                    const AliHLTComponentBlockData* blocks, 
                                    AliHLTComponentTriggerData& trigData,
                                    AliHLTUInt8_t* outputPtr, 
index 723c503766800ca4c981351e49cb11160ab2a723..70e0d23cd5cad59ff4170679b2c509410c7facac 100644 (file)
@@ -42,7 +42,7 @@ class AliHLTDataSource : public AliHLTComponent {
    * preparation of data structures. The call is redirected to GetEvent.
    * @return neg. error code if failed
    */
-  int ProcessEvent( const AliHLTComponentEventData& evtData,
+  int DoProcessing( const AliHLTComponentEventData& evtData,
                    const AliHLTComponentBlockData* blocks, 
                    AliHLTComponentTriggerData& trigData,
                    AliHLTUInt8_t* outputPtr, 
index e71d5f92db7bb5391dd5749e67a74e5d0a13d9ad..99ad43ca5c82ffcc01fbafe837115760829a1ae8 100644 (file)
@@ -36,6 +36,7 @@ extern "C" {
     AliHLTUInt32_t fBlockCnt;
   };
 
+  const AliHLTEventID_t kAliHLTVoidEventID=~(AliHLTEventID_t)0;
   struct AliHLTComponentShmData
   {
     AliHLTUInt32_t fStructSize;
index a883b2d0670ec4beb219d945ec9413913e02c7d0..8cab1dbbc386f2199df4afa3e31f67ca2857967a 100644 (file)
@@ -104,6 +104,7 @@ int AliHLTFilePublisher::DoInit( int argc, const char** argv )
   int bMissingParam=0;
   for (int i=0; i<argc && iResult>=0; i++) {
     argument=argv[i];
+    if (argument.IsNull()) continue;
 
     // -datafile
     if (argument.CompareTo("-datafile")==0) {
@@ -124,21 +125,23 @@ int AliHLTFilePublisher::DoInit( int argc, const char** argv )
     } else if (argument.CompareTo("-datatype")==0) {
       if ((bMissingParam=(++i>=argc))) break;
       memcpy(&fDataType.fID, argv[i], TMath::Min(kAliHLTComponentDataTypefIDsize, (Int_t)strlen(argv[i])));
+      if ((bMissingParam=(++i>=argc))) break;
+      memcpy(&fDataType.fOrigin, argv[i], TMath::Min(kAliHLTComponentDataTypefOriginSize, (Int_t)strlen(argv[i])));
 
       // -dataspec
     } else if (argument.CompareTo("-dataspec")==0) {
       if ((bMissingParam=(++i>=argc))) break;
       TString parameter(argv[i]);
+      parameter.Remove(TString::kLeading, ' '); // remove all blanks
       if (parameter.IsDigit()) {
        fSpecification=(AliHLTUInt32_t)parameter.Atoi();
+      } else if (parameter.BeginsWith("0x") &&
+                parameter.Replace(0,2,"",0).IsHex()) {
+       sscanf(parameter.Data(),"%x", &fSpecification);
       } else {
        HLTError("wrong parameter for argument %s, number expected", argument.Data());
        iResult=-EINVAL;
       }
-      // -dataorigin
-    } else if (argument.CompareTo("-dataorigin")==0) {
-      if ((bMissingParam=(++i>=argc))) break;
-      memcpy(&fDataType.fOrigin, argv[i], TMath::Min(kAliHLTComponentDataTypefOriginSize,(Int_t)strlen(argv[i])));
     } else {
       if ((iResult=ScanArgument(argc-i, &argv[i]))==-EINVAL) {
        HLTError("unknown argument %s", argument.Data());
index 382ed48dac5f54e6640bc293f72428bb17fdb347..0759b08deddba99581dc8fcd51f8aaf93250f2f1 100644 (file)
  * @class AliHLTFilePublisher
  * An HLT data source component which publishes data from one or a sequence
  * of files.<br>
+ *
  * Mandatory arguments: <br>
  * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formating -->
  * \li -datafile     <i> filename      </i>
- * \li -datafilelist <i> file pattern  </i>
- * \li -datatype     <i> data type     </i>
- * \li -dataspec     <i> specification </i>
- * \li -dataorigin   <i> origin        </i>
+ * \li -datafilelist <i> file pattern  </i> <br>
+ *      not yet implemented
+ * \li -datatype     <i> datatype   dataorigin </i> <br>
+ *      data type ID and origin, e.g. <tt>-datatype CLUSTERS TPC </tt>
+ * \li -dataspec     <i> specification </i> <br>
+ *      data specification treated as decimal number or hex number if
+ *      prepended by '0x'
  *
  * Optional arguments:<br>
  *
  * The component needs at least one argument \em -datafile or \em -datafilelist.
- * Both can occur multiple times.
+ * Both can occur multiple times. The \em -datatype and \em -dataspec
+ * parameters are valid for all files until the next occurrence of
+ * \em -datatype/spec
  * @ingroup alihlt_component
  */
 class AliHLTFilePublisher : public AliHLTDataSource  {
index 3dd484e17e1600fb38547337b418ba0033c60579..b6795d945fda51105adb96e4b7f6a8958bb4a6c1 100644 (file)
@@ -25,6 +25,7 @@ using namespace std;
 #endif
 
 #include "AliHLTFileWriter.h"
+#include <TObjArray.h>
 #include <TObjString.h>
 #include <TMath.h>
 #include <TFile.h>
@@ -35,18 +36,20 @@ ClassImp(AliHLTFileWriter)
 AliHLTFileWriter::AliHLTFileWriter()
   :
   fBaseName(""),
+  fExtension(""),
   fDirectory(""),
-  fEnumeration(""),
-  fbSeparate(0)
+  fCurrentFileName(""),
+  fMode(0)
 {
 }
 
 AliHLTFileWriter::AliHLTFileWriter(const AliHLTFileWriter&)
   :
   fBaseName(""),
+  fExtension(""),
   fDirectory(""),
-  fEnumeration(""),
-  fbSeparate(0)
+  fCurrentFileName(""),
+  fMode(0)
 {
   HLTFatal("copy constructor untested");
 }
@@ -86,11 +89,25 @@ int AliHLTFileWriter::DoInit( int argc, const char** argv )
   int bMissingParam=0;
   for (int i=0; i<argc && iResult>=0; i++) {
     argument=argv[i];
+    if (argument.IsNull()) continue;
 
     // -basename
     if (argument.CompareTo("-datafile")==0) {
       if ((bMissingParam=(++i>=argc))) break;
       fBaseName=argv[i];
+      TObjArray* pTokens=fBaseName.Tokenize(".");
+      if (pTokens) {
+       int iEntries=pTokens->GetEntries();
+       if (iEntries>1) {
+         int i=0;
+         fBaseName=((TObjString*)pTokens->At(i++))->GetString();
+         while (i<iEntries-1) {
+           fBaseName+="." + ((TObjString*)pTokens->At(i++))->GetString();
+         }
+         fExtension=((TObjString*)pTokens->At(i))->GetString();
+       }
+       delete pTokens;
+      }
 
       // -directory
     } else if (argument.CompareTo("-directory")==0) {
@@ -98,18 +115,16 @@ int AliHLTFileWriter::DoInit( int argc, const char** argv )
       fDirectory=argv[i];
 
       // -enumeration
-    } else if (argument.CompareTo("-enumeration")==0) {
-      if ((bMissingParam=(++i>=argc))) break;
-      fEnumeration=argv[i];
+    } else if (argument.CompareTo("-enumerate")==0) {
+      SetMode(kEnumerate);
 
-      // -separate
-    } else if (argument.CompareTo("-enumeration")==0) {
-      if ((bMissingParam=(++i>=argc))) break;
-      TString parameter(argv[i]);
-      fbSeparate=parameter.Atoi();
-      if (fbSeparate < 0 || fbSeparate > 1) {
-       HLTError("invalid parameter for argument %s", argument.Data());
-      }
+      // -concatenate-blocks
+    } else if (argument.CompareTo("-concatenate-blocks")==0) {
+      SetMode(kConcatenateBlocks);
+
+      // -concatenate-events
+    } else if (argument.CompareTo("-concatenate-events")==0) {
+      SetMode(kConcatenateEvents);
 
     } else {
       if ((iResult=ScanArgument(argc-i, &argv[i]))==-EINVAL) {
@@ -128,9 +143,18 @@ int AliHLTFileWriter::DoInit( int argc, const char** argv )
     HLTError("missing parameter for argument %s", argument.Data());
     iResult=-EINVAL;
   }
+  if (iResult>=0) {
+    iResult=InitWriter();
+  }
+
   return iResult;
 }
 
+int AliHLTFileWriter::InitWriter()
+{
+  return 0; // note: this doesn't mean 'error'
+}
+
 int AliHLTFileWriter::ScanArgument(int argc, const char** argv)
 {
   // there are no other arguments than the standard ones
@@ -139,24 +163,49 @@ int AliHLTFileWriter::ScanArgument(int argc, const char** argv)
 
 int AliHLTFileWriter::DoDeinit()
 {
-  int iResult=0;
+  HLTDebug("");
+  int iResult=CloseWriter();
+  ClearMode(kEnumerate);
   return iResult;
 }
 
+int AliHLTFileWriter::CloseWriter()
+{
+  return 0; // note: this doesn't mean 'error'
+}
+
 int AliHLTFileWriter::DumpEvent( const AliHLTComponentEventData& evtData,
                         const AliHLTComponentBlockData* blocks, 
                         AliHLTComponentTriggerData& trigData )
 {
   int iResult=0;
+  if (CheckMode(kConcatenateEvents)==0) {
+    // reset the current file name in order to open a new file
+    // for the first block. If events are concatenated, the current
+    // file name stays in order to be opended in append mode.
+    fCurrentFileName="";
+  }
   for (int n=0; n<(int)evtData.fBlockCnt; n++ ) {
     //HLTDebug("block %d out of %d", n, evtData.fBlockCnt);
     TString filename;
+    HLTDebug("dataspec 0x%x", blocks[n].fSpecification);
     iResult=BuildFileName(evtData.fEventID, n, blocks[n].fDataType, filename);
+    ios::openmode filemode=(ios::openmode)0;
+    if (fCurrentFileName.CompareTo(filename)==0) {
+      // append to the file
+      filemode=ios::app;
+    } else {
+      // store the file for the next block
+      fCurrentFileName=filename;
+    }
     if (iResult>=0) {
-      ofstream dump(filename.Data());
+      ofstream dump(filename.Data(), filemode);
       if (dump.good()) {
        dump.write((const char*)blocks[n].fPtr, blocks[n].fSize);
        HLTDebug("wrote %d byte(s) to file %s", blocks[n].fSize, filename.Data());
+      } else {
+       HLTError("can not open file %s for writing", filename.Data());
+       iResult=-EBADF;
       }
       dump.close();
     }
@@ -168,7 +217,54 @@ int AliHLTFileWriter::BuildFileName(const AliHLTEventID_t eventID, const int blo
 {
   int iResult=0;
   //HLTDebug("build file name for event %d block %d", eventID, blockID);
-  filename.Form("event_%#08x_0x%x_", eventID, blockID);
-  filename+=AliHLTComponent::DataType2Text(dataType).data();
+  filename="";
+  if (!fDirectory.IsNull()) {
+    filename+=fDirectory;
+    if (!fDirectory.EndsWith("/"))
+      filename+="/";
+  }
+  if (!fBaseName.IsNull())
+    filename+=fBaseName;
+  else
+    filename+="event";
+  if (!CheckMode(kConcatenateEvents)) {
+    if (!CheckMode(kEnumerate)) {
+      if (eventID!=kAliHLTVoidEventID) {
+       filename+=Form("_0x%08x", eventID);
+      }
+    } else {
+      filename+=Form("_%d", GetEventCount());
+    }
+  }
+  if (blockID>=0 && !CheckMode(kConcatenateBlocks)) {
+    filename+=Form("_0x%x", blockID);
+    if (dataType!=kAliHLTVoidDataType) {
+      filename+="_";
+      filename+=AliHLTComponent::DataType2Text(dataType).data();
+    }
+  }
+  if (!fExtension.IsNull())
+    filename+="." + fExtension;
+  filename.ReplaceAll(" ", "");
   return iResult;
 }
+
+int AliHLTFileWriter::SetMode(Short_t mode) 
+{
+  fMode|=mode;
+  //HLTDebug("mode set to 0x%x", fMode);
+  return fMode;
+}
+
+int AliHLTFileWriter::ClearMode(Short_t mode)
+{
+  fMode&=~mode;
+  //HLTDebug("mode set to 0x%x", fMode);
+  return fMode;
+}
+
+int AliHLTFileWriter::CheckMode(Short_t mode)
+{
+  //HLTDebug("check mode 0x%x for flag 0x%x: %d", fMode, mode, (fMode&mode)!=0);
+  return (fMode&mode)!=0;
+}
index 4aacf1833821dab0d9d063ea8554bd3fad0945f2..83e1fc5411b2f7df8f94b1b28f5baad7338d4bf8 100644 (file)
@@ -9,7 +9,6 @@
     @author Matthias Richter
     @date   
     @brief  An HLT file dump (data sink) component.
-    @note   The class is used in Offline (AliRoot) context
 */
 
 #include "AliHLTDataSink.h"
 
 /**
  * @class AliHLTFileWriter
- * An HLT data sink component which writes data to file(s)
+ * An HLT data sink component which writes data to file(s).
  *
+ * Mandatory arguments: <br>
+ * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formating -->
+ *
+ * Optional arguments: <br>
+ * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formating -->
+ * \li -datafile     <i> filename   </i> <br>
+ *      file name base
+ * \li -directory    <i> directory  </i> <br>
+ *      target directory
+ * \li -enumerate <br>
+ *      don't use the event number but an event counter beginning from 0
+ * \li -concatenate-blocks <br>
+ *      concatenate all blocks of one event into one file, this skips
+ *      the block no, and the block data type in the file name
+ * \li -concatenate-events <br>
+ *      concatenate all events into one file, this skips the event no,
+ *      the block no, and the block data type in the file name. Currently,
+ *      this implies the -concatenate-blocks option.
+ *
+ * The file name is built from the basename, the event number, the block
+ * number and the data type in the format:
+ * <pre>
+ * basename_eventno_blockno_dt
+ * </pre>
+ * If the basename was not given, \em 'event' ist used instead. A file
+ * extension after the last dot is separated from the basename and appended
+ * to the final name.
+ *
+ * The class can be used as a base class for file writers. Additional
+ * argument scan can be implemented in @ref ScanArgument which is called
+ * for each unknown argument.
  * @ingroup alihlt_component
  */
 class AliHLTFileWriter : public AliHLTDataSink  {
@@ -32,9 +62,9 @@ class AliHLTFileWriter : public AliHLTDataSink  {
   /** destructor */
   virtual ~AliHLTFileWriter();
 
-  const char* GetComponentID();
-  void GetInputDataTypes( vector<AliHLTComponentDataType>& list);
-  AliHLTComponent* Spawn();
+  virtual const char* GetComponentID();
+  virtual void GetInputDataTypes( vector<AliHLTComponentDataType>& list);
+  virtual AliHLTComponent* Spawn();
 
  protected:
   /**
@@ -47,13 +77,28 @@ class AliHLTFileWriter : public AliHLTDataSink  {
    */
   int DoDeinit();
 
+  /**
+   * Init the writer.
+   * The DoInit function is not available for child classes. InitWriter is the
+   * corresponding function for classes derived from AliHLTFileWriter.
+   */
+  virtual int InitWriter();
+
+  /**
+   * Init the writer.
+   * The DoDeinit function is not available for child classes. CloseWriter is the
+   * corresponding function for classes derived from AliHLTFileWriter.
+   */
+  virtual int CloseWriter();
+
   /**
    * Data processing method for the component.
+   * The function can be overloaded by other file writer components.
    * @param evtData       event data structure
    * @param blocks        input data block descriptors
    * @param trigData     trigger data structure
    */
-  int DumpEvent( const AliHLTComponentEventData& evtData,
+  virtual int DumpEvent( const AliHLTComponentEventData& evtData,
                         const AliHLTComponentBlockData* blocks, 
                         AliHLTComponentTriggerData& trigData );
 
@@ -61,7 +106,8 @@ class AliHLTFileWriter : public AliHLTDataSink  {
    * Scan one argument and adjacent parameters.
    * Can be overloaded by child classes in order to add additional arguments
    * beyond the standard arguments of the file publisher. The method is called
-   * whenever a non-standard argument is recognized.
+   * whenever a non-standard argument is recognized. Make sure to return 
+   * <tt> -EPROTO </tt> if the argument is not recognized be the child.
    * @param argc           size of the argument array
    * @param argv           agument array for component initialization
    * @return number of processed members of the argv <br>
@@ -70,28 +116,70 @@ class AliHLTFileWriter : public AliHLTDataSink  {
    */
   virtual int ScanArgument(int argc, const char** argv);
 
- private:
   /**
    * Build file name from eventID data type and the specified directory and basename.
    * @param eventID [in]   the ID of the event
    * @param blockID [in]   the ID of the current block
+   *                       no block string appended if -1
    * @param dataType [in]  the data type of the data block
+   *                       no type string appanded if @ref kAliHLTVoidDataType
    * @param filename [out] string to receive the file name
    */
   int BuildFileName(const AliHLTEventID_t eventID, const int blockID, const AliHLTComponentDataType& dataType, TString& filename);
 
+  /**
+   * Set a mode flag.
+   * @return current mode flags
+   */
+  int SetMode(Short_t mode);
+    
+  /**
+   * Clear a mode flag.
+   * @return current mode flags
+   */
+  int ClearMode(Short_t mode);
+
+  /**
+   * Check a mode flag.
+   * @return 1 if flag is set, 0 if not
+   */
+  int CheckMode(Short_t mode);
+
+  /**
+   * Working modes of the writer
+   * @internal
+   */
+  enum TWriterMode {
+    /**
+     * flag to indicate whether to write each incoming block to separate files
+     * or all blocks of one event to one file. set = concatenate (one file).
+     */
+    kConcatenateBlocks = 0x1,
+
+    /**
+     * flag to indicate whether to concatenate incoming blocks of the same type
+     * for all events to one file. If also @ref kConcatenateBlocks is set,
+     * or all blocks of all events are written to the same file.
+     */
+    kConcatenateEvents = 0x2,
+
+    /** event enumeration flag */
+    kEnumerate = 0x4
+  };
+
+ private:
   /** the basename of the output file */
   TString    fBaseName;
+  /** the extension of the output file */
+  TString    fExtension;
   /** target directory */
   TString    fDirectory;
   /** enumeration format string */
-  TString    fEnumeration;
-  /**
-   * flag to indicate whether to write each incoming block to separate files
-   * or all blocks of one event to one file.
-   */
-  Int_t      fbSeparate;
+  TString    fCurrentFileName;
+
+  /** mode specifier, see @ref TWriterMode */
+  Short_t    fMode;
 
-  ClassDef(AliHLTFileWriter, 0)
+  ClassDef(AliHLTFileWriter, 1)
 };
 #endif
index 1410577de8ff9f3e46c187b2a317ecef374f2735..066babaf0305c9332282e292447d7f67097b8b8a 100644 (file)
@@ -28,6 +28,7 @@ using namespace std;
 
 #include "AliHLTStdIncludes.h"
 #include "AliHLTLogging.h"
+#include "TString.h"
 
 // global logging buffer
 #define LOG_BUFFER_SIZE 100
@@ -105,10 +106,14 @@ int AliHLTLogging::Message(void *param, AliHLTComponentLogSeverity severity, con
   default:
     break;
   }
-  cout << "HLT Log " << strSeverity << ": " << origin << " " << message;
-  if (strcmp(keyword, HLT_DEFAULT_LOG_KEYWORD)!=0)
-    cout << " (" << keyword << ")";
-  cout << endl;
+  TString out="HLT Log ";
+  out+=strSeverity;
+  if (origin) {out+=": "; out+=origin;}
+  out+=" "; out+=message;
+  if (keyword!=NULL && strcmp(keyword, HLT_DEFAULT_LOG_KEYWORD)!=0) {
+    out+=" ("; out+=keyword; out +=")";
+  }
+  cout << out.Data() << endl;
   return iResult;
 }
 
index 4985880bd9488d9b7635e06155dd6a249e1abef6..c461d05e3601bc7e105eb3d2e8f3c32f911e37de 100644 (file)
@@ -104,10 +104,10 @@ private:
   static  AliHLTComponentLogSeverity fGlobalLogFilter;
   AliHLTComponentLogSeverity fLocalLogFilter;
   static AliHLTfctLogging fLoggingFunc;
-  const char* fpDefaultKeyword;
-  const char* fpCurrentKeyword;
+  const char* fpDefaultKeyword; //!
+  const char* fpCurrentKeyword; //!
 
-  ClassDef(AliHLTLogging, 0)
+  ClassDef(AliHLTLogging, 1)
 };
 
 /* the class AliHLTKeyword is a simple helper class used by the HLTLogKeyword macro
index 09d0601eb3b6c6ee84b06cc9caa97bd8aebe2ca3..a2619a93e48b9dfc30825ac636d629d46b3d95e1 100644 (file)
@@ -53,7 +53,7 @@ int AliHLTProcessor::Deinit()
   return iResult;
 }
 
-int AliHLTProcessor::ProcessEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
+int AliHLTProcessor::DoProcessing( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
                            AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
                            AliHLTUInt32_t& size, AliHLTUInt32_t& outputBlockCnt, 
                            AliHLTComponentBlockData*& outputBlocks,
index 89efb58b33975585953dcacaa2a45d7162e1b208..99e2262eefb6baee8c5ff0c5d8c206f1c52483cf 100644 (file)
@@ -46,7 +46,7 @@ class AliHLTProcessor : public AliHLTComponent {
    * preparation of data structures. The call is redirected to DoEvent.
    * @return neg. error code if failed 
    */
-  int ProcessEvent( const AliHLTComponentEventData& evtData,
+  int DoProcessing( const AliHLTComponentEventData& evtData,
                    const AliHLTComponentBlockData* blocks, 
                    AliHLTComponentTriggerData& trigData,
                    AliHLTUInt8_t* outputPtr, 
diff --git a/HLT/BASE/AliHLTRootFileWriterComponent.cxx b/HLT/BASE/AliHLTRootFileWriterComponent.cxx
new file mode 100644 (file)
index 0000000..4ca28d0
--- /dev/null
@@ -0,0 +1,91 @@
+// @(#) $Id$
+
+/** @file   AliHLTRootFileWriterComponent.cxx
+    @author Matthias Richter
+    @date   
+    @brief  Base class for writer components to store data in a ROOT file
+
+                                                                          */
+
+#include "AliHLTRootFileWriterComponent.h"
+#include "TFile.h"
+#include "TString.h"
+
+/** ROOT macro for the implementation of ROOT specific class methods */
+ClassImp(AliHLTRootFileWriterComponent)
+
+AliHLTRootFileWriterComponent::AliHLTRootFileWriterComponent()
+  :
+  fEventID(kAliHLTVoidEventID),
+  fCurrentFile(NULL)
+{
+  // all blocks of one event go into the same file
+  SetMode(kConcatenateBlocks);
+}
+
+AliHLTRootFileWriterComponent::~AliHLTRootFileWriterComponent()
+{
+}
+
+int AliHLTRootFileWriterComponent::DumpEvent( const AliHLTComponentEventData& evtData,
+                                           const AliHLTComponentBlockData* blocks, 
+                                           AliHLTComponentTriggerData& trigData )
+{
+  int iResult=0;
+  // this function will be implemented in conjunction with the high-level
+  // component interface
+  HLTWarning("not yet implemented");
+  return iResult;
+}
+
+int AliHLTRootFileWriterComponent::ScanArgument(int argc, const char** argv)
+{
+  // no other arguments known
+  int iResult=-EPROTO;
+  return iResult;
+}
+
+int AliHLTRootFileWriterComponent::WriteObject(const AliHLTEventID_t eventID, TObject *pOb)
+{
+  int iResult=0;
+  if (pOb) {
+    HLTDebug("write object %p (%s)", pOb, pOb->GetName());
+    if (CheckMode(kConcatenateEvents) && eventID != fEventID &&
+       fCurrentFile!=NULL && eventID!=kAliHLTVoidEventID) {
+      TFile* pFile=fCurrentFile; fCurrentFile=NULL;
+      pFile->Close(); delete pFile;
+    }
+    if (fCurrentFile==NULL) {
+      fCurrentFile=OpenFile(eventID, 0);
+      if (fCurrentFile) fEventID=eventID;
+    }
+    if (fCurrentFile) {
+      fCurrentFile->cd();
+      pOb->Write();
+    } else {
+      iResult=-EBADF;
+    }
+  }
+  return iResult;
+}
+
+TFile* AliHLTRootFileWriterComponent::OpenFile(const AliHLTEventID_t eventID, const int blockID, const char* option)
+{
+  TFile* pFile=NULL;
+  TString filename("");
+  if ((BuildFileName(eventID, blockID, kAliHLTVoidDataType, filename))>=0 && filename.IsNull()==0) {
+    pFile=new TFile(filename, option);
+    if (pFile) {
+      if (pFile->IsZombie()) {
+       delete pFile;
+       pFile=NULL;
+       HLTError("can not open ROOT file %s", filename.Data());
+      }
+    } else {
+      HLTFatal("memory allocation failed");
+    }
+  } else {
+    HLTError("failed to build a new file name for event %#8x", eventID);
+  }
+  return pFile;
+}
diff --git a/HLT/BASE/AliHLTRootFileWriterComponent.h b/HLT/BASE/AliHLTRootFileWriterComponent.h
new file mode 100644 (file)
index 0000000..cccca96
--- /dev/null
@@ -0,0 +1,97 @@
+// @(#) $Id$
+
+#ifndef ALIHLTROOTFILEWRITERCOMPONENT_H
+#define ALIHLTROOTFILEWRITERCOMPONENT_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/** @file   AliHLTRootFileWriterComponent.h
+    @author Matthias Richter
+    @date   
+    @brief  Base class for writer components to store data in a ROOT file
+
+                                                                          */
+#include "AliHLTFileWriter.h"
+#include "TObject.h" 
+
+class TFile;
+
+/**
+ * @class AliHLTRootFileWriterComponent
+ * @see AliHLTFileWriter for parameters
+ */
+class AliHLTRootFileWriterComponent : public AliHLTFileWriter
+{
+ public:
+  /** standard constructor */
+  AliHLTRootFileWriterComponent();
+  /** destructor */
+  ~AliHLTRootFileWriterComponent();
+
+  /**
+   * The id of the component.
+   * @return component id (string)
+   */
+  virtual const char* GetComponentID() {return "ROOTFileWriter";};
+
+  /**
+   * Spawn function.
+   * @return new class instance
+   */
+  virtual AliHLTComponent* Spawn() {return new AliHLTRootFileWriterComponent;}
+
+ protected:
+  /**
+   * Data processing method for the component.
+   * The function can be overloaded by specific ROOT file writer
+   * components.
+   * @param evtData       event data structure
+   * @param blocks        input data block descriptors
+   * @param trigData     trigger data structure
+   */
+  virtual int DumpEvent( const AliHLTComponentEventData& evtData,
+                        const AliHLTComponentBlockData* blocks, 
+                        AliHLTComponentTriggerData& trigData );
+
+  /**
+   * Scan one argument and adjacent parameters.
+   * \b IMPORTANT: if  overloaded by child class, call this function
+   * as the default from the cutomized switch, e.g.
+   * <pre>
+   * </pre>
+   * @param argc           size of the argument array
+   * @param argv           agument array for component initialization
+   * @return number of processed members of the argv <br>
+   *         -EINVAL unknown argument <br>
+   *         -EPROTO parameter for argument missing <br>
+   */
+  virtual int ScanArgument(int argc, const char** argv);
+
+  /**
+   * Write ROOT object to current file.
+   * @param eventID    ID of the current event
+   * @param pOb        pointer to ROOT object
+   * @return neg. error code if failed
+   */
+  int WriteObject(const AliHLTEventID_t eventID, TObject *pOb);
+
+  /**
+   * Open a ROOT file.
+   * The function calls @ref AliHLTFileWriter::BuildFileName in order to
+   * create a file name and opens it as a root file.
+   * @param eventID    ID of the current event
+   * @param blockID    ID of the current block
+   * @param option     option as specified in TFile
+   * @return pointer to TFile object, the called has to clean-up the object after use.
+   */
+  TFile* OpenFile(const AliHLTEventID_t eventID, const int blockID=-1, const char* option="recreate");
+
+  /** the event ID associated with the current file */
+  AliHLTEventID_t fEventID;
+
+  /** the name of the current file */
+  TFile* fCurrentFile; //! transient value
+
+  ClassDef(AliHLTRootFileWriterComponent, 0)
+};
+#endif
index 14a5191298d1a430a40f4c882b519e7fab6a95cf..87e14b68155aa8ce16865fa2d0857c8a12a70327 100644 (file)
@@ -40,10 +40,9 @@ int AliHLT_C_Component_InitSystem( AliHLTComponentEnvironment* environ )
     {
       return EINPROGRESS;
     }
-  gComponentHandler_C = new AliHLTComponentHandler();
+  gComponentHandler_C = new AliHLTComponentHandler(environ);
   if ( !gComponentHandler_C )
     return EFAULT;
-  gComponentHandler_C->SetEnvironment( environ );
   gComponentHandler_C->AnnounceVersion();
   return 0;
 }
@@ -86,7 +85,10 @@ void AliHLT_C_DestroyComponent( AliHLTComponentHandle handle )
 {
   if ( !handle )
     return;
-  delete reinterpret_cast<AliHLTComponent*>( handle );
+  
+  AliHLTComponent* pComp=reinterpret_cast<AliHLTComponent*>( handle );
+  pComp->Deinit();
+  delete pComp;
 }
 
 int AliHLT_C_ProcessEvent( AliHLTComponentHandle handle, const AliHLTComponent_EventData* evtData, const AliHLTComponent_BlockData* blocks, 
index 03ababd55d0de4e11d1c0b73eeb2f05c99eab87d..fef323bff31c6696d9e259744780b1e21c593f1e 100644 (file)
@@ -19,6 +19,7 @@
 #pragma link C++ class AliHLTDataSink;
 #pragma link C++ class AliHLTFilePublisher;
 #pragma link C++ class AliHLTFileWriter;
+#pragma link C++ class AliHLTRootFileWriterComponent;
 
 #endif
 
index ceedd7445370b2e09533980dc7383239a01c8460..b54f636db9937e6ffcc7cd2a515cd6d64669a237 100644 (file)
@@ -1,11 +1,22 @@
+2007-02-05
+       - improvements in AliHLTFilePublisher/Writer
+       - small fix in component handler to pipe log messages during registration
+         of standard components into right log channel
+       - the ProcessEvent method is now a method of the component base class,
+         the actual processing method to implement is DoProcessing
+       - new standard component AliHLTRootFileWriterComponent added
+       - TPCLib: AliHLTTPCEsdWriterComponent added, conversion of AliHLTTPCTrack
+         to AliTPCtrack implemented (not finished)
+       - small fixes in stand-alone build system (libAliHLTPHOS.pkg, *LinkDef.h)
+       
 2007-01-19
        - AliHLTFileWriter added, handling of standard components in libHLT
          added to ComponentHandler
        - several fixes in the HLT offline framework
 2007-01-05
        - changes according to coding conventions and documentation
-       - AliHLTTPCDigitReaderRaw: HAVE_TPC_MAPPING dependend implementation
-         fixed in order to make class definition independend
+       - AliHLTTPCDigitReaderRaw: HAVE_TPC_MAPPING dependent implementation
+         fixed in order to make class definition independent
        - helper functions for data structure handling added
        - libHLTbase.pkg and libAliHLTSample.pkg included to the stand-alone
          build system
index f668da6545ea2b2d259d092d886b31c3f6452aea..ee1cfa69f881dad8151e9319ba84fdbe6e877e08 100644 (file)
@@ -22,6 +22,7 @@ SUBDIRS               = BASE \
 
 EXTRA_DIST             = libHLTbase.pkg \
                          libAliHLTSample.pkg \
+                         libAliHLTPHOS.pkg \
                          hlt.conf
 
 DIST_SUBDIRS           = $(SUBDIRS)
index 7645506b9c60fcfc1504c45c2e6215484e3efc22..5a67662f624f56aadc358817b01afe4a1df047b0 100644 (file)
@@ -3,6 +3,8 @@
 
 MODULE                                 = AliHLTPHOS
 
+EXTRA_DIST                     = AliHLTPHOSLinkDef.h
+
 AM_CPPFLAGS                    = @ALIROOT_CPPFLAGS@ \
                                  -I$(top_srcdir)/BASE
 
diff --git a/HLT/TPCLib/AliHLTTPCEsdWriterComponent.cxx b/HLT/TPCLib/AliHLTTPCEsdWriterComponent.cxx
new file mode 100644 (file)
index 0000000..9e2f09e
--- /dev/null
@@ -0,0 +1,148 @@
+// @(#) $Id$
+
+/** @file   AliHLTTPCEsdWriterComponent.cxx
+    @author Matthias Richter
+    @date   
+    @brief  Writer component to store tracks of the HLT TPC conformal
+            mapping tracker in the AliESD format
+
+                                                                          */
+#include "AliHLTTPCEsdWriterComponent.h"
+#include "AliESD.h"
+#include "TTree.h"
+#include "AliHLTTPCTrack.h"
+#include "AliHLTTPCTrackArray.h"
+#include "AliHLTTPCTrackletDataFormat.h"
+#include "AliHLTTPCDefinitions.h"
+
+/** global instance for component registration */
+AliHLTTPCEsdWriterComponent gTPCEsdWriter;
+
+/** ROOT macro for the implementation of ROOT specific class methods */
+ClassImp(AliHLTTPCEsdWriterComponent)
+
+AliHLTTPCEsdWriterComponent::AliHLTTPCEsdWriterComponent()
+  :
+  fTree(NULL),
+  fESD(NULL)
+{
+}
+
+AliHLTTPCEsdWriterComponent::~AliHLTTPCEsdWriterComponent()
+{
+}
+
+int AliHLTTPCEsdWriterComponent::InitWriter()
+{
+  int iResult=0;
+  fESD = new AliESD;
+  if (fESD) {
+    fTree = new TTree("esdTree", "Tree with HLT ESD objects");
+    if (fTree) {
+      fTree->Branch("ESD", "AliESD", &fESD);
+    }
+    delete fESD;
+    fESD=NULL;
+  }
+  if (fTree==NULL) {
+    iResult=-ENOMEM;
+  }
+  return iResult;
+}
+
+int AliHLTTPCEsdWriterComponent::CloseWriter()
+{
+  int iResult=0;
+  if (fTree) {
+    WriteObject(kAliHLTVoidEventID, fTree);
+    TTree* pTree=fTree;
+    fTree=NULL;
+    delete pTree;
+  } else {
+    HLTWarning("not initialized");
+  }
+  AliHLTRootFileWriterComponent::CloseWriter();
+}
+
+int AliHLTTPCEsdWriterComponent::DumpEvent( const AliHLTComponentEventData& evtData,
+                                           const AliHLTComponentBlockData* blocks, 
+                                           AliHLTComponentTriggerData& trigData )
+{
+  int iResult=0;
+  TTree* pTree=fTree;
+  if (pTree) {
+    fESD = new AliESD;
+    if (fESD) {
+      AliESD* pESD=fESD;
+
+      const AliHLTComponentBlockData* iter = NULL;
+      AliHLTTPCTrackArray* tracks=NULL;
+      AliHLTTPCTrackletData* inPtr=NULL;
+      for (int ndx=0; ndx<evtData.fBlockCnt && iResult>=0; ndx++) {
+       iter = blocks+ndx;
+       if ( iter->fDataType == AliHLTTPCDefinitions::gkTrackSegmentsDataType ) {
+         if (tracks==NULL) {
+           tracks=new AliHLTTPCTrackArray;
+           if (tracks) {
+             inPtr=(AliHLTTPCTrackletData*)iter->fPtr;
+             HLTDebug("reading block %d: %d tracklets", ndx, inPtr->fTrackletCnt);
+             tracks->FillTracks(inPtr->fTrackletCnt, inPtr->fTracklets);
+             if ((iResult=Tracks2ESD(tracks, pESD))>=0) {
+               pTree->Fill();
+             }
+           } else {
+             iResult=-ENOMEM;
+           }
+         } else {
+           HLTWarning("can not process more than one track segment data block, "
+                      "please put a track merger in between");
+           break; // don't print the warning again
+         }
+       }
+      }
+
+
+      fESD=NULL;
+      delete pESD;
+    } else {
+      iResult=-ENOMEM;
+    }
+  }
+  return iResult;
+}
+
+int AliHLTTPCEsdWriterComponent::ScanArgument(int argc, const char** argv)
+{
+  int iResult=AliHLTRootFileWriterComponent::ScanArgument(argc, argv);
+  return iResult;
+}
+
+int AliHLTTPCEsdWriterComponent::Tracks2ESD(AliHLTTPCTrackArray* pTracks, AliESD* pESD)
+{
+  int iResult=0;
+  if (pTracks && pESD) {
+    HLTDebug("converting %d tracks from track array", pTracks->GetNTracks());
+    for (int i=0; i<pTracks->GetNTracks() && iResult>=0; i++) {
+      AliHLTTPCTrack* pTrack=(*pTracks)[i];
+      if (pTrack) {
+       int iLocal=pTrack->Convert2AliKalmanTrack();
+       if (iLocal>=0) {
+       AliESDtrack iotrack;
+       iotrack.UpdateTrackParams(pTrack,AliESDtrack::kTPCin);
+       iotrack.SetTPCPoints(pTrack->GetPoints());
+       pESD->AddTrack(&iotrack);
+       } else {
+         HLTError("conversion to AliKalmanTrack failed for track %d of %d", i, pTracks->GetNTracks());
+       }
+      } else {
+       HLTError("internal missmatch in array");
+       iResult=-EFAULT;
+      }
+    }
+    
+  } else {
+    iResult=-EINVAL;
+  }
+  return iResult;
+}
diff --git a/HLT/TPCLib/AliHLTTPCEsdWriterComponent.h b/HLT/TPCLib/AliHLTTPCEsdWriterComponent.h
new file mode 100644 (file)
index 0000000..84b9b38
--- /dev/null
@@ -0,0 +1,100 @@
+// @(#) $Id$
+
+#ifndef ALIHLTTPCESDWRITERCOMPONENT_H
+#define ALIHLTTPCESDWRITERCOMPONENT_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/** @file   AliHLTTPCEsdWriterComponent.h
+    @author Matthias Richter
+    @date   
+    @brief  Writer component to store tracks of the HLT TPC conformal
+            mapping tracker in the AliESD format
+
+                                                                          */
+#include "AliHLTRootFileWriterComponent.h"
+
+// forward declarations
+class TTree;
+class AliESD;
+class AliHLTTPCTrackArray;
+
+/**
+ * @class AliHLTRootFileWriterComponent
+ * @see AliHLTFileWriter for parameters
+ */
+class AliHLTTPCEsdWriterComponent : public AliHLTRootFileWriterComponent
+{
+ public:
+  /** standard constructor */
+  AliHLTTPCEsdWriterComponent();
+  /** destructor */
+  ~AliHLTTPCEsdWriterComponent();
+
+  /**
+   * The id of the component.
+   * @return component id (string)
+   */
+  const char* GetComponentID() {return "TPCEsdWriter";};
+
+  /**
+   * Spawn function.
+   * @return new class instance
+   */
+  AliHLTComponent* Spawn() {return new AliHLTTPCEsdWriterComponent;}
+
+ protected:
+  /**
+   * Data processing method for the component.
+   * The function can be overloaded by specific ROOT file writer
+   * components.
+   * @param evtData       event data structure
+   * @param blocks        input data block descriptors
+   * @param trigData     trigger data structure
+   */
+  virtual int DumpEvent( const AliHLTComponentEventData& evtData,
+                        const AliHLTComponentBlockData* blocks, 
+                        AliHLTComponentTriggerData& trigData );
+
+  /**
+   * Scan one argument and adjacent parameters.
+   * @param argc           size of the argument array
+   * @param argv           agument array for component initialization
+   * @return number of processed members of the argv <br>
+   *         -EINVAL unknown argument <br>
+   *         -EPROTO parameter for argument missing <br>
+   */
+  int ScanArgument(int argc, const char** argv);
+
+ private:
+  /**
+   * Init the writer.
+   * The DoInit function is not available for this child class. InitWriter is the
+   * corresponding function for classes derived from AliHLTFileWriter.
+   */
+  int InitWriter();
+
+  /**
+   * Init the writer.
+   * The DoDeinit function is not available for this child class. CloseWriter is the
+   * corresponding function for classes derived from AliHLTFileWriter.
+   */
+  int CloseWriter();
+
+  /**
+   * Covert tracks to AliTPCtracks (AliKalmanTracks) and add them to ESD.
+   * @param pTracks  array of tracks
+   * @param pESD     pointer to ESD
+   * @return neg. error code if failed
+   */
+  int Tracks2ESD(AliHLTTPCTrackArray* pTracks, AliESD* pESD);
+
+  /** the ESD tree */
+  TTree* fTree; //! transient value
+
+  /** the ESD */
+  AliESD* fESD; //! transient value
+
+  ClassDef(AliHLTTPCEsdWriterComponent, 0)
+};
+#endif
index 97722c95ba14904e135958615edc51504a64e650..f855cf6e87cd649e0bd37c481fbe0add6ea4dfb6 100644 (file)
@@ -47,8 +47,8 @@ class AliHLTTPCGlobalMergerComponent : public AliHLTProcessor
        
     private:
 
-       AliHLTTPCGlobalMerger* fGlobalMerger;
-       AliHLTTPCVertex* fVertex;
+      AliHLTTPCGlobalMerger* fGlobalMerger; //!
+      AliHLTTPCVertex* fVertex; //!
 
        struct SliceData
            {
index 43fb9f762652491c07c64732cec94e9d05bf6d47..8dfa69a2b05b80bf8837ab459c2af7412c83d729 100644 (file)
@@ -163,12 +163,12 @@ Int_t AliHLTTPCPad::CalculateBaseLine(Int_t reqMinCount)
            if (fpRawData[i]>=0) AddBaseLineValue(i, fpRawData[i]);
          if (fCount>0 && fCount>=reqMinCount && fCount>=fTotal/2) {
            fAverage=fSum/fCount;
-           HLTDebug("new average %d", fAverage);
+           //HLTDebug("new average %d", fAverage);
          } else {
-           HLTDebug("baseline re-eveluation skipped because of to few "
-                      "contributing bins: total=%d, contributing=%d, req=%d"
-                      "\ndata might be already zero suppressed"
-                      , fTotal, fCount, reqMinCount);
+//         HLTDebug("baseline re-eveluation skipped because of to few "
+//                    "contributing bins: total=%d, contributing=%d, req=%d"
+//                    "\ndata might be already zero suppressed"
+//                    , fTotal, fCount, reqMinCount);
            iResult=-ENODATA;
          }
          fCount=0;fSum=-1;
@@ -188,9 +188,9 @@ Int_t AliHLTTPCPad::CalculateBaseLine(Int_t reqMinCount)
       fAverage=avBackup;
     }
   } else {
-    HLTDebug("baseline calculation skipped because of to few contributing "
-              "bins: total=%d, contributing=%d, required=%d \ndata might be "
-              "already zero suppressed", fTotal, fCount, reqMinCount);
+//     HLTDebug("baseline calculation skipped because of to few contributing "
+//            "bins: total=%d, contributing=%d, required=%d \ndata might be "
+//            "already zero suppressed", fTotal, fCount, reqMinCount);
   }
 
   return iResult;
@@ -249,9 +249,9 @@ Int_t AliHLTTPCPad::AddBaseLineValue(Int_t bin, AliHLTTPCSignal_t value)
        fBLMinBin=bin;
       }
     } else {
-      HLTDebug("ignoring value %d (bin %d) for base line calculation "
-              "(current average is %d)",
-              value, bin, fAverage);
+//       HLTDebug("ignoring value %d (bin %d) for base line calculation "
+//            "(current average is %d)",
+//            value, bin, fAverage);
     }
   }
   return iResult;
index ddea52d63ff0f1bc4e6002b2011cfaecbe3f42cf..37cc91cd408e74b01f28c1ceb1ae37e744b8614d 100644 (file)
@@ -1,8 +1,27 @@
 // @(#) $Id$
 // Original: AliHLTTrack.cxx,v 1.32 2005/06/14 10:55:21 cvetan 
 
-// Author: Anders Vestbo <mailto:vestbo$fi.uib.no>, Uli Frankenfeld <mailto:franken@fi.uib.no>
-//*-- Copyright &copy ALICE HLT Group
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Authors: Matthias Richter <Matthias.Richter@ift.uib.no>                *
+ *          Timm Steinbeck <timm@kip.uni-heidelberg.de>                   *
+ *          for The ALICE Off-line 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   AliHLTTPCTrack.cxx
+    @author Anders Vestbo, Uli Frankenfeld, Matthias Richter
+    @date   
+    @brief  HLT TPC track implementation (conformal mapping) */
+
 
 #include "AliHLTTPCLogging.h"
 #include "AliHLTTPCTrack.h"
 using namespace std;
 #endif
 
-/** \class AliHLTTPCTrack
-//<pre>
-//_____________________________________________________________
-// AliHLTTPCTrack
-//
-// Track base class
-//Begin_Html
-//<img src="track_coordinates.gif">
-//End_Html
-</pre>
-*/
-
 ClassImp(AliHLTTPCTrack)
 
 
@@ -64,7 +71,7 @@ AliHLTTPCTrack::AliHLTTPCTrack()
   fPointPsi=0;
 }
 
-void AliHLTTPCTrack::Set(AliHLTTPCTrack *tpt)
+void AliHLTTPCTrack::Copy(AliHLTTPCTrack *tpt)
 {
   //setter
   SetRowRange(tpt->GetFirstRow(),tpt->GetLastRow());
@@ -618,3 +625,56 @@ void AliHLTTPCTrack::Print() const
 
 // END ################################################# MODIFIY JMT
 }
+
+int AliHLTTPCTrack::Convert2AliKalmanTrack()
+{
+  int iResult=0;
+  // The method has been copied from AliHLTHoughKalmanTrack and adapted
+  // to the TPC conformal mapping track parametrization
+
+  SetChi2(0.);
+  SetNumberOfClusters(GetLastRow()-GetFirstRow());
+  SetLabel(GetMCid());
+  SetFakeRatio(0.);
+  SetMass(0.13957); // just a guess
+
+  fdEdx=0;
+  Double_t alpha = fmod((GetSector()+0.5)*(2*TMath::Pi()/18),2*TMath::Pi());
+  if      (alpha < -TMath::Pi()) alpha += 2*TMath::Pi();
+  else if (alpha >= TMath::Pi()) alpha -= 2*TMath::Pi();
+
+  Double_t xhit=GetFirstPointX();
+  Double_t yhit=GetFirstPointY();
+  Double_t zhit=GetFirstPointZ();
+  Double_t psi = GetPsi();
+  Double_t kappa = GetKappa();
+  Double_t radius = GetRadius();
+  Double_t centerx = GetCenterX();
+
+  Double_t tanl = GetTgl();
+
+  Double_t cnv=1.;
+  // TODO: think about how to get the magnetic field
+  //Double_t cnv=1./(GetBz()*kB2C);
+
+  //covariance matrix
+  Double_t cov[15]={
+    0.,
+    0.,  0.,
+    0.,  0.,  0.,
+    0.,  0.,  0.,  0.,
+    0.,  0.,  0.,  0.,  0.
+  };
+
+  Double_t xx[5];
+  xx[0] = yhit;
+  xx[1] = zhit;
+  xx[2] = (xhit-centerx)/radius;
+  xx[3] = tanl;
+  xx[4] = kappa*cnv;
+  // the Set function was not available in earlier versions, check required in
+  // configure.ac
+  //Set(xhit,alpha,xx,cov);
+
+  return iResult;
+}
index bc766a8f764d2821df7ec23143ddc7ec3ffcc619..5e3fa751e9c0fd8e1db5d893cff62414f30421c1 100644 (file)
@@ -1,20 +1,57 @@
+// XEmacs -*-C++-*-
 // @(#) $Id$
 // Original: AliHLTTrack.h,v 1.18 2005/03/31 04:48:58 cvetan 
+
 #ifndef ALIHLTTPCTRACK_H
 #define ALIHLTTPCTRACK_H
 
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/** @file   AliHLTTPCTrack.h
+    @author Anders Vestbo, Uli Frankenfeld, Matthias Richter
+    @date   
+    @brief  HLT TPC track base class (conformal mapping)
+*/
+
+#include "AliTPCtrack.h"
+
 class AliHLTTPCVertex;
 class AliHLTTPCSpacePointData;
 
-class AliHLTTPCTrack {
+/**
+ * @class AliHLTTPCTrack
+ * This class implements the representation of a TPC track, used by the
+ * HLT conformal mapping track finder. <br>
+ * It was originally separated from the offline TPC track class, but in
+ * order to adjust the output format to the offline ESD, AliHLTTPCTrack
+ * now inherits from AliHLTtrack.
+ */
+class AliHLTTPCTrack : public AliTPCtrack {
 
  public:
   
   AliHLTTPCTrack();
   virtual ~AliHLTTPCTrack();
   
-  virtual void Set(AliHLTTPCTrack* track);
+  /**
+   * Copy track parameters.
+   * @param track   pointer to source track
+   */
+  virtual void Copy(AliHLTTPCTrack* track);
+
+  /**
+   * Compare two tracks by the number of hits
+   * @return 0 if equal number of hits, 
+   *         1 if this > track
+   *        -1 if this < track
+   */
   virtual Int_t Compare(const AliHLTTPCTrack *track) const;
+
+  /**
+   * Fit the assigned spacepoints to a helix.
+   * The function sets teh track parameters.
+   */
   virtual void CalculateHelix();
   
   Bool_t CalculateReferencePoint(Double_t angle,Double_t radius=132);//Calculate Reference Point
@@ -109,6 +146,15 @@ class AliHLTTPCTrack {
   void SetCharge(Int_t f) {fQ = f;}
   void ComesFromMainVertex(Bool_t f) {fFromMainVertex = f;}
 
+  /**
+   * Convert all track parameters to the format of AliKalmanTrack
+   * The AliKalmanTrack class implements the track parametrization for offline ITS, TPC
+   * and TRD tracking. The function calculates and sets the parameters of the
+   * parent class (Note: AliHLTTPCTrack inherits from AliTPCtrack and thus
+   * AliKalmanTrack).
+   */
+  int Convert2AliKalmanTrack();
+
  private:
 
   Int_t fNHits; //Number of hits
@@ -154,6 +200,6 @@ class AliHLTTPCTrack {
 
   Bool_t IsPoint(Bool_t ispoint) {fIsPoint = ispoint;return fIsPoint;}
   
-  ClassDef(AliHLTTPCTrack,1) //Base track class
+  ClassDef(AliHLTTPCTrack,2) //Base track class
 };
 #endif
index 4e8d79a4f9b705bd7737aeb2b179ea8767501b1f..11a0620bfa79869dc2cecb832f6f7c6bc27a3ac9 100644 (file)
@@ -433,7 +433,7 @@ void AliHLTTPCTrackArray::AddLast(AliHLTTPCTrack *track)
 {
   //add track to last position
   AliHLTTPCTrack *tpt = NextTrack();
-  tpt->Set(track);
+  tpt->Copy(track);
   
 }
 
@@ -454,7 +454,7 @@ void AliHLTTPCTrackArray::AddTracks(AliHLTTPCTrackArray *newtrack,Bool_t remove_
     if(remove_old)
       newtrack->Remove(i);
     AliHLTTPCTrack *track = NextTrack();
-    track->Set(tpt);
+    track->Copy(tpt);
     if(slice>=0)
       track->Rotate(slice); //Rotate track to global coordinates
     /*
@@ -465,7 +465,7 @@ void AliHLTTPCTrackArray::AddTracks(AliHLTTPCTrackArray *newtrack,Bool_t remove_
       else
 #endif
       track = NextTrack();
-      track->Set(tpt);
+      track->Copy(tpt);
     */
   }
 }
@@ -570,4 +570,8 @@ Int_t AliHLTTPCTrackArray::TrackCompare(AliHLTTPCTrack *a, AliHLTTPCTrack *b) co
   */
 }
 
-
+AliHLTTPCTrack* AliHLTTPCTrackArray::operator[](int index)
+{
+  if (index<fNTracks) return fTrack[index];
+  return NULL;
+}
index 8d5a5e125c26add9a01529cddc5ff9ba708f249f..9a7ea14560a1c4e2aa251ede356d8add79b77fe7 100644 (file)
@@ -57,7 +57,9 @@ class AliHLTTPCTrackArray {
   void AddTracks(AliHLTTPCTrackArray *newtrack,Bool_t remove_old=kTRUE,Int_t slice=-1);//add all Tracks to this 
   void AddLast(AliHLTTPCTrack *track);
 
-  ClassDef(AliHLTTPCTrackArray,1) //Track array class
+  AliHLTTPCTrack* operator[](int index);
+
+  ClassDef(AliHLTTPCTrackArray,2) //Track array class
 };
 
 #endif
index 21b962350fec0689e813b04261786a060679bf77..01a21ab9fff690f0ff8b4684c96612334df4e6e5 100644 (file)
@@ -57,7 +57,8 @@ libAliHLTTPC_la_SOURCES               = AliHLTTPCLog.cxx \
                                  AliHLTTPCClusterFinderComponent.cxx \
                                  AliHLTTPCVertexFinderComponent.cxx \
                                  AliHLTTPCSliceTrackerComponent.cxx \
-                                 AliHLTTPCGlobalMergerComponent.cxx
+                                 AliHLTTPCGlobalMergerComponent.cxx \
+                                 AliHLTTPCEsdWriterComponent.cxx
 
 
 #                                AliHLTTPCClustFinderNew.cxx \
@@ -109,7 +110,8 @@ CLASS_HDRS                  = AliHLTTPCLog.h \
                                  AliHLTTPCClusterFinderComponent.h \
                                  AliHLTTPCVertexFinderComponent.h \
                                  AliHLTTPCSliceTrackerComponent.h \
-                                 AliHLTTPCGlobalMergerComponent.h
+                                 AliHLTTPCGlobalMergerComponent.h \
+                                 AliHLTTPCEsdWriterComponent.h
 
 #                                AliHLTTPCClustFinderNew.h \
 #                                AliHLTTPC.h
index 2aa255742933fe77fb67bf53144a4cbbe169e227..19fc15db51134a67f2823e934669f75d8f454afe 100644 (file)
@@ -14,6 +14,7 @@ MODULE_SRCS=  AliHLTComponent.cxx \
                AliHLTDataSource.cxx \
                AliHLTDataSink.cxx \
                AliHLTFilePublisher.cxx \
+               AliHLTRootFileWriterComponent.cxx \
                AliHLTFileWriter.cxx
 
 CLASS_HDRS:=   AliHLTComponent.h \
@@ -28,6 +29,7 @@ CLASS_HDRS:=          AliHLTComponent.h \
                AliHLTDataSource.h \
                AliHLTDataSink.h \
                AliHLTFilePublisher.h \
+               AliHLTRootFileWriterComponent.h \
                AliHLTFileWriter.h
 
 MODULE_HDRS:=  $(CLASS_HDRS) \
index a3aa7ec6b30bb20c18055f5ed6cba04803ccdebe..b9765ef2bcb096bcb0466e9480cd5e51dcc59de9 100644 (file)
@@ -26,7 +26,7 @@ $(DICTCPP:.cxx=.h): $(DICTCPP)
 
 $(DICTCPP): $(DICTHEADERS:%=$(srcdir)/%) $(DICTDEF)
        if [ -x $(ROOTCINT) ]; then $(ROOTCINT) -f $@ -c $(CPPFLAGS) $(AM_CPPFLAGS) $(DEFS) $(foreach i, $(DICTINCLUDE), $(i)) $^ ; fi
-$(DICTDEF): Makefile.am
+$(DICTDEF): Makefile.am $(PKGDEF)
        @echo '//automatically generated ROOT DICT definition' > $@
        @echo '//!!! DO NOT EDIT THIS FILE !!!' >> $@
        @echo '//add further class definitions to the CLASS_HDRS variable in Makefile.am' >> $@