using namespace std;
#endif
+#include "AliHLTStdIncludes.h"
#include "AliHLTComponent.h"
#include "AliHLTComponentHandler.h"
-#include <string>
#include "AliHLTSystem.h"
/** ROOT macro for the implementation of ROOT specific class methods */
ClassImp(AliHLTComponent)
AliHLTComponent::AliHLTComponent()
+ :
+ fCurrentEvent(0),
+ fEnvironment()
{
memset(&fEnvironment, 0, sizeof(AliHLTComponentEnvironment));
if (fpComponentHandler)
AliHLTComponentHandler* AliHLTComponent::fpComponentHandler=NULL;
+int AliHLTComponent::SetGlobalComponentHandler(AliHLTComponentHandler* pCH, int bOverwrite)
+{
+ int iResult=0;
+ if (fpComponentHandler==NULL || bOverwrite!=0)
+ fpComponentHandler=pCH;
+ else
+ iResult=-EPERM;
+ return iResult;
+}
+
+int AliHLTComponent::UnsetGlobalComponentHandler() {
+ return SetGlobalComponentHandler(NULL,1);
+}
+
int AliHLTComponent::Init( AliHLTComponentEnvironment* environ, void* environ_param, int argc, const char** argv )
{
int iResult=0;
strncat( output, type.fID, 8 );
}
+void* AliHLTComponent::AllocMemory( unsigned long size ) {
+ if (fEnvironment.fAllocMemoryFunc)
+ return (*fEnvironment.fAllocMemoryFunc)(fEnvironment.fParam, size );
+ return NULL;
+}
+
int AliHLTComponent::MakeOutputDataBlockList( const vector<AliHLTComponent_BlockData>& blocks, AliHLTUInt32_t* blockCount,
AliHLTComponent_BlockData** outputBlocks ) {
if ( !blockCount || !outputBlocks )
}
+int AliHLTComponent::GetEventDoneData( unsigned long size, AliHLTComponent_EventDoneData** edd ) {
+ if (fEnvironment.fGetEventDoneDataFunc)
+ return (*fEnvironment.fGetEventDoneDataFunc)(fEnvironment.fParam, fCurrentEvent, size, edd );
+ return -ENOSYS;
+}
+
int AliHLTComponent::FindMatchingDataTypes(AliHLTComponent* pConsumer, vector<AliHLTComponent_DataType>* tgtList)
{
int iResult=0;
* @defgroup alihlt_component Component handling of the HLT module
* This section describes the the component handling for the HLT module.
*/
-#include <cerrno>
#include "AliHLTLogging.h"
#include "AliHLTDataTypes.h"
#include "AliHLTDefinitions.h"
* Set the global component handler.
* The static method is needed for the automatic registration of components.
*/
- static int SetGlobalComponentHandler(AliHLTComponentHandler* pCH, int bOverwrite=0) {
- int iResult=0;
- if (fpComponentHandler==NULL || bOverwrite!=0)
- fpComponentHandler=pCH;
- else
- iResult=-EPERM;
- return iResult;
- }
+ static int SetGlobalComponentHandler(AliHLTComponentHandler* pCH, int bOverwrite=0);
/**
* Clear the global component handler.
* The static method is needed for the automatic registration of components.
*/
- static int UnsetGlobalComponentHandler() {
- return SetGlobalComponentHandler(NULL,1);
- }
+ static int UnsetGlobalComponentHandler();
protected:
* framework. Function pointers are transferred via the @ref
* AliHLTComponentEnvironment structure.
*/
- void* AllocMemory( unsigned long size ) {
- if (fEnvironment.fAllocMemoryFunc)
- return (*fEnvironment.fAllocMemoryFunc)(fEnvironment.fParam, size );
- return NULL;
- }
+ void* AllocMemory( unsigned long size );
/**
* Helper function to create a monolithic BlockData description block out
*/
int MakeOutputDataBlockList( const vector<AliHLTComponent_BlockData>& blocks, AliHLTUInt32_t* blockCount,
AliHLTComponent_BlockData** outputBlocks );
-/* { */
-/* if (fEnvironment.fMakeOutputDataBlockListFunc) */
-/* return (*fEnvironment.fMakeOutputDataBlockListFunc)(fEnvironment.fParam, blocks, blockCount, outputBlocks ); */
-/* return -ENOSYS; */
-/* } */
/**
* Fill the EventDoneData structure.
* framework. Function pointers are transferred via the @ref
* AliHLTComponentEnvironment structure.
*/
- int GetEventDoneData( unsigned long size, AliHLTComponent_EventDoneData** edd ) {
- if (fEnvironment.fGetEventDoneDataFunc)
- return (*fEnvironment.fGetEventDoneDataFunc)(fEnvironment.fParam, fCurrentEvent, size, edd );
- return -ENOSYS;
- }
-
+ int GetEventDoneData( unsigned long size, AliHLTComponent_EventDoneData** edd );
/**
* Helper function to convert the data type to a string.
using namespace std;
#endif
-#include <cerrno>
-#include <string>
#include <dlfcn.h>
-#include "AliL3StandardIncludes.h"
+#include "AliHLTStdIncludes.h"
#include "AliHLTComponentHandler.h"
#include "AliHLTComponent.h"
#include "AliHLTDataTypes.h"
ClassImp(AliHLTComponentHandler)
AliHLTComponentHandler::AliHLTComponentHandler()
+ :
+ fComponentList(),
+ fScheduleList(),
+ fLibraryList(),
+ fEnvironment()
{
+ memset(&fEnvironment, 0, sizeof(AliHLTComponentEnvironment));
}
-
AliHLTComponentHandler::~AliHLTComponentHandler()
{
UnloadLibraries();
ClassImp(AliHLTConfiguration)
AliHLTConfiguration::AliHLTConfiguration()
+ :
+ fID(NULL),
+ fComponent(NULL),
+ fStringSources(NULL),
+ fNofSources(-1),
+ fArguments(NULL),
+ fArgc(-1),
+ fArgv(NULL),
+ fListSources(),
+ fListSrcElement()
{
- fID=NULL;
- fComponent=NULL;
- fStringSources=NULL;
- fNofSources=-1;
- fArguments=NULL;
- fArgc=-1;
- fArgv=NULL;
fListSrcElement=fListSources.begin();
}
AliHLTConfiguration::AliHLTConfiguration(const char* id, const char* component, const char* sources, const char* arguments)
+ :
+ fID(id),
+ fComponent(component),
+ fStringSources(sources),
+ fNofSources(-1),
+ fArguments(arguments),
+ fArgc(-1),
+ fArgv(NULL),
+ fListSources(),
+ fListSrcElement()
{
- fArgc=-1;
- fArgv=NULL;
-
+ fListSrcElement=fListSources.begin();
if (id && component) {
- fID=id;
- fComponent=component;
- fStringSources=sources;
- fNofSources=-1;
- fArguments=arguments;
- fListSrcElement=fListSources.begin();
if (fConfigurationHandler) {
fConfigurationHandler->RegisterConfiguration(this);
} else {
}
}
+AliHLTConfiguration::AliHLTConfiguration(const AliHLTConfiguration&)
+ :
+ fID(NULL),
+ fComponent(NULL),
+ fStringSources(NULL),
+ fNofSources(-1),
+ fArguments(NULL),
+ fArgc(-1),
+ fArgv(NULL),
+ fListSources(),
+ fListSrcElement()
+{
+ fListSrcElement=fListSources.begin();
+ HLTFatal("copy constructor untested");
+}
+
+AliHLTConfiguration& AliHLTConfiguration::operator=(const AliHLTConfiguration&)
+{
+ HLTFatal("assignment operator untested");
+ return *this;
+}
+
AliHLTConfiguration::~AliHLTConfiguration()
{
if (fConfigurationHandler) {
ClassImp(AliHLTTask)
AliHLTTask::AliHLTTask()
+ :
+ fpConfiguration(NULL),
+ fpComponent(NULL),
+ fpBlockDataArray(NULL),
+ fBlockDataArraySize(0),
+ fpDataBuffer(NULL),
+ fListTargets(),
+ fListDependencies()
{
- fpConfiguration=NULL;
- fpComponent=NULL;
- fpBlockDataArray=NULL;
- fBlockDataArraySize=0;
- fpDataBuffer=NULL;
}
AliHLTTask::AliHLTTask(AliHLTConfiguration* fConf, AliHLTComponentHandler* pCH)
+ :
+ fpConfiguration(NULL),
+ fpComponent(NULL),
+ fpBlockDataArray(NULL),
+ fBlockDataArraySize(0),
+ fpDataBuffer(NULL),
+ fListTargets(),
+ fListDependencies()
{
- fpConfiguration=NULL;
- fpComponent=NULL;
- fpBlockDataArray=NULL;
- fBlockDataArraySize=0;
- fpDataBuffer=NULL;
Init(fConf, pCH);
}
+AliHLTTask::AliHLTTask(const AliHLTTask&)
+ :
+ fpConfiguration(NULL),
+ fpComponent(NULL),
+ fpBlockDataArray(NULL),
+ fBlockDataArraySize(0),
+ fpDataBuffer(NULL),
+ fListTargets(),
+ fListDependencies()
+{
+ HLTFatal("copy constructor untested");
+}
+
+AliHLTTask& AliHLTTask::operator=(const AliHLTTask&)
+{
+ HLTFatal("assignment operator untested");
+ return *this;
+}
+
AliHLTTask::~AliHLTTask()
{
if (fpComponent) delete fpComponent;
*/
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 */
/** destructor */
virtual ~AliHLTConfiguration();
#include "AliHLTSystem.h"
AliHLTConsumerDescriptor::AliHLTConsumerDescriptor()
+ :
+ fpConsumer(NULL),
+ fSegments()
{
- fpConsumer=NULL;
fSegments.clear();
}
AliHLTConsumerDescriptor::AliHLTConsumerDescriptor(AliHLTComponent* pConsumer)
+ :
+ fpConsumer(pConsumer),
+ fSegments()
{
- fpConsumer=pConsumer;
fSegments.clear();
}
+AliHLTConsumerDescriptor::AliHLTConsumerDescriptor(const AliHLTConsumerDescriptor& desc)
+ :
+ fpConsumer(desc.fpConsumer),
+ fSegments()
+{
+ // we can simply transfer the pointer to th new object since there are no
+ // release actions in the destructor
+}
+
+AliHLTConsumerDescriptor& AliHLTConsumerDescriptor::operator=(const AliHLTConsumerDescriptor& desc)
+{
+ // we can simply transfer the pointer to th new object since there are no
+ // release actions in the destructor
+ fpConsumer=desc.fpConsumer;
+ return *this;
+}
+
AliHLTConsumerDescriptor::~AliHLTConsumerDescriptor()
{
if (fSegments.size()>0) {
ClassImp(AliHLTDataBuffer)
AliHLTDataBuffer::AliHLTDataBuffer()
+ :
+ fSegments(),
+ fConsumers(),
+ fActiveConsumers(),
+ fReleasedConsumers(),
+ fpBuffer(NULL),
+ fFlags(0)
{
- // TODO: do the right initialization
- //fSegments.empty();
- //fConsumers.empty;
- //fActiveConsumers.empty;
- //fReleasedConsumers.empty;
- fpBuffer=NULL;
- fFlags=0;
+ fSegments.empty();
+ fConsumers.empty();
+ fActiveConsumers.empty();
+ fReleasedConsumers.empty();
fNofInstances++;
}
+AliHLTDataBuffer::AliHLTDataBuffer(const AliHLTDataBuffer&)
+ :
+ fSegments(),
+ fConsumers(),
+ fActiveConsumers(),
+ fReleasedConsumers(),
+ fpBuffer(NULL),
+ fFlags(0)
+{
+ HLTFatal("copy constructor untested");
+}
+
+AliHLTDataBuffer& AliHLTDataBuffer::operator=(const AliHLTDataBuffer&)
+{
+ HLTFatal("assignment operator untested");
+ return *this;
+}
+
int AliHLTDataBuffer::fNofInstances=0;
vector<AliHLTRawBuffer*> AliHLTDataBuffer::fFreeBuffers;
vector<AliHLTRawBuffer*> AliHLTDataBuffer::fActiveBuffers;
*/
struct AliHLTDataSegment {
AliHLTDataSegment()
+ :
+ fDataType(),
+ fSegmentOffset(0),
+ fSegmentSize(0),
+ fSpecification(0)
{
- //fDataType=0;
- fSegmentOffset=0;
- fSegmentSize=0;
- fSpecification=0;
+ memset(&fDataType, 0, sizeof(AliHLTComponent_DataType));
}
AliHLTDataSegment(AliHLTUInt32_t offset, AliHLTUInt32_t size)
+ :
+ fDataType(),
+ fSegmentOffset(offset),
+ fSegmentSize(size),
+ fSpecification(0)
{
- //fDataType=0;
- fSegmentOffset=offset;
- fSegmentSize=size;
- fSpecification=0;
+ memset(&fDataType, 0, sizeof(AliHLTComponent_DataType));
}
/** the data type of this segment */
AliHLTComponent_DataType fDataType;
* @param pConsumer pointer to the consumer component
*/
AliHLTConsumerDescriptor(AliHLTComponent* pConsumer);
+ /** not a valid copy constructor, defined according to effective C++ style */
+ AliHLTConsumerDescriptor(const AliHLTConsumerDescriptor&);
+ /** not a valid assignment op, but defined according to effective C++ style */
+ AliHLTConsumerDescriptor& operator=(const AliHLTConsumerDescriptor&);
+ /** destructor */
~AliHLTConsumerDescriptor();
/**
/* standard constructor
*/
AliHLTDataBuffer();
-
+ /** not a valid copy constructor, defined according to effective C++ style */
+ AliHLTDataBuffer(const AliHLTDataBuffer&);
+ /** not a valid assignment op, but defined according to effective C++ style */
+ AliHLTDataBuffer& operator=(const AliHLTDataBuffer&);
+ /** destructor */
virtual ~AliHLTDataBuffer();
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
using namespace std;
#endif
-#include <cerrno>
-#include "AliL3StandardIncludes.h"
+#include "AliHLTStdIncludes.h"
#include "AliHLTLogging.h"
-#include <cstdarg>
-#include <string>
/** ROOT macro for the implementation of ROOT specific class methods */
ClassImp(AliHLTLogging)
AliHLTLogging::AliHLTLogging()
+ :
+ fpDefaultKeyword(NULL),
+ fpCurrentKeyword(NULL),
+ //fLocalLogFilter(kHLTLogDefault),
+ fLocalLogFilter(kHLTLogAll)
{
- fpDefaultKeyword=NULL;
- fpCurrentKeyword=NULL;
- //fLocalLogFilter=kHLTLogDefault;
- fLocalLogFilter=kHLTLogAll;
+}
+
+AliHLTLogging::AliHLTLogging(const AliHLTLogging&)
+ :
+ fpDefaultKeyword(NULL),
+ fpCurrentKeyword(NULL),
+ fLocalLogFilter(kHLTLogAll)
+{
+ HLTFatal("copy constructor untested");
+}
+
+AliHLTLogging& AliHLTLogging::operator=(const AliHLTLogging&)
+{
+ HLTFatal("assignment operator untested");
+ return *this;
}
char AliHLTLogging::fLogBuffer[LOG_BUFFER_SIZE]="";
return iResult;
}
-int AliHLTLogging::LoggingVarargs( AliHLTComponent_LogSeverity severity, const char* origin_class, const char* origin_func, ... )
+int AliHLTLogging::LoggingVarargs( AliHLTComponent_LogSeverity severity, const char* origin_class, const char* origin_func, ... ) const
{
int iResult=CheckFilter(severity);
if (iResult>0) {
return iResult;
}
-int AliHLTLogging::CheckFilter(AliHLTComponent_LogSeverity severity)
+int AliHLTLogging::CheckFilter(AliHLTComponent_LogSeverity severity) const
{
int iResult=severity==kHLTLogNone || (severity&fGlobalLogFilter)>0 && (severity&fLocalLogFilter)>0;
return iResult;
class AliHLTLogging {
public:
AliHLTLogging();
+ AliHLTLogging(const AliHLTLogging&);
+ AliHLTLogging& operator=(const AliHLTLogging&);
virtual ~AliHLTLogging();
// logging filter for all objects
// get the current keyword
//
- const char* GetKeyword()
+ const char* GetKeyword() const
{
if (fpCurrentKeyword) return fpCurrentKeyword;
else if (fpDefaultKeyword) return fpDefaultKeyword;
// logging function with two origin parameters, used by the log macros
//
- int LoggingVarargs( AliHLTComponent_LogSeverity severity, const char* origin_class, const char* origin_func, ... );
+ int LoggingVarargs( AliHLTComponent_LogSeverity severity, const char* origin_class, const char* origin_func, ... ) const;
// apply filter, return 1 if message should pass
//
- int CheckFilter(AliHLTComponent_LogSeverity severity);
+ int CheckFilter(AliHLTComponent_LogSeverity severity) const;
static int Message(void * param, AliHLTComponent_LogSeverity severity, const char* origin, const char* keyword, const char* message);
class AliHLTKeyword {
public:
AliHLTKeyword()
+ :
+ fpParent(NULL),
+ fpOriginal(NULL)
{
- fpParent=NULL;
- fpOriginal=NULL;
}
AliHLTKeyword(AliHLTLogging* parent, const char* keyword)
+ :
+ fpParent(parent),
+ fpOriginal(NULL)
{
- fpOriginal=NULL;
if (parent) {
- fpParent=parent;
fpOriginal=fpParent->SetKeyword(keyword);
}
}
+ AliHLTKeyword(const AliHLTKeyword& kw)
+ :
+ fpParent(kw.fpParent),
+ fpOriginal(kw.fpOriginal)
+ {
+ }
+
+ AliHLTKeyword& operator=(const AliHLTKeyword& kw)
+ {
+ fpParent=kw.fpParent;
+ fpOriginal=kw.fpOriginal;
+ return *this;
+ }
+
~AliHLTKeyword()
{
if (fpParent) {
--- /dev/null
+// @(#) $Id$
+// Original file : src/AliL3StandardIncludes.h,v 1.5
+
+#ifndef ALIHLTSTDINCLUDESH
+#define ALIHLTSTDINCLUDESH
+
+#if __GNUC__ >= 3
+#include <fstream>
+#include <iostream>
+
+#include <cstdio>
+#include <cmath>
+#include <cstring>
+#include <ctime>
+#include <cstdlib>
+#include <cerrno>
+#include <cstdarg>
+
+/* Use these only if absolutely necessary
+eg. in inline functions defined in header files */
+#define STDCOUT std::cout
+#define STDCERR std::cerr
+#define STDENDL std::endl
+#define STDIF std::ifstream
+#define STDOF std::ofstream
+
+#else
+#include <iostream.h>
+#include <fstream.h>
+
+#include <stdio.h>
+#include <math.h>
+#include <string.h>
+#include <time.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <stdarg.h>
+
+/* Use these only if absolutely necessary
+eg. in inline functions defined in header files */
+#define STDCOUT cout
+#define STDCERR cerr
+#define STDENDL endl
+#define STDIF ifstream
+#define STDOF ofstream
+
+#endif //__GNUC__
+
+#endif
using namespace std;
#endif
-#include <cerrno>
-#include <string>
-#include "AliL3StandardIncludes.h"
+#include "AliHLTStdIncludes.h"
#include "AliHLTSystem.h"
#include "AliHLTComponentHandler.h"
#include "AliHLTComponent.h"
ClassImp(AliHLTSystem)
AliHLTSystem::AliHLTSystem()
+ :
+ fpComponentHandler(new AliHLTComponentHandler()),
+ fpConfigurationHandler(new AliHLTConfigurationHandler()),
+ fTaskList()
{
- fpComponentHandler=new AliHLTComponentHandler();
if (fpComponentHandler) {
AliHLTComponentEnvironment env;
memset(&env, 0, sizeof(AliHLTComponentEnvironment));
} else {
HLTFatal("can not create Component Handler");
}
- fpConfigurationHandler=new AliHLTConfigurationHandler();
if (fpConfigurationHandler) {
AliHLTConfiguration::GlobalInit(fpConfigurationHandler);
} else {
}
}
+AliHLTSystem::AliHLTSystem(const AliHLTSystem&)
+ :
+ fpComponentHandler(NULL),
+ fpConfigurationHandler(NULL),
+ fTaskList()
+{
+ HLTFatal("copy constructor untested");
+}
+
+AliHLTSystem& AliHLTSystem::operator=(const AliHLTSystem&)
+{
+ HLTFatal("assignment operator untested");
+ return *this;
+}
AliHLTSystem::~AliHLTSystem()
{
* This section describes the HLT integration into AliRoot.
*/
-#include "AliL3RootTypes.h"
#include "AliHLTLogging.h"
#include <TList.h>
public:
/** default constructor */
AliHLTSystem();
+ /** not a valid copy constructor, defined according to effective C++ style */
+ AliHLTSystem(const AliHLTSystem&);
+ /** not a valid assignment op, but defined according to effective C++ style */
+ AliHLTSystem& operator=(const AliHLTSystem&);
/** destructor */
virtual ~AliHLTSystem();
int StopEvent();
private:
- TList fConfList;
- int fbListChanged;
+/* TList fConfList; */
+/* int fbListChanged; */
TList fTaskList;
@param pCH the HLT component handler
*/
AliHLTTask(AliHLTConfiguration* pConf, AliHLTComponentHandler* pCH);
+ /** not a valid copy constructor, defined according to effective C++ style */
+ AliHLTTask(const AliHLTTask&);
+ /** not a valid assignment op, but defined according to effective C++ style */
+ AliHLTTask& operator=(const AliHLTTask&);
/** destructor */
virtual ~AliHLTTask();
MODULE = HLTbase
-AM_CPPFLAGS = -I$(top_srcdir)/src
+AM_CPPFLAGS =
# library definition
lib_LTLIBRARIES = libHLTbase.la
AliHLT_C_Component_WrapperInterface.h \
AliHLTDefinitions.h
+noinst_HEADERS = AliHLTStdIncludes.h
# version info for the library
libHLTbase_la_LDFLAGS = -version-info 1:0:0
+2006-08-21 intermediate
+ - made package indepentend of src
+ added BASE/AliHLTStdIncludes.h which should take the job of
+ including std headers
+ - removed eff C++ warnings in BASE
+ - TPCref library off by default
+ - added doc pictures to distribution
+ - TPCLib version interface no 2
+ - started to sort header includes in TPCLib
+
2006-08-17 Jochen's TPCLib source code from Jan 2006 (not a joke) merged
- bugfix in AliHLTTPCConfMapper (caused low tracking efficiency)
- Online Display development
SUBDIRS = BASE \
$(SAMPLE_DIR) \
$(TPC_DIR) \
- src \
doc
DIST_SUBDIRS = $(SUBDIRS)
using namespace std;
#endif
-#include "AliL3StandardIncludes.h"
#include "AliHLTSampleComponent1.h"
/**
using namespace std;
#endif
-#include "AliL3StandardIncludes.h"
#include "AliHLTSampleComponent2.h"
/**
MODULE = AliHLTSample
-AM_CPPFLAGS = -I$(top_srcdir)/src \
- -I$(top_srcdir)/BASE
+AM_CPPFLAGS = -I$(top_srcdir)/BASE
# library definition
// Author: Anders Vestbo <mailto:vestbo@fi.uib.no>, Uli Frankenfeld <mailto:franken@fi.uib.no>
//*-- Copyright © ALICE HLT Group
-#include "AliHLTTPCStandardIncludes.h"
-
#ifndef no_root
#include <TFile.h>
#include <TDirectory.h>
#include <TStopwatch.h>
#include <TMath.h>
#endif
-#include "AliHLTTPCStandardIncludes.h"
#include "AliHLTTPCRootTypes.h"
#include "AliHLTTPCLogging.h"
#include "AliHLTTPCBenchmark.h"
// Author: Anders Vestbo <mailto:vestbo@fi.uib.no>, Constantin Loizides <mailto:loizides@ikf.uni-frankfurt.de>
//*-- Copyright © ALICE HLT Group
-#include "AliHLTTPCStandardIncludes.h"
#include "AliHLTTPCRootTypes.h"
#include "AliHLTTPCLogging.h"
#include "AliHLTTPCClustFinderNew.h"
#include "AliHLTTPCDigitReader.h"
-#include "AliHLTTPCStandardIncludes.h"
#include "AliHLTTPCRootTypes.h"
#include "AliHLTTPCLogging.h"
#include "AliHLTTPCClusterFinder.h"
// Author: Anders Vestbo <mailto:vestbo@fi.uib.no>
//*-- Copyright © ALICE HLT Group
-#include "AliHLTTPCStandardIncludes.h"
#include "AliHLTTPCRootTypes.h"
#include "AliHLTTPCLogging.h"
#include "AliHLTTPCVertex.h"
// Author: Anders Vestbo <mailto:vestbo$fi.uib.no>
//*-- Copyright © ALICE HLT Group
-#include "AliHLTTPCStandardIncludes.h"
-
#include "AliHLTTPCLogging.h"
#include "AliHLTTPCConfMapPoint.h"
#include "AliHLTTPCSpacePointData.h"
// Author: Anders Vestbo <mailto:vestbo@fi.uib.no>, Uli Frankenfeld <mailto:franken@fi.uib.no>
//*-- Copyright © ALICE HLT Group
-#include "AliHLTTPCStandardIncludes.h"
-
#include "AliHLTTPCRootTypes.h"
#include "AliHLTTPCLogging.h"
#include "AliHLTTPCVertex.h"
#include <sys/time.h>
-#include "AliHLTTPCStandardIncludes.h"
#include "AliHLTTPCRootTypes.h"
#include "AliHLTTPCSpacePointData.h"
#include "AliHLTTPCLogging.h"
// Author: C. Loizides <loizides@ikf.uni-frankfurt.de>
//*-- Copyright © ALICE HLT Group
-#include "AliHLTTPCStandardIncludes.h"
-
#include "AliHLTTPCRootTypes.h"
#include "AliHLTTPCLogging.h"
#include "AliHLTTPCTransform.h"
// Author: Anders Vestbo <mailto:vestbo@fi.uib.no>
//*-- Copyright © ALICE HLT Group
-#include "AliHLTTPCStandardIncludes.h"
-
+#include "AliHLTStdIncludes.h"
#include "AliHLTTPCRootTypes.h"
#include "AliHLTTPCTransform.h"
#define TRACKPOLYMARKER 0
#define BACKWARD 0
-#include "AliHLTTPCStandardIncludes.h"
#include <TView.h>
#include <TPolyMarker3D.h>
#include <TPolyLine3D.h>
// Author: Uli Frankenfeld <mailto:franken@fi.uib.no>, Anders Vestbo <mailto:vestbo$fi.uib.no>, C. Loizides <mailto:loizides@ikf.uni-frankfurt.de>
//*-- Copyright © ALICE HLT Group
-#include "AliHLTTPCStandardIncludes.h"
#include <TClonesArray.h>
#include <TSystem.h>
#include <TMath.h>
*/
#include <math.h>
-#include "AliHLTTPCStandardIncludes.h"
#include "AliHLTTPCLogging.h"
#include "AliHLTTPCFitter.h"
#include "AliHLTTPCVertex.h"
// Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
//*-- Copyright © ALICE HLT Group
-#include "AliHLTTPCStandardIncludes.h"
-
#include "AliHLTTPCLogging.h"
#include "AliHLTTPCGlobalMerger.h"
#include "AliHLTTPCTrack.h"
// Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
//*-- Copyright © ALICE HLT Group
-#include "AliHLTTPCStandardIncludes.h"
-
#include "AliHLTTPCLogging.h"
#include "AliHLTTPCInterMerger.h"
#include "AliHLTTPCTrack.h"
#ifndef use_logging
-#include "AliHLTTPCStandardIncludes.h"
#include "AliHLTTPCLogging.h"
AliHLTTPCLog::TLogLevel AliHLTTPCLog::fgLevel=AliHLTTPCLog::kNone;
#define ALIHLTTPCLOGGING_H
#include "AliHLTTPCRootTypes.h"
-#include "AliHLTTPCStandardIncludes.h"
+#include "AliHLTStdIncludes.h"
#ifdef use_logging
#include <MLUCLog.hpp>
*/
#include "AliHLTTPCRootTypes.h"
-#include "AliHLTTPCStandardIncludes.h"
#include "AliHLTTPCDigitData.h"
#include "AliHLTTPCLogging.h"
#include "AliHLTTPCTransform.h"
// Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
//*-- Copyright © Uli
-#include "AliHLTTPCStandardIncludes.h"
-
#include "AliHLTTPCLogging.h"
#include "AliHLTTPCMerger.h"
#include "AliHLTTPCTrack.h"
//
-#include "AliHLTTPCStandardIncludes.h"
-
#include "AliHLTTPCLogging.h"
#include "AliHLTTPCTransform.h"
#include "AliHLTTPCVertex.h"
// Author: Anders Vestbo <mailto:vestbo$fi.uib.no>, Uli Frankenfeld <mailto:franken@fi.uib.no>
//*-- Copyright © ALICE HLT Group
-#include "AliHLTTPCStandardIncludes.h"
-#include "AliHLTTPCRootTypes.h"
-#include "AliHLTTPCRootTypes.h"
#include "AliHLTTPCLogging.h"
#include "AliHLTTPCTrack.h"
#include "AliHLTTPCTransform.h"
// Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
//*-- Copyright © ALICE HLT Group
-#include "AliHLTTPCStandardIncludes.h"
-
#include "AliHLTTPCLogging.h"
#include "AliHLTTPCTrackArray.h"
#ifdef INCLUDE_TPC_HOUGH
</pre
*/
-#include "AliHLTTPCStandardIncludes.h"
-
#include "AliHLTTPCLogging.h"
#include "AliHLTTPCTrackMerger.h"
#include "AliHLTTPCTrack.h"
//*-- Copyright © ALICE HLT Group
-#include "AliHLTTPCStandardIncludes.h"
#include "dirent.h"
#ifdef use_aliroot
// Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
//*-- Copyright © ALICE HLT Group
-#include "AliHLTTPCStandardIncludes.h"
-#include "AliHLTTPCRootTypes.h"
#include "AliHLTTPCLogging.h"
#include "AliHLTTPCVertexData.h"
#include "AliHLTTPCVertex.h"
// Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
//*-- Copyright © ALICE HLT Group
-#include "AliHLTTPCStandardIncludes.h"
-
#include "AliHLTTPCLogging.h"
#include "AliHLTTPCVertexArray.h"
// Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
//*-- Copyright © ALICE HLT Group
-#include "AliHLTTPCStandardIncludes.h"
-#include "AliHLTTPCRootTypes.h"
#include "AliHLTTPCSpacePointData.h"
#include "AliHLTTPCVertexData.h"
#include "AliHLTTPCLogging.h"
MODULE = AliHLTTPC
-AM_CPPFLAGS = -I$(top_srcdir)/src \
- -I$(top_srcdir)/BASE \
+AM_CPPFLAGS = -I$(top_srcdir)/BASE \
-I$(ALICE_ROOT)/include \
-I$(ALICE_ROOT)/TPC \
-I$(ALICE_ROOT)/CONTAINERS \
# version info for the library
-libAliHLTTPC_la_LDFLAGS = -version-info 1:0:0
+libAliHLTTPC_la_LDFLAGS = -version-info 2:0:0
# set the file name for the generated root dictionary
DICTCPP = AliHLTTPC-DICT.cxx
include $(top_srcdir)/make.dict
-SUBDIRS = . Ref
+if EN_HLT_TPCREF
+REFDIR = Ref
+endif
+SUBDIRS = . $(REFDIR)
#ALIHLT_USEPACKAGE=STANDALONE
AC_DEFINE(use_aliroot)
AC_DEFINE(use_root)
-CPPFLAGS="$CPPFLAGS -DROOTVERSION=`${ROOTCONF} --version`"
-CPPFLAGS="$CPPFLAGS -DALIROOTVERSION=0"
-CPPFLAGS="$CPPFLAGS -I${ROOTINCDIR}"
+CPPFLAGS="$CPPFLAGS -DROOTVERSION=\\\"`${ROOTCONF} --version`\\\""
+CPPFLAGS="$CPPFLAGS -DALIROOTVERSION=\\\"Unknown\\\""
+CPPFLAGS="$CPPFLAGS ${ROOTCFLAGS}"
+LDFLAGS="$LDFLAGS -L${ROOTLIBDIR} ${ROOTLIBS}"
+
+dnl ------------------------------------------------------------------
+dnl check for AliRoot
+dnl AC_LANG_PUSH(C++)
+dnl AC_MSG_CHECKING([for AliRoot])
+dnl have_aliroot=no
+dnl ALIROOTLIBDIR=${ALICE_ROOT}/lib/tgt_${ALICE_TARGET}
+dnl ALIROOTINCDIR=${ALICE_ROOT}/include
+dnl if test "x$ALICE_ROOT" != "x" \
+dnl && test -d ${ALIROOTLIBDIR} \
+dnl && test -d ${ALIROOTINCDIR}; then
+dnl have_aliroot=yes
+dnl else
+dnl ALIROOTLIBDIR=
+dnl ALIROOTINCDIR=
+dnl fi
+dnl AC_MSG_RESULT([$have_aliroot])
+
+dnl if test ! "x$have_aliroot" = "x" ; then
+dnl CPPFLAGS="$CPPFLAGS -I${ALIROOTINCDIR}"
+dnl LDFLAGS="$LDFLAGS -L${ALIROOTLIBDIR} -lESD -lGeom -lMinuit -lVMC -lEG -lRAWData -ldl"
+dnl have_alisteer=no
+dnl AC_CHECK_LIB(STEER, [AliRun], [have_alisteer=yes])
+dnl fi
+dnl AC_LANG_POP(C++)
+
+
+dnl ------------------------------------------------------------------
+AC_MSG_CHECKING([whether to impose strict coding conventions])
+AC_ARG_ENABLE(strict,
+ [AC_HELP_STRING([--enable-strict],
+ [enable coding convention checks ])],
+ [],[enable_strict=no])
+if test "x$enable_strict" = "xyes" ; then
+ CPPFLAGS="$CPPFLAGS -Weffc++"
+fi
+AC_MSG_RESULT([$enable_strict])
dnl ------------------------------------------------------------------
AC_MSG_CHECKING([whether to compile sample library])
AM_CONDITIONAL(EN_HLT_TPC, test x$enable_tpc = xyes)
AC_MSG_RESULT([$enable_tpc])
+dnl ------------------------------------------------------------------
+if test "x$enable_tpc" = "xyes" ; then
+ AC_MSG_CHECKING([whether to compile tpc reference library])
+ AH_TEMPLATE([HLT_TPCREF],[hlt tpc reference library])
+ AC_ARG_ENABLE(tpcref,
+ [AC_HELP_STRING([--enable-tpcref],
+ [compile the tpc reference library ])],
+ [],[enable_tpcref=no])
+ if test "x$enable_tpcref" = "xyes" ; then
+ AC_DEFINE(HLT_TPCREF)
+ fi
+ AM_CONDITIONAL(EN_HLT_TPCREF, test x$enable_tpcref = xyes)
+ AC_MSG_RESULT([$enable_tpcref])
+fi
+
dnl ------------------------------------------------------------------
AC_MSG_CHECKING([whether to enable HLT logging])
AH_TEMPLATE([NOLOGGING],[disable hlt logging])
fi
AC_MSG_RESULT([$enable_mc_saving])
-dnl ------------------------------------------------------------------
-# TODO: get AliRoot version during configure
-#Switch on ALIROOT version detection by cvs command
-#ifeq ($(ALIHLT_ALIDETECT),true)
-#USECVS = 1
-#endif
-
dnl ------------------------------------------------------------------
AC_MSG_CHECKING([whether to enable AliRoot NEWIO])
AH_TEMPLATE([use_newio],[AliRoot NEWIO])
SampleLib/Makefile
TPCLib/Makefile
TPCLib/Ref/Makefile
- src/Makefile
doc/Makefile
doc/doxygen.conf])
#
#***********************************************************************/
-EXTRA_DIST = mainpage.c
+EXTRA_DIST = mainpage.c \
+ pics/HLT-AliRoot-Integration_overview.png \
+ pics/HLT-AliRoot-Integration_overview.eps \
+ pics/HLT-AliRoot-Integration_overview.png \
+ pics/HLT-AliRoot-Integration_overview.eps \
+ pics/PubSub_WrapperComponent.png
DISTCLEANFILES = doxy.log $(PACKAGE).tags
if HAVE_DOXYGEN
html/index.html $(PACKAGE).tags: doxygen.conf Makefile mainpage.c
$(DOXYGEN) $<
-# for i in `find @srcdir@/pics -name '*.png'`; do cp -f $$i html/pic_`basename $$i`; done
tar-ball:$(HTML)
if test -f html/index.html ; then \
#endif //__GNUC__
#endif
-
+++ /dev/null
-# $Id$
-# Makefile template for the old TPC HLT code
-#
-# The purpose of this file is to include header files to the
-# package
-
-pkginclude_HEADERS = AliL3RootTypes.h \
- AliL3StandardIncludes.h
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff