- adapted to AliRoot logging system, messages printed out via AliRoot
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 13 Mar 2007 10:26:55 +0000 (10:26 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 13 Mar 2007 10:26:55 +0000 (10:26 +0000)
  message channel
- AliRoot logging methods can be used in the same way as in AliRoot
- HLT TPC logging methods fixed to be redirected to the common logging
  channel
- handling of configurations corrected in order to cope with the
  Root CINT garbage collection.
- TPCLib stand-alone build system changed in order to use AliRoot package
  definition

22 files changed:
HLT/AUTHORS
HLT/BASE/AliHLTConfiguration.cxx
HLT/BASE/AliHLTConfiguration.h
HLT/BASE/AliHLTConfigurationHandler.h
HLT/BASE/AliHLTLogging.cxx
HLT/BASE/AliHLTLogging.h
HLT/BASE/AliHLTSystem.cxx
HLT/BASE/AliHLTSystem.h
HLT/BASE/Makefile.am
HLT/ChangeLog
HLT/README
HLT/TPCLib/AliHLTTPCConfMapTrack.cxx
HLT/TPCLib/AliHLTTPCConfMapper.cxx
HLT/TPCLib/AliHLTTPCLog.cxx
HLT/TPCLib/AliHLTTPCLog.h
HLT/TPCLib/AliHLTTPCLogging.h
HLT/TPCLib/AliHLTTPCTransform.cxx
HLT/TPCLib/Makefile.am
HLT/configure.ac
HLT/libAliHLTSample.pkg
HLT/libAliHLTTPC.pkg
HLT/libHLTbase.pkg

index 77f73b6..01ae25b 100644 (file)
@@ -26,10 +26,13 @@ SampleLib: Examples by Timm M. Steinbeck and Matthias Richter
 
 TPCLib: The original TPC code was written by Anders S Vestbo and Constantin
 Loizides and was checked in under HLT/src. The code has been adapted to the
-framework by Timm. Contributions by Cvetan Cheshkov, Jochen Theader and 
-Matthias Richter.
+framework by Timm Steinbeck and further developed by Matthias Richter.
+Contributions by Cvetan Cheshkov, Jochen Theader, Gaute Ovrebekk.
+
+PHOS: Per Thomas Hille, Yuri Kharlov, Boris Polichtchouk, Oystein Djuvsland
+
+TRD: Mateusz Ploskon
 
 Further author notice will be added in conjunction with new modules.
 
 Thanks to Christian H. Christensen for help with autotools and macros.
-
index bb15d4c..3e6af6c 100644 (file)
@@ -77,29 +77,34 @@ AliHLTConfiguration::AliHLTConfiguration(const char* id, const char* component,
   }
 }
 
-AliHLTConfiguration::AliHLTConfiguration(const AliHLTConfiguration&)
+AliHLTConfiguration::AliHLTConfiguration(const AliHLTConfiguration& src)
   :
   TObject(),
   AliHLTLogging(),
-  fID(NULL),
-  fComponent(NULL),
-  fStringSources(NULL),
+  fID(src.fID),
+  fComponent(src.fComponent),
+  fStringSources(src.fStringSources),
   fNofSources(-1),
   fListSources(),
   fListSrcElement(),
-  fArguments(NULL),
+  fArguments(src.fArguments),
   fArgc(-1),
   fArgv(NULL)
 { 
   // see header file for function documentation
   fListSrcElement=fListSources.begin();
-  HLTFatal("copy constructor untested");
 }
 
-AliHLTConfiguration& AliHLTConfiguration::operator=(const AliHLTConfiguration&)
+AliHLTConfiguration& AliHLTConfiguration::operator=(const AliHLTConfiguration& src)
 { 
   // see header file for function documentation
-  HLTFatal("assignment operator untested");
+  fID=src.fID;
+  fComponent=src.fComponent;
+  fStringSources=src.fStringSources;
+  fNofSources=-1;
+  fArguments=src.fArguments;
+  fArgc=-1;
+  fArgv=NULL;
   return *this;
 }
 
@@ -131,16 +136,20 @@ int AliHLTConfiguration::GlobalInit(AliHLTConfigurationHandler* pHandler)
   // see header file for function documentation
   int iResult=0;
   if (fgConfigurationHandler!=NULL) {
-    fgConfigurationHandler->Logging(kHLTLogWarning, "AliHLTConfiguration::GlobalInit", HLT_DEFAULT_LOG_KEYWORD, "configuration handler already initialized, overriding object %p", fgConfigurationHandler);
+    fgConfigurationHandler->Logging(kHLTLogWarning, "AliHLTConfiguration::GlobalInit", HLT_DEFAULT_LOG_KEYWORD, "configuration handler already initialized, overriding object %p with %p", fgConfigurationHandler, pHandler);
   }
   fgConfigurationHandler=pHandler;
   return iResult;
 }
 
-int AliHLTConfiguration::GlobalDeinit()
+int AliHLTConfiguration::GlobalDeinit(AliHLTConfigurationHandler* pHandler)
 {
   // see header file for function documentation
   int iResult=0;
+  if (pHandler!=NULL && fgConfigurationHandler!=pHandler) {
+    fgConfigurationHandler->Logging(kHLTLogWarning, "AliHLTConfiguration::GlobalDeinit", HLT_DEFAULT_LOG_KEYWORD, "handler %p is not set, skip ...", pHandler);
+    return -EBADF;
+  }
   fgConfigurationHandler=NULL;
   return iResult;
 }
@@ -1014,25 +1023,23 @@ void AliHLTTask::PrintStatus()
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-TList AliHLTConfigurationHandler::fgListConfigurations;
-TList AliHLTConfigurationHandler::fgListDynamicConfigurations;
-
 /** ROOT macro for the implementation of ROOT specific class methods */
 ClassImp(AliHLTConfigurationHandler)
 
 AliHLTConfigurationHandler::AliHLTConfigurationHandler()
 {
   // see header file for function documentation
+  SetLocalLogLevel(kHLTLogInfo);
 }
 
 AliHLTConfigurationHandler::~AliHLTConfigurationHandler()
 {
   // see header file for function documentation
-  TObjLink* lnk=fgListDynamicConfigurations.FirstLink();
+  TObjLink* lnk=fgListConfigurations.FirstLink();
   while (lnk) {
     TObject* obj=lnk->GetObject();
     if (fgListConfigurations.FindObject(obj->GetName())==NULL) {
-      HLTDebug("delete dynamic configuration \"%s\"", obj->GetName());
+      HLTDebug("delete configuration \"%s\"", obj->GetName());
       delete obj;
     }
     lnk=lnk->Next();
@@ -1045,14 +1052,15 @@ int AliHLTConfigurationHandler::RegisterConfiguration(AliHLTConfiguration* pConf
   int iResult=0;
   if (pConf) {
     if (FindConfiguration(pConf->GetName()) == NULL) {
-      fgListConfigurations.Add(pConf);
-      //HLTDebug("configuration \"%s\" registered", pConf->GetName());
+      AliHLTConfiguration* pClone=new AliHLTConfiguration(*pConf);
+      fgListConfigurations.Add(pClone);
+      HLTDebug("configuration \"%s\" registered", pClone->GetName());
 
       // mark all configurations with unresolved dependencies for re-evaluation
       TObjLink* lnk=fgListConfigurations.FirstLink();
       while (lnk) {
        AliHLTConfiguration* pSrc=(AliHLTConfiguration*)lnk->GetObject();
-       if (pSrc && pSrc!=pConf && pSrc->SourcesResolved()!=1) {
+       if (pSrc && pSrc!=pClone && pSrc->SourcesResolved()!=1) {
          pSrc->InvalidateSources();
        }
        lnk=lnk->Next();
@@ -1079,8 +1087,6 @@ int AliHLTConfigurationHandler::CreateConfiguration(const char* id, const char*
       delete pConf;
       pConf=NULL;
       iResult=-EEXIST;
-    } else {
-      fgListDynamicConfigurations.Add(pConf);
     }
   } else {
     HLTError("system error: object allocation failed");
@@ -1110,6 +1116,8 @@ int AliHLTConfigurationHandler::RemoveConfiguration(const char* id)
     AliHLTConfiguration* pConf=NULL;
     if ((pConf=FindConfiguration(id))!=NULL) {
       iResult=RemoveConfiguration(pConf);
+      delete pConf;
+      pConf=NULL;
     } else {
       HLTWarning("can not find configuration \"%s\"", id);
       iResult=-ENOENT;
index 1929177..707b0a9 100644 (file)
@@ -63,11 +63,10 @@ class AliHLTConfiguration : public TObject, public AliHLTLogging {
    */
   AliHLTConfiguration(const char* id, const char* component,
                      const char* sources, const char* arguments);
-  /** not a valid copy constructor, defined according to effective C++ style */
-  AliHLTConfiguration(const AliHLTConfiguration&);
-  /** not a valid assignment op, but defined according to effective C++ style */
-  AliHLTConfiguration& operator=(const AliHLTConfiguration&);
-  /** destructor */
+  /** copy constructor */
+  AliHLTConfiguration(const AliHLTConfiguration& src);
+  /** assignment op */
+  AliHLTConfiguration& operator=(const AliHLTConfiguration& src);
   /** destructor */
   virtual ~AliHLTConfiguration();
 
@@ -83,7 +82,7 @@ class AliHLTConfiguration : public TObject, public AliHLTLogging {
   /**
    * Global de-init and cleanup of the global configuration handler
    */
-  static int GlobalDeinit();
+  static int GlobalDeinit(AliHLTConfigurationHandler* pHandler);
 
   /*****************************************************************************
    * properties of the configuration
index c552a8d..56c18e7 100644 (file)
@@ -81,11 +81,9 @@ class AliHLTConfigurationHandler : public AliHLTLogging {
 
  private:
   /** the list of registered configurations */
-  static TList fgListConfigurations;                              // see above
-  /** the list of dynamic configurations (for proper cleanup) */
-  static TList fgListDynamicConfigurations;                       // see above
+  TList fgListConfigurations;                              // see above
 
-  ClassDef(AliHLTConfigurationHandler, 0);
+  ClassDef(AliHLTConfigurationHandler, 1);
 };
 
 #endif
index 9c3e808..60d7b98 100644 (file)
@@ -1,4 +1,4 @@
-// $Id: 
+// @(#) $Id$
 
 /**************************************************************************
  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 using namespace std;
 #endif
 
+#ifndef NOALIROOT_LOGGING
+#include "AliLog.h"
+#endif
 #include "AliHLTStdIncludes.h"
 #include "AliHLTLogging.h"
 #include "TString.h"
+#include "TArrayC.h"
+#include "Varargs.h"
+#include <string>
+#include <sstream>
+#include <iostream>
+
+/** target stream for AliRoot logging methods */
+ostringstream gLogstr;
+
+#ifndef NOALIROOT_LOGGING
+/**
+ * Notification callback for AliRoot logging methods
+ */
+void LogNotification(AliLog::EType_t level, const char* message)
+{
+  cout << "Notification handler: " << gLogstr.str() << endl;
+  AliHLTLogging hltlog;
+  hltlog.SwitchAliLog(0);
+  hltlog.Logging(kHLTLogInfo, "NotificationHandler", "AliLog", gLogstr.str().c_str());
+  gLogstr.clear();
+  string empty("");
+  gLogstr.str(empty);
+}
+#endif
 
-// global logging buffer
-#define LOG_BUFFER_SIZE 512
-char gAliHLTLoggingBuffer[LOG_BUFFER_SIZE]="";
-char gAliHLTLoggingOriginBuffer[LOG_BUFFER_SIZE]="";
+/**
+ * The global logging buffer.
+ * The buffer is created with an initial size and grown dynamically on
+ * demand.
+ */
+TArrayC gAliHLTLoggingTarget(200);
+
+/** the maximum size of the buffer */
+const int gALIHLTLOGGING_MAXBUFFERSIZE=10000;
 
 /** ROOT macro for the implementation of ROOT specific class methods */
 ClassImp(AliHLTLogging)
@@ -71,6 +103,7 @@ AliHLTLogging& AliHLTLogging::operator=(const AliHLTLogging&)
 
 AliHLTComponentLogSeverity AliHLTLogging::fGlobalLogFilter=kHLTLogAll;
 AliHLTfctLogging AliHLTLogging::fLoggingFunc=NULL;
+int AliHLTLogging::fgUseAliLog=1;
 
 AliHLTLogging::~AliHLTLogging()
 {
@@ -83,17 +116,27 @@ int AliHLTLogging::Init(AliHLTfctLogging pFun)
   if (fLoggingFunc!=NULL && fLoggingFunc!=pFun) {
     (*fLoggingFunc)(NULL/*fParam*/, kHLTLogWarning, "AliHLTLogging::Init", "no key", "overriding previously initialized logging function");    
   }
-  fLoggingFunc=pFun; 
+  fLoggingFunc=pFun;
+#ifndef NOALIROOT_LOGGING
+  // to be activated when changes to AliLog have been committed
+//   AliLog* log=new AliLog;
+//   log->SetLogNotification(LogNotification);
+//   log->SetStreamOutput(&gLogstr);
+#endif
+  
   return 0;
 }
 
-int AliHLTLogging::Message(void *param, AliHLTComponentLogSeverity severity, const char* origin, const char* keyword, const char* message) 
+int AliHLTLogging::Message(void *param, AliHLTComponentLogSeverity severity,
+                          const char* origin, const char* keyword,
+                          const char* message) 
 {
   // see header file for class documentation
   int iResult=0;
   if (param==NULL) {
     // this is currently just to get rid of the warning "unused parameter"
   }
+
   const char* strSeverity="";
   switch (severity) {
   case kHLTLogBenchmark: 
@@ -128,32 +171,84 @@ int AliHLTLogging::Message(void *param, AliHLTComponentLogSeverity severity, con
   return iResult;
 }
 
-const char* AliHLTLogging::BuildLogString(const char *format, va_list ap) 
+#ifndef NOALIROOT_LOGGING
+int AliHLTLogging::AliMessage(AliHLTComponentLogSeverity severity, 
+                             const char* origin_class, const char* origin_func,
+                             const char* file, int line, const char* message) 
 {
   // see header file for class documentation
-  int tgtLen=0;
-  int iBufferSize=LOG_BUFFER_SIZE;
-  char* tgtBuffer=gAliHLTLoggingBuffer;
-  tgtBuffer[tgtLen]=0;
 
-#if (defined LOG_PREFIX)
-  tgtLen = snprintf(tgtBuffer, iBufferSize, LOG_PREFIX); // add logging prefix
+  switch (severity) {
+  case kHLTLogBenchmark: 
+    AliLog::Message(AliLog::kInfo, message, "HLT", origin_class, origin_func, file, line);
+    break;
+  case kHLTLogDebug:
+    AliLog::Message(AliLog::kDebug, message, "HLT", origin_class, origin_func, file, line);
+    break;
+  case kHLTLogInfo:
+    AliLog::Message(AliLog::kInfo, message, "HLT", origin_class, origin_func, file, line);
+    break;
+  case kHLTLogWarning:
+    AliLog::Message(AliLog::kWarning, message, "HLT", origin_class, origin_func, file, line);
+    break;
+  case kHLTLogError:
+    AliLog::Message(AliLog::kError, message, "HLT", origin_class, origin_func, file, line);
+    break;
+  case kHLTLogFatal:
+    AliLog::Message(AliLog::kWarning, message, "HLT", origin_class, origin_func, file, line);
+    break;
+  default:
+    break;
+  }
+  return 0;
+}
 #endif
-  if (tgtLen>=0) {
-    tgtBuffer+=tgtLen; iBufferSize-=tgtLen;
-    tgtLen = vsnprintf(tgtBuffer, iBufferSize, format, ap);
-    if (tgtLen>0) {
-      tgtBuffer+=tgtLen;
-//       if (tgtLen<LOG_BUFFER_SIZE-1) {
-//     *tgtBuffer++='\n'; // add newline if space in buffer
-//      }
-      *tgtBuffer=0; // terminate the buffer
+
+const char* AliHLTLogging::BuildLogString(const char *format, va_list ap) 
+{
+  // see header file for class documentation
+
+  int iResult=0;
+  va_list bap;
+  R__VA_COPY(bap, ap);
+
+  // take the first argument from the list as format string if no
+  // format was given
+  const char* fmt = format;
+  if (fmt==NULL) fmt=va_arg(ap, const char*);
+
+  gAliHLTLoggingTarget[0]=0;
+  while (fmt!=NULL) {
+    iResult=vsnprintf(gAliHLTLoggingTarget.GetArray(), gAliHLTLoggingTarget.GetSize(), fmt, ap);
+    if (iResult==-1)
+      // for compatibility with older version of vsnprintf
+      iResult=gAliHLTLoggingTarget.GetSize()*2;
+    else if (iResult<gAliHLTLoggingTarget.GetSize())
+      break;
+
+    // terminate if buffer is already at the limit
+    if (gAliHLTLoggingTarget.GetSize()>=gALIHLTLOGGING_MAXBUFFERSIZE) {
+      gAliHLTLoggingTarget[gAliHLTLoggingTarget.GetSize()-1]=0;
+      break;
     }
-  }
-  return gAliHLTLoggingBuffer;
+
+    // check limitation and grow the buffer
+    if (iResult>gALIHLTLOGGING_MAXBUFFERSIZE) iResult=gALIHLTLOGGING_MAXBUFFERSIZE;
+    gAliHLTLoggingTarget.Set(iResult+1);
+
+    // copy the original list and skip the first argument if this was the format string
+    va_end(ap);
+    R__VA_COPY(ap, bap);
+    if (format==NULL) va_arg(ap, const char*);
+  }     
+  va_end(bap);
+
+  return gAliHLTLoggingTarget.GetArray();
 }
 
-int AliHLTLogging::Logging(AliHLTComponentLogSeverity severity, const char* origin, const char* keyword, const char* format, ... ) 
+int AliHLTLogging::Logging(AliHLTComponentLogSeverity severity,
+                          const char* origin, const char* keyword,
+                          const char* format, ... ) 
 {
   // see header file for class documentation
   int iResult=CheckFilter(severity);
@@ -163,50 +258,51 @@ int AliHLTLogging::Logging(AliHLTComponentLogSeverity severity, const char* orig
     if (fLoggingFunc) {
       iResult = (*fLoggingFunc)(NULL/*fParam*/, severity, origin, keyword, AliHLTLogging::BuildLogString(format, args ));
     } else {
-      iResult = Message(NULL/*fParam*/, severity, origin, keyword, AliHLTLogging::BuildLogString(format, args ));
+#ifndef NOALIROOT_LOGGING
+      if (fgUseAliLog)
+       iResult=AliMessage(severity, NULL, origin, NULL, 0, AliHLTLogging::BuildLogString(format, args ));
+      else
+#endif
+        iResult=Message(NULL/*fParam*/, severity, origin, keyword, AliHLTLogging::BuildLogString(format, args ));
     }
+    va_end(args);
   }
   return iResult;
 }
 
-int AliHLTLogging::LoggingVarargs( AliHLTComponentLogSeverity severity, const char* origin_class, const char* origin_func,  ... ) const
+int AliHLTLogging::LoggingVarargs(AliHLTComponentLogSeverity severity, 
+                                 const char* origin_class, const char* origin_func,
+                                 const char* file, int line,  ... ) const
 {
   // see header file for class documentation
 
+  if (file==NULL && line==0) {
+    // this is currently just to get rid of the warning "unused parameter"
+  }
   int iResult=CheckFilter(severity);
   if (iResult>0) {
-    int iMaxSize=LOG_BUFFER_SIZE-1;
-    int iPos=0;
     const char* separator="";
-    gAliHLTLoggingOriginBuffer[iPos]=0;
+    TString origin;
     if (origin_class) {
-      if ((int)strlen(origin_class)<iMaxSize-iPos) {
-       strcpy(&gAliHLTLoggingOriginBuffer[iPos], origin_class);
-       iPos+=strlen(origin_class);
+       origin+=origin_class;
        separator="::";
-      }
     }
     if (origin_func) {
-      if ((int)strlen(origin_func)+(int)strlen(separator)<iMaxSize-iPos) {
-       strcpy(&gAliHLTLoggingOriginBuffer[iPos], separator);
-       iPos+=strlen(separator);
-       strcpy(&gAliHLTLoggingOriginBuffer[iPos], origin_func);
-       iPos+=strlen(origin_func);
-      }
+       origin+=separator;
+       origin+=origin_func;
     }
     va_list args;
-    va_start(args, origin_func);
-    const char* format = va_arg(args, const char*);
+    va_start(args, line);
 
-    const char* message=format;
-    const char* qualifier=NULL;
-    if ((qualifier=strchr(format, '%'))!=NULL) {
-      message=AliHLTLogging::BuildLogString(format, args);
-    }
     if (fLoggingFunc) {
-      iResult=(*fLoggingFunc)(NULL/*fParam*/, severity, gAliHLTLoggingOriginBuffer, GetKeyword(), message);
+      iResult=(*fLoggingFunc)(NULL/*fParam*/, severity, origin.Data(), GetKeyword(), AliHLTLogging::BuildLogString(NULL, args ));
     } else {
-      iResult=Message(NULL/*fParam*/, severity, gAliHLTLoggingOriginBuffer, GetKeyword(), message);
+#ifndef NOALIROOT_LOGGING
+      if (fgUseAliLog)
+       iResult=AliMessage(severity, origin_class, origin_func, file, line, AliHLTLogging::BuildLogString(NULL, args ));
+      else
+#endif
+       iResult=Message(NULL/*fParam*/, severity, origin.Data(), GetKeyword(), AliHLTLogging::BuildLogString(NULL, args ));
     }
     va_end(args);
   }
index cf0d446..a860948 100644 (file)
@@ -1,4 +1,4 @@
-// @(#) $Id: 
+// @(#) $Id$
 
 #ifndef ALIHLTLOGGING_H
 #define ALIHLTLOGGING_H
@@ -12,8 +12,8 @@
 */
 
 #include "AliHLTDataTypes.h"
-#include <TObject.h>
 #include "AliHLTStdIncludes.h"
+#include "TObject.h"
 
 //#define LOG_PREFIX ""       // logging prefix, for later extensions
 
  * AliHLTLogging
  */
 // HLTMessage is not filtered
-#define HLTMessage( ... )   LoggingVarargs(kHLTLogNone,      NULL , NULL ,  __VA_ARGS__ )
+#define HLTMessage( ... )   LoggingVarargs(kHLTLogNone,      NULL , NULL , __FILE__ , __LINE__ , __VA_ARGS__ )
 
-#ifndef __func__
-#define __func__ "???"
+// function name
+#if defined(__GNUC__) || defined(__ICC) || defined(__ECC) || defined(__APPLE__)
+#define FUNCTIONNAME() __FUNCTION__
+#else
+#define FUNCTIONNAME() "???"
 #endif
 
 // the following macros are filtered by the Global and Local Log Filter
-#define HLTBenchmark( ... ) LoggingVarargs(kHLTLogBenchmark, this->Class_Name() , __func__ ,  __VA_ARGS__ )
-#define HLTDebug( ... )     LoggingVarargs(kHLTLogDebug,     this->Class_Name() , __func__ ,  __VA_ARGS__ )
-#define HLTInfo( ... )      LoggingVarargs(kHLTLogInfo,      this->Class_Name() , __func__ ,  __VA_ARGS__ )
-#define HLTWarning( ... )   LoggingVarargs(kHLTLogWarning,   this->Class_Name() , __func__ ,  __VA_ARGS__ )
-#define HLTError( ... )     LoggingVarargs(kHLTLogError,     this->Class_Name() , __func__ ,  __VA_ARGS__ )
-#define HLTFatal( ... )     LoggingVarargs(kHLTLogFatal,     this->Class_Name() , __func__ ,  __VA_ARGS__ )
+#define HLTBenchmark( ... ) LoggingVarargs(kHLTLogBenchmark, Class_Name() , FUNCTIONNAME() , __FILE__ , __LINE__ , __VA_ARGS__ )
+#define HLTDebug( ... )     LoggingVarargs(kHLTLogDebug,     Class_Name() , FUNCTIONNAME() , __FILE__ , __LINE__ , __VA_ARGS__ )
+#define HLTInfo( ... )      LoggingVarargs(kHLTLogInfo,      Class_Name() , FUNCTIONNAME() , __FILE__ , __LINE__ , __VA_ARGS__ )
+#define HLTWarning( ... )   LoggingVarargs(kHLTLogWarning,   Class_Name() , FUNCTIONNAME() , __FILE__ , __LINE__ , __VA_ARGS__ )
+#define HLTError( ... )     LoggingVarargs(kHLTLogError,     Class_Name() , FUNCTIONNAME() , __FILE__ , __LINE__ , __VA_ARGS__ )
+#define HLTFatal( ... )     LoggingVarargs(kHLTLogFatal,     Class_Name() , FUNCTIONNAME() , __FILE__ , __LINE__ , __VA_ARGS__ )
 
 // helper macro to set the keyword
 #define HLTLogKeyword(a)    AliHLTKeyword hltlogTmpkey__LINE__(this, a)
@@ -87,7 +90,9 @@ public:
 
   // logging function with two origin parameters, used by the log macros
   //
-  int LoggingVarargs( AliHLTComponentLogSeverity severity, const char* origin_class, const char* origin_func,  ... ) const;
+  int LoggingVarargs(AliHLTComponentLogSeverity severity, 
+                    const char* origin_class, const char* origin_func,
+                    const char* file, int line, ... ) const;
 
   // apply filter, return 1 if message should pass
   //
@@ -101,19 +106,51 @@ public:
   //
   void SetLocalLoggingLevel(AliHLTComponentLogSeverity level);
 
+  /**
+   * Print message to stdout
+   */
   static int Message(void * param, AliHLTComponentLogSeverity severity, const char* origin, const char* keyword, const char* message);
 
+#ifndef NOALIROOT_LOGGING
+  /**
+   * Print message through AliRoot log channels.
+   */
+  static int AliMessage(AliHLTComponentLogSeverity severity,
+                       const char* origin_class, const char* origin_func,
+                       const char* file, int line, const char* message);
+#endif
+
+  /**
+   * Build the log string from format specifier and variadac arguments
+   * @param format     format string of printf style
+   * @param ap         opened and initialized argument list
+   * @return const char string with the formatted message 
+   */
   static const char* BuildLogString(const char *format, va_list ap);
 
   virtual void* GetParameter() {return NULL;}
+
+  /**
+   * Switch logging through AliLog on or off
+   * @param sw          1 = logging through AliLog
+   */
+  void SwitchAliLog(int sw) {fgUseAliLog=(sw!=0);}
+
 protected:
 
 private:
-  static  AliHLTComponentLogSeverity fGlobalLogFilter;
-  AliHLTComponentLogSeverity fLocalLogFilter;
-  static AliHLTfctLogging fLoggingFunc;
-  const char* fpDefaultKeyword; //!
-  const char* fpCurrentKeyword; //!
+  /** the global logging filter */
+  static  AliHLTComponentLogSeverity fGlobalLogFilter;             // see above
+  /** the local logging filter for one class */
+  AliHLTComponentLogSeverity fLocalLogFilter;                      // see above
+  /** logging callback from the framework */
+  static AliHLTfctLogging fLoggingFunc;                            // see above
+  /** default keyword */
+  const char* fpDefaultKeyword;                                    //! transient
+  /** current keyword */
+  const char* fpCurrentKeyword;                                    //! transient
+  /** switch for logging through AliLog, default on */
+  static int fgUseAliLog;                                          // see above
 
   ClassDef(AliHLTLogging, 1)
 };
index b0c387c..be5e2b0 100644 (file)
@@ -34,19 +34,6 @@ using namespace std;
 #include "AliHLTTask.h"
 #include "TString.h"
 
-// #include <sstream>
-// #include <iostream>
-// #include "AliLog.h"
-
-// ostringstream g_logstr;
-
-// void LogNotification(AliLog::EType_t level, const char* message)
-// {
-//   cout << "notification handler" << endl;
-//   cout << g_logstr.str() << endl;
-//   g_logstr.clear();
-// }
-
 /** ROOT macro for the implementation of ROOT specific class methods */
 ClassImp(AliHLTSystem)
 
@@ -62,14 +49,15 @@ AliHLTSystem::AliHLTSystem()
   // or
   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
 
-  // init logging function in AliHLTLogging
-  Init(AliHLTLogging::Message);
+  if (fgNofInstances++>0)
+    HLTWarning("multiple instances of AliHLTSystem, you should not use more than one at a time");
+
   SetGlobalLoggingLevel(kHLTLogDefault);
   if (fpComponentHandler) {
     AliHLTComponentEnvironment env;
     memset(&env, 0, sizeof(AliHLTComponentEnvironment));
     env.fAllocMemoryFunc=AliHLTSystem::AllocMemory;
-    env.fLoggingFunc=AliHLTLogging::Message;
+    env.fLoggingFunc=NULL;
     fpComponentHandler->SetEnvironment(&env);
   } else {
     HLTFatal("can not create Component Handler");
@@ -79,11 +67,6 @@ AliHLTSystem::AliHLTSystem()
   } else {
     HLTFatal("can not create Configuration Handler");
   }
-//   AliLog log;
-//   log.SetLogNotification(LogNotification);
-//   log.SetStreamOutput(&g_logstr);
-//   AliInfo("this is a printf message");
-//   AliInfoStream() << "this is a stream message" << endl;
 }
 
 AliHLTSystem::AliHLTSystem(const AliHLTSystem&)
@@ -94,6 +77,9 @@ AliHLTSystem::AliHLTSystem(const AliHLTSystem&)
   fTaskList()
 {
   // see header file for class documentation
+  if (fgNofInstances++>0)
+    HLTWarning("multiple instances of AliHLTSystem, you should not use more than one at a time");
+
   HLTFatal("copy constructor untested");
 }
 
@@ -107,8 +93,9 @@ AliHLTSystem& AliHLTSystem::operator=(const AliHLTSystem&)
 AliHLTSystem::~AliHLTSystem()
 {
   // see header file for class documentation
+  fgNofInstances--;
   CleanTaskList();
-  AliHLTConfiguration::GlobalDeinit();
+  AliHLTConfiguration::GlobalDeinit(fpConfigurationHandler);
   if (fpConfigurationHandler) {
     delete fpConfigurationHandler;
   }
@@ -120,6 +107,8 @@ AliHLTSystem::~AliHLTSystem()
   fpComponentHandler=NULL;
 }
 
+int AliHLTSystem::fgNofInstances=0;
+
 int AliHLTSystem::AddConfiguration(AliHLTConfiguration* pConf)
 {
   // see header file for class documentation
@@ -322,7 +311,7 @@ int AliHLTSystem::Run(Int_t iNofEvents)
       HLTError("can not start task list");
     }
     DeinitTasks();
-  } else {
+  } else if (iResult!=-ENOENT) {
     HLTError("can not initialize task list");
   }
   return iResult;
@@ -333,6 +322,10 @@ int AliHLTSystem::InitTasks()
   // see header file for class documentation
   int iResult=0;
   TObjLink *lnk=fTaskList.FirstLink();
+  if (lnk==NULL) {
+    HLTWarning("Task list is empty, aborting ...");
+    return -ENOENT;
+  }
   while (lnk && iResult>=0) {
     TObject* obj=lnk->GetObject();
     if (obj) {
index 3ceebbe..e9a5579 100644 (file)
@@ -179,8 +179,11 @@ class AliHLTSystem : public AliHLTLogging {
 
   TList fTaskList;                                                 // see above
 
+  /** the number of instances of AliHLTSystem */
+  static int fgNofInstances;                                       // see above
+
  private:
-  ClassDef(AliHLTSystem, 1);
+  ClassDef(AliHLTSystem, 2);
 };
 #endif
 
index 59f6ed1..d8747e3 100644 (file)
@@ -10,7 +10,8 @@ MODULE                                = HLTbase
 
 EXTRA_DIST                     = HLTbaseLinkDef.h
 
-AM_CPPFLAGS                    = -DMODULE=$(MODULE)
+AM_CPPFLAGS                    = -DMODULE=$(MODULE) \
+                                 -I@ALICE_ROOT@/STEER
 
 bin_SCRIPTS                    = setenv.sh setenv.csh
 
@@ -34,7 +35,11 @@ libHLTbase_la_SOURCES                = $(MODULE_SRCS)
 pkginclude_HEADERS             = $(MODULE_HDRS)
 
 # linker flags
-libHLTbase_la_LDFLAGS          =  -version-info $(LIBRARY_VERSION)
+libHLTbase_la_LDFLAGS          = -L@ROOTLIBDIR@ \
+                                 @ROOTLIBS@ \
+                                 @ALIROOT_LDFLAGS@ \
+                                 @ALIROOT_LIBS@ \
+                                 -version-info $(LIBRARY_VERSION)
 
 # automatic generation of data and time of library build
 COMPILE_INFO                   =  HLTBaseCompileInfo.cxx
index 4118c90..0c92a5e 100644 (file)
@@ -1,4 +1,14 @@
-2007-01-03 changes from Gaute (TPC)
+2007-03-09 logging system
+       - adapted to AliRoot logging system, messages printed out via AliRoot
+         message channel
+       - AliRoot logging methods can be used in the same way as in AliRoot
+       - HLT TPC logging methods fixed to be redirected to the common logging
+         channel
+       - handling of configurations corrected in order to cope with the
+         Root CINT garbage collection.
+       - TPCLib stand-alone build system changed in order to use AliRoot package
+         definition
+2007-03-01 changes by Gaute (TPC)
        - added InterMerger to SliceTrackerComponent, can be switched off by
          component argument 'disable-merger'
        - new data type 'TRACKS' defined for TPC describing tracks in global
index b6a9ec9..8cc1ac1 100644 (file)
@@ -37,8 +37,9 @@ implementation and a tutorial.
 - TPCLib: The HLT code for the TPC
 - TPCLib/OnlineDisplay: HLT visualization code for the TPC
 
-Currently, the the package is not included to the standard AliRoot
-compilation, but will be part of it.
+- PHOS: The HLT code for PHOS
+
+- TRD: The HLT code for TRD
 
 The old stand-alone build system is still available. Check the README
 file in the doc folder.
@@ -90,27 +91,57 @@ Package build relies on the GNU triplet configure, make and make install.
 In order to keep the development directory clean, it is recommended to
 use a separate build directory. 
 
+It is recommended to read the complete section before the build process.
+
+5.1 For the impatiant user
+--------------------------
+
   mkdir build
   cd build
   ../configure
   make
   make install
 
-You should redirect the output of the make into a file.
+5.2 Installation directory
+--------------------------
 The default install directory is set to the current directory ($PWD). To
 override the default directory use the option --prefix=<dir>. More information
 can be obtained from the configure script by running it with option --help.
-All binary libraries will be installed under <prefix>/lib. 
+All binary libraries will be installed under <prefix>/lib.
+
 If the directory is equal to $ALICE_ROOT, the libraries will be installed under 
 <prefix>/lib/tgt_<arch> as used for AliRoot. This is a custom extension in
 order to adapt to the specific AliRoot installation directories.
 
-Some important options:
---enable-logging  # Enable/Disable logging (default enabled)
---enable-sample   # Compile the sample library
---enable-tpc      # Compile the TPC library
---enable-phos      # Compile the PHOS library
+5.3 For the AliRoot user
+------------------------
+To install all libraries in the AliRoot lib dir:
+
+  mkdir build
+  cd build
+  ../configure --prefix=$ALICE_ROOT
+  make
+  make install
 
+5.4 Package options
+-------------------
+Some important options (all options are on by default):
+--disable-sample           # disable compilation the sample library
+--disable-tpc              # disable compilation the TPC library
+--disable-phos             # disable compilation the PHOS library
+--disable-trd              # disable compilation the TRD library
+--disable-aliroot-logging  # disable logging
+
+5.5 External packages
+---------------------
+PubSub framework: the TPC online display needs the HOMER interface, which
+is currently part of the PubSub framework. It is planned to integrate it
+into AliRoot.
+If the TPC online display is not necessary one can skip this option.
+--with-pubsub=<dir>        # the top dir of the HLT PubSub framework
+
+5.6 Final remarks/further information 
+-------------------------------------
 Note: You can have several build directories with different configure options,
 but using the same source code. 
 
index d7d66af..a5b3b93 100644 (file)
@@ -251,9 +251,11 @@ void AliHLTTPCConfMapTrack::Fill(AliHLTTPCVertex *vertex,Double_t max_Dca)
            
            delete fit;
        }
-       else if(GetPt() == 0)
+       else if(GetPt() == 0) 
+       {
            LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapTrack::Fill","Tracks")<<AliHLTTPCLog::kDec<<
                "Found track with Pt=0!!!"<<ENDLOG;
+       }
        else
        {
            LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapTrack::Fill","Tracks")<<AliHLTTPCLog::kDec<<
index 87ac297..c7db9f3 100644 (file)
@@ -139,9 +139,9 @@ void AliHLTTPCConfMapper::InitVolumes()
   if(fVolume) delete [] fVolume;
   if(fRow) delete [] fRow;
   
-  LOG(AliHLTTPCLog::kInformational,"AliHLTTPCConfMapper::InitVolumes","Memory")<<AliHLTTPCLog::kDec<<
+  LOG(AliHLTTPCLog::kDebug,"AliHLTTPCConfMapper::InitVolumes","Memory")<<AliHLTTPCLog::kDec<<
     "Allocating "<<fBounds*sizeof(AliHLTTPCConfMapContainer)<<" Bytes to fVolume"<<ENDLOG;
-  LOG(AliHLTTPCLog::kInformational,"AliHLTTPCConfMapper::InitVolumes","Memory")<<AliHLTTPCLog::kDec<<
+  LOG(AliHLTTPCLog::kDebug,"AliHLTTPCConfMapper::InitVolumes","Memory")<<AliHLTTPCLog::kDec<<
     "Allocating "<<fNumRowSegmentPlusOne*sizeof(AliHLTTPCConfMapContainer)<<" Bytes to fRow"<<ENDLOG;
   
   fVolume = new AliHLTTPCConfMapContainer[fBounds];
@@ -221,7 +221,7 @@ Bool_t AliHLTTPCConfMapper::ReadHits(UInt_t count, AliHLTTPCSpacePointData* hits
     }
   fClustersUnused += nhit;
 
-  LOG(AliHLTTPCLog::kInformational,"AliHLTTPCConfMapper::ReadHits","#hits")
+  LOG(AliHLTTPCLog::kDebug,"AliHLTTPCConfMapper::ReadHits","#hits")
     <<AliHLTTPCLog::kDec<<"hit_counter: "<<nhit<<" count: "<<count<<ENDLOG;
   
   return true;
@@ -948,7 +948,7 @@ Int_t AliHLTTPCConfMapper::FillTracks()
       return 0;
     }
 
-  LOG(AliHLTTPCLog::kInformational,"AliHLTTPCConfMapper::FillTracks","fNTracks")<<AliHLTTPCLog::kDec<<
+  LOG(AliHLTTPCLog::kDebug,"AliHLTTPCConfMapper::FillTracks","fNTracks")<<AliHLTTPCLog::kDec<<
     "Number of found tracks: "<<fNTracks<<ENDLOG;
   
   //  fTrack->Sort();
index d6b73fd..ee03d37 100644 (file)
@@ -1,9 +1,7 @@
 // $Id$
 // Original: AliHLTLog.cxx,v 1.1 2004/05/14 09:37:22 loizides 
 
-#ifndef use_logging
-
-#include "AliHLTTPCLogging.h"
+#include "AliHLTTPCLog.h"
 
 AliHLTTPCLog::TLogLevel AliHLTTPCLog::fgLevel=AliHLTTPCLog::kNone;
 
@@ -11,8 +9,78 @@ const char* AliHLTTPCLog::kEnd = "";
 const char* AliHLTTPCLog::kPrec = "";
 const char* AliHLTTPCLog::kHex = "";
 const char* AliHLTTPCLog::kDec = "";
-// const std::ios_base::fmtflags AliHLTTPCLog::kHex = std::ios_base::hex;
-// const std::ios_base::fmtflags AliHLTTPCLog::kDec = std::ios_base::dec;
 
+const char* AliHLTTPCLog::fgKeyOrigin ="__origin";
+const char* AliHLTTPCLog::fgKeyKeyword="__key";
+const char* AliHLTTPCLog::fgKeyMessage="__message";
+
+stringstream AliHLTTPCLog::fgStream;
+
+AliHLTLogging AliHLTTPCLog::fgHLTLogging;
+
+const char* AliHLTTPCLog::Flush()
+{
+  int severity=0;
+  string origin("");
+  string keyword("");
+  string iter;
+  string message("");
+  int scanStatus=0;
+  fgStream >> severity;
+  while (!fgStream.eof()) {
+    fgStream >> iter;
+    if (scanStatus==0 && iter.compare(fgKeyOrigin)==0) {
+      // idicate scan of origin message
+      scanStatus=1;
+      continue;
+    } else if (scanStatus==1 && iter.compare(fgKeyKeyword)==0) {
+      // idicate scan of keyword message
+      scanStatus=2;
+      continue;
+    } else if (scanStatus==2 && iter.compare(fgKeyMessage)==0) {
+      scanStatus=3;
+      continue;
+    }
+    switch (scanStatus) {
+    case 1:
+      if (!origin.empty()) origin+=" ";
+      origin+=iter;
+      break;
+    case 2:
+      if (!keyword.empty()) keyword+=" ";
+      keyword+=iter;
+      break;
+    default:
+      // if we have come here already for the first word, we don't
+      // expect origin and keyword any more
+      scanStatus=3;
+      if (!message.empty()) message+=" ";
+      message+=iter;
+    }
+  }
+  
+  // flush the string stream and send out through the logging system
+  switch (severity) {
+  case kDebug:
+    fgHLTLogging.Logging(kHLTLogDebug, origin.c_str(), keyword.c_str(), message.c_str());
+    break;
+  case kInformational:
+    fgHLTLogging.Logging(kHLTLogInfo, origin.c_str(), keyword.c_str(), message.c_str());
+    break;
+  case kWarning:
+    fgHLTLogging.Logging(kHLTLogWarning, origin.c_str(), keyword.c_str(), message.c_str());
+    break;
+  case kError:
+    fgHLTLogging.Logging(kHLTLogError, origin.c_str(), keyword.c_str(), message.c_str());
+    break;
+  case kFatal:
+  case kPrimary:
+    fgHLTLogging.Logging(kHLTLogFatal, origin.c_str(), keyword.c_str(), message.c_str());
+    break;
+  }
+  fgStream.clear();
+  string empty("");
+  fgStream.str(empty);
+  return "";
+}
 
-#endif
index fc18a41..3ae208e 100644 (file)
@@ -4,31 +4,72 @@
 #ifndef ALIHLTTPCLOG_H
 #define ALIHLTTPCLOG_H
 
-#ifndef __CINT__
-#include <ios>
-#endif
+#include <sstream>
+#include <iostream>
+#include "AliHLTLogging.h"
 
-class AliHLTTPCLog {
+using namespace std;
+
+/**
+ * @class AliHLTTPCLog
+ * This class implements the old HLT TPC logging mechanism.
+ * Logging messages are now forwarded to the HLT logging system
+ * \em Note: the old LOG and ENDLOG macros should be used any longer,
+ * use the HLT logging macros or AliRoot logging macros instead. 
+ * @see AliHLTLogging
+ */
+class AliHLTTPCLog  {
   public:
   enum TLogLevel { kNone = 0, kDebug= 0x01, kInformational = 0x02, kWarning = 0x04, kError = 0x08 , kFatal = 0x10, kPrimary = 0x80, kAll = 0x9F };
-  //enum TLogCmd { kEnd, kPrec, kHex=std::ios_base::hex, kDec=std::ios_base::dec };
-  static const char* kEnd;
-  static const char* kPrec;
-  static const char* kHex;
-  static const char* kDec;
-/*   static const std::ios_base::fmtflags kHex; */
-/*   static const std::ios_base::fmtflags kDec; */
-  static TLogLevel fgLevel;
+
+  /** not used */
+  static const char* kEnd;                                         //! transient
+  /** not used */
+  static const char* kPrec;                                        //! transient
+  /** stream manipulator for hex output, but empty in the implementation */
+  static const char* kHex;                                         //! transient
+  /** stream manipulator for decimal output, but empty in the implementation */
+  static const char* kDec;                                         //! transient
+
+  /** the logging filter */
+  static TLogLevel fgLevel;                                        // see above
+
+  /** key to indicate the origin part */
+  static const char* fgKeyOrigin;                                  //! transient
+  /** key to indicate the keyword part */
+  static const char* fgKeyKeyword;                                 //! transient
+  /** key to indicate the message part */
+  static const char* fgKeyMessage;                                 //! transient
+
+  /** a stringstream to receive the output */
+  static stringstream fgStream;                                    // see above
+  /** HLT logging instance */
+  static AliHLTLogging fgHLTLogging;                               // see above
+
+  /**
+   * Flush the stringstream and print output to the HLT logging system.
+   * The attributes are set before the message is streamed into the
+   * stringstream.<br>
+   * The LOG macro sets the attributes from the macro arguments and provides
+   * the stringstream.<br>
+   * The ENDLOG macro calls the Flush method after the message was streamed
+   * into the stringstream.
+   */
+  static const char* Flush();
 };
 
-#if __GNUC__ >= 3
-#define LOG( lvl, origin, keyword ) \
- if (lvl>=AliHLTTPCLog::fgLevel) std::cerr<<"["<<origin<<": "<<keyword<<"] "
-#define ENDLOG std::endl
-#else
-#error old gcc!
+/** LOG macro to be used by the TPC code 
+ * \em Note: this macro should be used any longer 
+ */
 #define LOG( lvl, origin, keyword ) \
- if (lvl>=AliHLTTPCLog::fgLevel) cerr<<"["<<origin<<": "<<keyword<<"] "
-#define ENDLOG endl
-#endif /* __GNUC__ */
+ if (lvl>=AliHLTTPCLog::fgLevel) AliHLTTPCLog::fgStream << lvl \
+                           << " " << AliHLTTPCLog::fgKeyOrigin  << " " << origin \
+                           << " " << AliHLTTPCLog::fgKeyKeyword << " " << keyword \
+                          << " " << AliHLTTPCLog::fgKeyMessage << " "
+
+/** ENDLOG macro calls the Flush method 
+ * \em Note: this macro should be used any longer 
+ */
+#define ENDLOG AliHLTTPCLog::Flush()
+
 #endif /* ALIHLTTPCLOG_H */
index b06dded..ad305bf 100644 (file)
@@ -4,22 +4,10 @@
 #ifndef ALIHLTTPCLOGGING_H
 #define ALIHLTTPCLOGGING_H
 
+// this is an old remnant, but we keep the file in order to keep the
+// HLT TPC code as it is
 #include "AliHLTTPCRootTypes.h"
 #include "AliHLTStdIncludes.h"
-
-#ifdef use_logging
-#include <MLUCLog.hpp>
-#include <MLUCLogServer.hpp>
-
-typedef MLUCLog AliHLTTPCLog;
-typedef MLUCLogServer AliHLTTPCLogServer;
-typedef MLUCDevNullLogServer AliHLTTPCDevNullLogServer;
-typedef MLUCStdoutLogServer AliHLTTPCStdoutLogServer;
-typedef MLUCStderrLogServer AliHLTTPCStderrLogServer;
-typedef MLUCStreamLogServer AliHLTTPCStreamLogServer;
-
-#else
-
 #include "AliHLTTPCLog.h"
-#endif /* use_logging */ 
+
 #endif /* ALIHLTTPCLOGGING_H */
index 6f91908..ef92151 100644 (file)
@@ -2138,10 +2138,4 @@ void AliHLTTPCTransform::PrintCompileOptions()
   cout << "NOT including any support for TPC Hough transformations." << endl;
 #endif // INCLUDE_TPC_HOUGH
 
-#ifdef use_logging
-  cout << "Using logging classes (MLUC): -Duse_logging was given." << endl;
-#else
-  cout << "NOT using logging classes (MLUC): -Duse_logging not was given." << endl;
-#endif
-
 }
index 9d0f0a2..5e4507c 100644 (file)
@@ -25,122 +25,28 @@ endif
 # library definition
 lib_LTLIBRARIES                        =  libAliHLTTPC.la
 
+# version info for the library
+LIBRARY_VERSION                        = '3:0:0'
+
+# MODDIR is set by the AliRoot build system and denotes the topdir
+# of the module, we must set it since the package definition libAliHLTTPC.pkg
+# includes another common configuration file
+MODDIR                         = $(top_srcdir)
+PKGDEF                         = $(MODDIR)/libHLTbase.pkg
+include $(top_srcdir)/libAliHLTTPC.pkg
+
 # library sources
-libAliHLTTPC_la_SOURCES                = AliHLTTPCLog.cxx \
-                                 AliHLTTPCTransform.cxx \
-                                 AliHLTTPCMemHandler.cxx \
-                                 AliHLTTPCDataCompressorHelper.cxx \
-                                 AliHLTTPCFitter.cxx \
-                                 AliHLTTPCFileHandler.cxx \
-                                 AliHLTTPCBenchmark.cxx \
-                                 AliHLTTPCDDLDataFileHandler.cxx \
-                                 AliHLTTPCClusterFinder.cxx \
-                                 AliHLTTPCDigitReader.cxx \
-                                 AliHLTTPCDigitReaderPacked.cxx \
-                                 AliHLTTPCDigitReaderUnpacked.cxx \
-                                 AliHLTTPCDigitReaderRaw.cxx \
-                                 AliHLTTPCVertex.cxx \
-                                 AliHLTTPCVertexArray.cxx \
-                                 AliHLTTPCVertexFinder.cxx \
-                                 AliHLTTPCTrackArray.cxx \
-                                 AliHLTTPCTrack.cxx \
-                                 AliHLTTPCConfMapFit.cxx \
-                                 AliHLTTPCConfMapTrack.cxx \
-                                 AliHLTTPCConfMapPoint.cxx \
-                                 AliHLTTPCConfMapper.cxx \
-                                 AliHLTTPCModelTrack.cxx \
-                                 AliHLTTPCMerger.cxx \
-                                 AliHLTTPCTrackMerger.cxx \
-                                 AliHLTTPCGlobalMerger.cxx \
-                                 AliHLTTPCInterMerger.cxx \
-                                 AliHLTTPCCATracker.cxx \
-                                 AliHLTTPCPad.cxx \
-                                 AliHLTTPCDefinitions.cxx \
-                                 AliHLTTPCRawDataUnpackerComponent.cxx \
-                                 AliHLTTPCClusterFinderComponent.cxx \
-                                 AliHLTTPCVertexFinderComponent.cxx \
-                                 AliHLTTPCSliceTrackerComponent.cxx \
-                                 AliHLTTPCGlobalMergerComponent.cxx \
-                                 AliHLTTPCCATrackerComponent.cxx \
-                                 AliHLTTPCEsdWriterComponent.cxx
-
-
-#                                AliHLTTPCClustFinderNew.cxx \
-#                                AliHLTTPC.cxx \
-#                                AliHLTTPCDisplay.cxx \
-#                                AliRawReaderMemory.cxx
-
-
-#                                AliHLTTPCHoughTrack.cxx \
-#                                AliHLTTPCHistogram.cxx \
-#                                AliHLTTPCHistogramAdaptive.cxx \
-#                                AliHLTTPCHoughBaseTransformer.cxx \
-#                                AliHLTTPCHoughTransformerRow.cxx
-
-
-# class header files, the link definition for the root dictionary
-# will be created from the names of the header files
-CLASS_HDRS                     = AliHLTTPCLog.h \
-                                 AliHLTTPCTransform.h \
-                                 AliHLTTPCMemHandler.h \
-                                 AliHLTTPCDataCompressorHelper.h \
-                                 AliHLTTPCFitter.h \
-                                 AliHLTTPCFileHandler.h \
-                                 AliHLTTPCBenchmark.h \
-                                 AliHLTTPCDDLDataFileHandler.h \
-                                 AliHLTTPCClusterFinder.h \
-                                 AliHLTTPCDigitReader.h \
-                                 AliHLTTPCDigitReaderPacked.h \
-                                 AliHLTTPCDigitReaderUnpacked.h \
-                                 AliHLTTPCDigitReaderRaw.h \
-                                 AliHLTTPCVertex.h \
-                                 AliHLTTPCVertexArray.h \
-                                 AliHLTTPCVertexFinder.h \
-                                 AliHLTTPCTrackArray.h \
-                                 AliHLTTPCTrack.h \
-                                 AliHLTTPCConfMapFit.h \
-                                 AliHLTTPCConfMapTrack.h \
-                                 AliHLTTPCConfMapPoint.h \
-                                 AliHLTTPCConfMapper.h \
-                                 AliHLTTPCModelTrack.h \
-                                 AliHLTTPCMerger.h \
-                                 AliHLTTPCTrackMerger.h \
-                                 AliHLTTPCGlobalMerger.h \
-                                 AliHLTTPCInterMerger.h \
-                                 AliHLTTPCCATracker.h \
-                                 AliHLTTPCPad.h \
-                                 AliHLTTPCSpacePointData.h \
-                                 AliHLTTPCDefinitions.h \
-                                 AliHLTTPCRawDataUnpackerComponent.h \
-                                 AliHLTTPCClusterFinderComponent.h \
-                                 AliHLTTPCVertexFinderComponent.h \
-                                 AliHLTTPCSliceTrackerComponent.h \
-                                 AliHLTTPCGlobalMergerComponent.h \
-                                 AliHLTTPCCATrackerComponent.h \
-                                 AliHLTTPCEsdWriterComponent.h
-
-#                                AliHLTTPCClustFinderNew.h \
-#                                AliHLTTPC.h
-
-
-pkginclude_HEADERS             = $(CLASS_HDRS) \
-                                 AliHLTTPCLogging.h \
-                                 AliHLTTPCRootTypes.h \
-                                 AliHLTTPCDigitData.h \
-                                 AliHLTTPCTrackSegmentData.h \
-                                 AliHLTTPCVertexData.h \
-                                 AliHLTTPCTrackletDataFormat.h \
-                                 AliHLTTPCRawDataFormat.h \
-                                 AliHLTTPCClusterDataFormat.h \
-                                 AliHLTTPCModels.h
+libAliHLTTPC_la_SOURCES                = $(MODULE_SRCS)
 
+# library headers
+pkginclude_HEADERS             = $(MODULE_HDRS)
 
-# version info for the library
+# linker flags
 libAliHLTTPC_la_LDFLAGS                = -L@ROOTLIBDIR@ \
                                  @ROOTLIBS@ \
                                  @ALIROOT_LDFLAGS@ \
                                  @ALIROOT_LIBS@ \
-                                 -version-info 3:0:0
+                                 -version-info  $(LIBRARY_VERSION)
 
 # set the file name for the generated root dictionary
 DICTCPP                                =  AliHLTTPC-DICT.cxx
index 5b935e9..dcdad67 100644 (file)
@@ -474,16 +474,17 @@ AM_CONDITIONAL(EN_HLT_TRD, test x$enable_trd = xyes)
 AC_MSG_RESULT([$enable_trd])
 
 dnl ------------------------------------------------------------------
-AC_MSG_CHECKING([whether to enable HLT logging])
-AH_TEMPLATE([NOLOGGING],[disable hlt logging])
-AC_ARG_ENABLE(logging,
-  [AC_HELP_STRING([--enable-logging],
-      [enable logging])],
-  [],[enable_logging=yes])
-if test "x$enable_logging" != "xyes" ; then 
-  AC_DEFINE(NOLOGGING)
+AC_MSG_CHECKING([whether to disable AliRoot logging])
+AH_TEMPLATE([NOALIROOT_LOGGING],[disable AliRoot logging])
+AC_ARG_ENABLE(aliroot-logging,
+  [AC_HELP_STRING([--disable-aliroot-logging],
+      [disable logging through AliRoot logging methods])],
+  [],[enable_aliroot_logging=no])
+if test "x$enable_aliroot_logging" != "xno" ; then 
+  AC_DEFINE(NOALIROOT_LOGGING)
 fi
-AC_MSG_RESULT([$enable_logging])
+AM_CONDITIONAL(NOALIROOT_LOGGING, test x$enable_aliroot_logging != no)
+AC_MSG_RESULT([$enable_aliroot_logging])
 
 dnl ------------------------------------------------------------------
 AC_MSG_CHECKING([whether to enable saving MC data through the chain])
index be66b2f..7233b93 100644 (file)
@@ -1,5 +1,5 @@
 #-*- Mode: Makefile -*-
-# $Id: 
+# $Id$
 
 # This files defines the source and header files for the
 # libAliHLTSample library and additional flags for the compilation
index dcc6118..ef51eda 100644 (file)
@@ -1,5 +1,5 @@
 #-*- Mode: Makefile -*-
-# $Id: 
+# $Id$
 
 include $(MODDIR)/hlt.conf
 
@@ -41,8 +41,7 @@ MODULE_SRCS=  AliHLTTPCLog.cxx \
                AliHLTTPCCATrackerComponent.cxx \
                AliHLTTPCEsdWriterComponent.cxx
 
-CLASS_HDRS:=   AliHLTTPCLog.h \
-               AliHLTTPCTransform.h \
+CLASS_HDRS:=   AliHLTTPCTransform.h \
                AliHLTTPCMemHandler.h \
                AliHLTTPCDataCompressorHelper.h \
                AliHLTTPCFitter.h \
@@ -81,6 +80,7 @@ CLASS_HDRS:=          AliHLTTPCLog.h \
                AliHLTTPCEsdWriterComponent.h
 
 MODULE_HDRS:=  $(CLASS_HDRS) \
+               AliHLTTPCLog.h \
                AliHLTTPCLogging.h \
                AliHLTTPCRootTypes.h \
                AliHLTTPCDigitData.h \
index 8ca03e9..85fd6c9 100644 (file)
@@ -1,5 +1,5 @@
 #-*- Mode: Makefile -*-
-# $Id: 
+# $Id$
 
 include $(MODDIR)/hlt.conf