* AliHLTConfigurationHandler. The agent can adapt the configurations
* to be registered to the current AliRoot setup by checking the
* runloader.
- * @param handler[in] the configuration handler
- * @param runloader[in] AliRoot runloader
+ * @param handler [in] the configuration handler
+ * @param runloader [in] AliRoot runloader
* @return neg. error code if failed
*/
virtual int CreateConfigurations(AliHLTConfigurationHandler* handler,
* described by the last configuration(s) in the chain.
* The agent can adapt the configurations to be registered to the current
* AliRoot setup by checking the runloader.
- * @param runloader[in] AliRoot runloader
+ * @param runloader [in] AliRoot runloader
* @return string containing the top configurations separated by blanks
*/
virtual const char* GetTopConfigurations(AliRunLoader* runloader=NULL) const;
* AliHLTConfigurationHandler. The agent can adapt the configurations
* to be registered to the current AliRoot setup by checking the
* runloader.
+ * @param handler the configuration handler
* @param runloader AliRoot runloader
* @return neg. error code if failed
*/
if (argc==0 && argv==NULL) {
// this is just to get rid of the warning "unused parameter"
}
- int iResult=-EPROTO;
+ int iResult=-EINVAL;
return iResult;
}
* AliHLTConfigurationHandler. The agent can adapt the configurations
* to be registered to the current AliRoot setup by checking the
* runloader.
+ * @param handler the configuration handler
* @param runloader AliRoot runloader
* @return neg. error code if failed
*/
#include "AliHLTTPCTrackSegmentData.h"
#include "AliHLTTPCTrackArray.h"
#include "AliHLTTPCTrackletDataFormat.h"
+#include "AliHLTTPCDefinitions.h"
//#include "AliHLTTPC.h"
#include <stdlib.h>
#include <iostream>
ClassImp(AliHLTTPCCATrackerComponent)
AliHLTTPCCATrackerComponent::AliHLTTPCCATrackerComponent()
- {
- fTracker = NULL;
- fVertex = NULL;
- }
+ :
+ fTracker(NULL),
+ fVertex(NULL)
+{
+ // see header file for class documentation
+ // or
+ // refer to README to build package
+ // or
+ // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
+}
+
+AliHLTTPCCATrackerComponent::AliHLTTPCCATrackerComponent(const AliHLTTPCCATrackerComponent&)
+ :
+ fTracker(NULL),
+ fVertex(NULL)
+{
+ // see header file for class documentation
+ HLTFatal("copy constructor untested");
+}
+
+AliHLTTPCCATrackerComponent& AliHLTTPCCATrackerComponent::operator=(const AliHLTTPCCATrackerComponent&)
+{
+ // see header file for class documentation
+ HLTFatal("assignment operator untested");
+ return *this;
+}
AliHLTTPCCATrackerComponent::~AliHLTTPCCATrackerComponent()
{
+ // see header file for class documentation
}
// Public functions to implement AliHLTComponent's interface.
const char* AliHLTTPCCATrackerComponent::GetComponentID()
{
+ // see header file for class documentation
return "TPCCATracker";
}
-void AliHLTTPCCATrackerComponent::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
+void AliHLTTPCCATrackerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
{
+ // see header file for class documentation
list.clear();
- list.push_back( AliHLTTPCDefinitions::gkClustersDataType );
- list.push_back( AliHLTTPCDefinitions::gkVertexDataType );
+ list.push_back( AliHLTTPCDefinitions::fgkClustersDataType );
+ list.push_back( AliHLTTPCDefinitions::fgkVertexDataType );
}
-AliHLTComponent_DataType AliHLTTPCCATrackerComponent::GetOutputDataType()
+AliHLTComponentDataType AliHLTTPCCATrackerComponent::GetOutputDataType()
{
- return AliHLTTPCDefinitions::gkTrackSegmentsDataType;
+ // see header file for class documentation
+ return AliHLTTPCDefinitions::fgkTrackSegmentsDataType;
}
void AliHLTTPCCATrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
{
+ // see header file for class documentation
// XXX TODO: Find more realistic values.
constBase = 0;
inputMultiplier = 0.2;
AliHLTComponent* AliHLTTPCCATrackerComponent::Spawn()
{
+ // see header file for class documentation
return new AliHLTTPCCATrackerComponent;
}
int AliHLTTPCCATrackerComponent::DoInit( int argc, const char** argv )
{
+ // see header file for class documentation
Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "DoInit", "DoInit()" );
if ( fTracker || fVertex )
int AliHLTTPCCATrackerComponent::DoDeinit()
{
+ // see header file for class documentation
if ( fTracker )
delete fTracker;
fTracker = NULL;
return 0;
}
-int AliHLTTPCCATrackerComponent::DoEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks,
- AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr,
- AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks )
+int AliHLTTPCCATrackerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
+ AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr,
+ AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
{
+ // see header file for class documentation
Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "DoEvent", "DoEvent()" );
if ( evtData.fBlockCnt<=0 )
{
return 0;
}
- const AliHLTComponent_BlockData* iter = NULL;
+ const AliHLTComponentBlockData* iter = NULL;
unsigned long ndx;
AliHLTTPCClusterData* inPtrSP;
AliHLTTPCVertexData* inPtrV = NULL;
- const AliHLTComponent_BlockData* vertexIter=NULL;
+ const AliHLTComponentBlockData* vertexIter=NULL;
AliHLTTPCTrackletData* outPtr;
AliHLTUInt8_t* outBPtr;
else
*slCntIter++;
- if ( iter->fDataType == AliHLTTPCDefinitions::gkVertexDataType )
+ if ( iter->fDataType == AliHLTTPCDefinitions::fgkVertexDataType )
{
inPtrV = (AliHLTTPCVertexData*)(iter->fPtr);
vertexIter = iter;
fVertex->Read( inPtrV );
vertexSlice = slice;
}
- if ( iter->fDataType == AliHLTTPCDefinitions::gkClustersDataType )
+ if ( iter->fDataType == AliHLTTPCDefinitions::fgkClustersDataType )
{
patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
if ( minPatch>patch )
for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
{
iter = blocks+ndx;
- if ( iter->fDataType == AliHLTTPCDefinitions::gkVertexDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
+ if ( iter->fDataType == AliHLTTPCDefinitions::fgkVertexDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
{
inPtrV = (AliHLTTPCVertexData*)(iter->fPtr);
vertexIter = iter;
{
iter = blocks+ndx;
- if ( iter->fDataType == AliHLTTPCDefinitions::gkClustersDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
+ if ( iter->fDataType == AliHLTTPCDefinitions::fgkClustersDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
{
patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
pIter = patchIndices.begin();
tSize += mysize+sizeof(AliHLTTPCTrackletData);
outBPtr += mysize+sizeof(AliHLTTPCTrackletData);
- AliHLTComponent_BlockData bd;
+ AliHLTComponentBlockData bd;
FillBlockData( bd );
bd.fOffset = offset;
bd.fSize = tSize;
*/
#include "AliHLTProcessor.h"
-#include "AliHLTTPCDefinitions.h"
class AliHLTTPCCATracker;
class AliHLTTPCVertex;
+/**
+ * @class AliHLTTPCCATrackerComponent
+ * The Cellular Automaton tracker component.
+ */
class AliHLTTPCCATrackerComponent : public AliHLTProcessor
{
public:
+ /** standard constructor */
AliHLTTPCCATrackerComponent();
+ /** not a valid copy constructor, defined according to effective C++ style */
+ AliHLTTPCCATrackerComponent(const AliHLTTPCCATrackerComponent&);
+ /** not a valid assignment op, but defined according to effective C++ style */
+ AliHLTTPCCATrackerComponent& operator=(const AliHLTTPCCATrackerComponent&);
+ /** standard destructor */
virtual ~AliHLTTPCCATrackerComponent();
// Public functions to implement AliHLTComponent's interface.
// These functions are required for the registration process
+ /** @see component interface @ref AliHLTComponent::GetComponentID */
const char* GetComponentID();
- void GetInputDataTypes( vector<AliHLTComponent_DataType>& list);
- AliHLTComponent_DataType GetOutputDataType();
+
+ /** @see component interface @ref AliHLTComponent::GetInputDataTypes */
+ void GetInputDataTypes( vector<AliHLTComponentDataType>& list);
+
+ /** @see component interface @ref AliHLTComponent::GetOutputDataType */
+ AliHLTComponentDataType GetOutputDataType();
+
+ /** @see component interface @ref AliHLTComponent::GetOutputDataSize */
virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
+
+ /** @see component interface @ref AliHLTComponent::Spawn */
AliHLTComponent* Spawn();
-
+
protected:
// Protected functions to implement AliHLTComponent's interface.
// These functions provide initialization as well as the actual processing
// capabilities of the component.
+ /** @see component interface @ref AliHLTComponent::DoInit */
int DoInit( int argc, const char** argv );
+
+ /** @see component interface @ref AliHLTComponent::DoDeinit */
int DoDeinit();
- int DoEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks,
- AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr,
- AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks );
+
+ /** @see component interface @ref AliHLTProcessor::DoEvent */
+ int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
+ AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr,
+ AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks );
private:
- AliHLTTPCCATracker* fTracker;
- AliHLTTPCVertex* fVertex;
+ /** the tracker object */
+ AliHLTTPCCATracker* fTracker; //! transient
+ /** the virtexer object */
+ AliHLTTPCVertex* fVertex; //! transient
- Double_t fBField;
+ /** magnetic field */
+ Double_t fBField; // see above
ClassDef(AliHLTTPCCATrackerComponent, 0)
* provided "as is" without express or implied warranty. *
**************************************************************************/
-/** @file AliHLTTPCSliceTrackerComponent.cxx
+/** @file AliHLTTPCClusterFinderComponent.cxx
@author Timm Steinbeck, Matthias Richter, Jochen Thaeder
@date
@brief The TPC cluster finder processing component
{
// see header file for class documentation
list.clear();
- if (fPackedSwitch) list.push_back( AliHLTTPCDefinitions::gkDDLPackedRawDataType );
- else list.push_back( AliHLTTPCDefinitions::gkUnpackedRawDataType );
+ if (fPackedSwitch) list.push_back( AliHLTTPCDefinitions::fgkDDLPackedRawDataType );
+ else list.push_back( AliHLTTPCDefinitions::fgkUnpackedRawDataType );
}
AliHLTComponentDataType AliHLTTPCClusterFinderComponent::GetOutputDataType()
{
// see header file for class documentation
- return AliHLTTPCDefinitions::gkClustersDataType;
+ return AliHLTTPCDefinitions::fgkClustersDataType;
}
void AliHLTTPCClusterFinderComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
if (fPackedSwitch) {
char tmp1[14], tmp2[14];
DataType2Text( iter->fDataType, tmp1 );
- DataType2Text( AliHLTTPCDefinitions::gkDDLPackedRawDataType, tmp2 );
+ DataType2Text( AliHLTTPCDefinitions::fgkDDLPackedRawDataType, tmp2 );
Logging( kHLTLogDebug, "HLT::TPCClusterFinder::DoEvent", "Event received",
"Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
evtData.fEventID, evtData.fEventID, tmp1, tmp2 );
- if ( iter->fDataType != AliHLTTPCDefinitions::gkDDLPackedRawDataType ) continue;
+ if ( iter->fDataType != AliHLTTPCDefinitions::fgkDDLPackedRawDataType ) continue;
}
else {
char tmp1[14], tmp2[14];
DataType2Text( iter->fDataType, tmp1 );
- DataType2Text( AliHLTTPCDefinitions::gkUnpackedRawDataType, tmp2 );
+ DataType2Text( AliHLTTPCDefinitions::fgkUnpackedRawDataType, tmp2 );
Logging( kHLTLogDebug, "HLT::TPCClusterFinder::DoEvent", "Event received",
"Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
evtData.fEventID, evtData.fEventID, tmp1, tmp2 );
- if ( iter->fDataType != AliHLTTPCDefinitions::gkUnpackedRawDataType ) continue;
+ if ( iter->fDataType != AliHLTTPCDefinitions::fgkUnpackedRawDataType ) continue;
}
#include "AliHLTTPCDefinitions.h"
+/** ROOT macro for the implementation of ROOT specific class methods */
ClassImp(AliHLTTPCDefinitions)
-const AliHLTComponentDataType AliHLTTPCDefinitions::gkDDLPackedRawDataType = { sizeof(AliHLTComponentDataType), {'D','D','L','_','R','W','P','K'},{'T','P','C',' '}};;
-const AliHLTComponentDataType AliHLTTPCDefinitions::gkPackedRawDataType = { sizeof(AliHLTComponentDataType), {'R','A','W','P','A','K','E','D'},{'T','P','C',' '}};;
-const AliHLTComponentDataType AliHLTTPCDefinitions::gkUnpackedRawDataType = { sizeof(AliHLTComponentDataType), {'R','A','W','U','N','P','A','K'},{'T','P','C',' '}};;
-const AliHLTComponentDataType AliHLTTPCDefinitions::gkClustersDataType = { sizeof(AliHLTComponentDataType), {'C','L','U','S','T','E','R','S'},{'T','P','C',' '}};;
-const AliHLTComponentDataType AliHLTTPCDefinitions::gkVertexDataType = { sizeof(AliHLTComponentDataType), {'V','E','R','T','E','X',' ',' '},{'T','P','C',' '}};;
-const AliHLTComponentDataType AliHLTTPCDefinitions::gkTrackSegmentsDataType = { sizeof(AliHLTComponentDataType), {'T','R','A','K','S','E','G','S'},{'T','P','C',' '}};;
-const AliHLTComponentDataType AliHLTTPCDefinitions::gkTracksDataType = { sizeof(AliHLTComponentDataType), {'T','R','A','C','K','S',' ',' '},{'T','P','C',' '}};;
+const AliHLTComponentDataType AliHLTTPCDefinitions::fgkDDLPackedRawDataType = { sizeof(AliHLTComponentDataType), {'D','D','L','_','R','W','P','K'},{'T','P','C',' '}};;
+const AliHLTComponentDataType AliHLTTPCDefinitions::fgkPackedRawDataType = { sizeof(AliHLTComponentDataType), {'R','A','W','P','A','K','E','D'},{'T','P','C',' '}};;
+const AliHLTComponentDataType AliHLTTPCDefinitions::fgkUnpackedRawDataType = { sizeof(AliHLTComponentDataType), {'R','A','W','U','N','P','A','K'},{'T','P','C',' '}};;
+const AliHLTComponentDataType AliHLTTPCDefinitions::fgkClustersDataType = { sizeof(AliHLTComponentDataType), {'C','L','U','S','T','E','R','S'},{'T','P','C',' '}};;
+const AliHLTComponentDataType AliHLTTPCDefinitions::fgkVertexDataType = { sizeof(AliHLTComponentDataType), {'V','E','R','T','E','X',' ',' '},{'T','P','C',' '}};;
+const AliHLTComponentDataType AliHLTTPCDefinitions::fgkTrackSegmentsDataType = { sizeof(AliHLTComponentDataType), {'T','R','A','K','S','E','G','S'},{'T','P','C',' '}};;
+const AliHLTComponentDataType AliHLTTPCDefinitions::fgkTracksDataType = { sizeof(AliHLTComponentDataType), {'T','R','A','C','K','S',' ',' '},{'T','P','C',' '}};;
AliHLTTPCDefinitions::AliHLTTPCDefinitions()
{
+ // see header file for class documentation
+ // or
+ // refer to README to build package
+ // or
+ // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
}
AliHLTTPCDefinitions::~AliHLTTPCDefinitions()
{
+ // see header file for class documentation
}
*/
#include "AliHLTDataTypes.h"
-#include "TObject.h"
+#include "Rtypes.h"
class AliHLTTPCDefinitions
- {
- public:
+{
+public:
AliHLTTPCDefinitions();
virtual ~AliHLTTPCDefinitions();
return ((maxSliceNr & 0xFF) << 24) | ((minSliceNr & 0xFF) << 16) | ((maxPatchNr & 0xFF) << 8) | ((minPatchNr & 0xFF));
}
- static const AliHLTComponentDataType gkDDLPackedRawDataType;
- static const AliHLTComponentDataType gkPackedRawDataType;
- static const AliHLTComponentDataType gkUnpackedRawDataType;
- static const AliHLTComponentDataType gkClustersDataType;
- /** track segments in local coordinates */
- static const AliHLTComponentDataType gkTrackSegmentsDataType;
- /** tracks in global koordinates */
- static const AliHLTComponentDataType gkTracksDataType;
- static const AliHLTComponentDataType gkVertexDataType;
+ /** DDL packed RAW data */
+ static const AliHLTComponentDataType fgkDDLPackedRawDataType; // see above
+ /** packed RAW data */
+ static const AliHLTComponentDataType fgkPackedRawDataType; // see above
+ /** unpacked RAW data */
+ static const AliHLTComponentDataType fgkUnpackedRawDataType; // see above
+ /** cluster data */
+ static const AliHLTComponentDataType fgkClustersDataType; // see above
+ /** track segments in local coordinates */
+ static const AliHLTComponentDataType fgkTrackSegmentsDataType; // see above
+ /** tracks in global koordinates */
+ static const AliHLTComponentDataType fgkTracksDataType; // see above
+ /** vertex data structure */
+ static const AliHLTComponentDataType fgkVertexDataType; // see above
- ClassDef(AliHLTTPCDefinitions, 0)
+ ClassDef(AliHLTTPCDefinitions, 0);
- };
+};
#endif
for (int ndx=0; ndx<(int)evtData.fBlockCnt && iResult>=0; ndx++) {
iter = blocks+ndx;
- if ( (bIsTrackSegs=(iter->fDataType == AliHLTTPCDefinitions::gkTrackSegmentsDataType))==1 ||
- iter->fDataType == AliHLTTPCDefinitions::gkTracksDataType ) {
+ if ( (bIsTrackSegs=(iter->fDataType == AliHLTTPCDefinitions::fgkTrackSegmentsDataType))==1 ||
+ iter->fDataType == AliHLTTPCDefinitions::fgkTracksDataType ) {
Int_t minslice=AliHLTTPCDefinitions::GetMinSliceNr(iter->fSpecification);
Int_t maxslice=AliHLTTPCDefinitions::GetMaxSliceNr(iter->fSpecification);
if (bIsTrackSegs==0) {
* provided "as is" without express or implied warranty. *
**************************************************************************/
-/** @file AliHLTTPCGlobalMergerComponent.h
+/** @file AliHLTTPCGlobalMergerComponent.cxx
@author Timm Steinbeck, Matthias Richter
@date
@brief HLT TPC global merger component.
#include "AliHLTTPCTrackletDataFormat.h"
#include "AliHLTTPCSpacePointData.h"
#include "AliHLTTPCClusterDataFormat.h"
+#include "AliHLTTPCDefinitions.h"
#include <stdlib.h>
#include <errno.h>
ClassImp(AliHLTTPCGlobalMergerComponent)
AliHLTTPCGlobalMergerComponent::AliHLTTPCGlobalMergerComponent()
- {
- fGlobalMerger = NULL;
- fVertex = NULL;
- }
+ :
+ fGlobalMerger(NULL),
+ fVertex(NULL)
+{
+ // see header file for class documentation
+ // or
+ // refer to README to build package
+ // or
+ // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
+}
+
+AliHLTTPCGlobalMergerComponent::AliHLTTPCGlobalMergerComponent(const AliHLTTPCGlobalMergerComponent&)
+ :
+ fGlobalMerger(NULL),
+ fVertex(NULL)
+{
+ // see header file for class documentation
+ HLTFatal("copy constructor untested");
+}
+
+AliHLTTPCGlobalMergerComponent& AliHLTTPCGlobalMergerComponent::operator=(const AliHLTTPCGlobalMergerComponent&)
+{
+ // see header file for class documentation
+ HLTFatal("assignment operator untested");
+ return *this;
+}
AliHLTTPCGlobalMergerComponent::~AliHLTTPCGlobalMergerComponent()
- {
- }
+{
+ // see header file for class documentation
+}
// Public functions to implement AliHLTComponent's interface.
// These functions are required for the registration process
const char* AliHLTTPCGlobalMergerComponent::GetComponentID()
{
+ // see header file for class documentation
return "TPCGlobalMerger";
}
void AliHLTTPCGlobalMergerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
{
+ // see header file for class documentation
list.clear();
- list.push_back( AliHLTTPCDefinitions::gkTrackSegmentsDataType );
- list.push_back( AliHLTTPCDefinitions::gkVertexDataType );
+ list.push_back( AliHLTTPCDefinitions::fgkTrackSegmentsDataType );
+ list.push_back( AliHLTTPCDefinitions::fgkVertexDataType );
}
AliHLTComponentDataType AliHLTTPCGlobalMergerComponent::GetOutputDataType()
{
- return AliHLTTPCDefinitions::gkTracksDataType;
+ // see header file for class documentation
+ return AliHLTTPCDefinitions::fgkTracksDataType;
}
void AliHLTTPCGlobalMergerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
{
+ // see header file for class documentation
// XXX TODO: Find more realistic values.
constBase = 0;
inputMultiplier = 1.0;
AliHLTComponent* AliHLTTPCGlobalMergerComponent::Spawn()
{
+ // see header file for class documentation
return new AliHLTTPCGlobalMergerComponent;
}
void AliHLTTPCGlobalMergerComponent::SetMergerParameters(Double_t maxy,Double_t maxz,Double_t maxkappa,Double_t maxpsi,Double_t maxtgl)
{
+ // see header file for class documentation
fGlobalMerger->SetParameter( maxy, maxz, maxkappa, maxpsi, maxtgl );
}
int AliHLTTPCGlobalMergerComponent::DoInit( int argc, const char** argv )
{
+ // see header file for class documentation
if ( fGlobalMerger || fVertex )
return EINPROGRESS;
fGlobalMerger = new AliHLTTPCGlobalMerger();
int AliHLTTPCGlobalMergerComponent::DoDeinit()
{
+ // see header file for class documentation
if ( fGlobalMerger )
delete fGlobalMerger;
fGlobalMerger = NULL;
AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr,
AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
{
+ // see header file for class documentation
const AliHLTComponentBlockData* iter = NULL;
const AliHLTComponentBlockData* lastVertexBlock = NULL;
unsigned long ndx;
}
if ( sdIter->fSlice == slice )
{
- if ( iter->fDataType == AliHLTTPCDefinitions::gkTrackSegmentsDataType )
+ if ( iter->fDataType == AliHLTTPCDefinitions::fgkTrackSegmentsDataType )
{
if ( !sdIter->fTrackletBlock )
{
slice, evtData.fEventID, evtData.fEventID, sdIter->fTrackletBlockIndex, ndx );
}
}
- if ( iter->fDataType == AliHLTTPCDefinitions::gkVertexDataType )
+ if ( iter->fDataType == AliHLTTPCDefinitions::fgkVertexDataType )
{
lastVertexBlock = iter;
if ( !sdIter->fVertexBlock )
*/
#include "AliHLTProcessor.h"
-#include "AliHLTTPCDefinitions.h"
class AliHLTTPCGlobalMerger;
class AliHLTTPCVertex;
+/**
+ * @class AliHLTTPCGlobalMergerComponent
+ * The TPC global merger component
+ * The component is the interface to the AliHLTGlobalMerger processing
+ * class.
+ */
class AliHLTTPCGlobalMergerComponent : public AliHLTProcessor
{
public:
- AliHLTTPCGlobalMergerComponent();
- virtual ~AliHLTTPCGlobalMergerComponent();
+ /** standard constructor */
+ AliHLTTPCGlobalMergerComponent();
+ /** not a valid copy constructor, defined according to effective C++ style */
+ AliHLTTPCGlobalMergerComponent(const AliHLTTPCGlobalMergerComponent&);
+ /** not a valid assignment op, but defined according to effective C++ style */
+ AliHLTTPCGlobalMergerComponent& operator=(const AliHLTTPCGlobalMergerComponent&);
+ /** standard destructor */
+ virtual ~AliHLTTPCGlobalMergerComponent();
// Public functions to implement AliHLTComponent's interface.
// These functions are required for the registration process
+ /** @see component interface @ref AliHLTComponent::GetComponentID */
const char* GetComponentID();
+
+ /** @see component interface @ref AliHLTComponent::GetInputDataTypes */
void GetInputDataTypes( vector<AliHLTComponentDataType>& list);
+
+ /** @see component interface @ref AliHLTComponent::GetOutputDataType */
AliHLTComponentDataType GetOutputDataType();
+
+ /** @see component interface @ref AliHLTComponent::GetOutputDataSize */
virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
+
+ /** @see component interface @ref AliHLTComponent::Spawn */
AliHLTComponent* Spawn();
protected:
+ /**
+ * Set the parameters
+ */
void SetMergerParameters(Double_t maxy=2.0,Double_t maxz=3.0,Double_t maxkappa=0.003,
Double_t maxpsi=0.1,Double_t maxtgl=0.05);
// These functions provide initialization as well as the actual processing
// capabilities of the component.
+
+ /** @see component interface @ref AliHLTComponent::DoInit */
int DoInit( int argc, const char** argv );
+
+ /** @see component interface @ref AliHLTComponent::DoDeinit */
int DoDeinit();
+
+ /** @see component interface @ref AliHLTProcessor::DoEvent */
int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr,
AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks );
private:
+ /** the global merger object */
AliHLTTPCGlobalMerger* fGlobalMerger; //!
+ /** the vertexer object */
AliHLTTPCVertex* fVertex; //!
- struct SliceData
- {
- int fSlice;
- const AliHLTComponentBlockData* fVertexBlock;
- unsigned fVertexBlockIndex;
- const AliHLTComponentBlockData* fTrackletBlock;
- unsigned fTrackletBlockIndex;
- };
+ struct SliceData {
+ /** slice no */
+ int fSlice; // see above
+ /** block descriptor for the vertex data block */
+ const AliHLTComponentBlockData* fVertexBlock; //! transient
+ /** index of the vertex data block */
+ unsigned fVertexBlockIndex; // see above
+ /** block descriptor for the tracklet data block */
+ const AliHLTComponentBlockData* fTrackletBlock; //! transient
+ /** index of the tracklet data block */
+ unsigned fTrackletBlockIndex; // see above
+ };
ClassDef(AliHLTTPCGlobalMergerComponent, 0)
void AliHLTTPCRawDataUnpackerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
{
list.clear();
- list.push_back( AliHLTTPCDefinitions::gkDDLPackedRawDataType );
+ list.push_back( AliHLTTPCDefinitions::fgkDDLPackedRawDataType );
}
AliHLTComponentDataType AliHLTTPCRawDataUnpackerComponent::GetOutputDataType()
{
- return AliHLTTPCDefinitions::gkUnpackedRawDataType;
+ return AliHLTTPCDefinitions::fgkUnpackedRawDataType;
}
void AliHLTTPCRawDataUnpackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
iter = blocks+ndx;
char tmp1[14], tmp2[14];
DataType2Text( iter->fDataType, tmp1 );
- DataType2Text( AliHLTTPCDefinitions::gkDDLPackedRawDataType, tmp2 );
+ DataType2Text( AliHLTTPCDefinitions::fgkDDLPackedRawDataType, tmp2 );
Logging( kHLTLogDebug, "HLT::TPCRawDataUnpackerSubscriber::DoEvent", "Event received",
"Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
evtData.fEventID, evtData.fEventID, tmp1, tmp2 );
- if ( iter->fDataType != AliHLTTPCDefinitions::gkDDLPackedRawDataType )
+ if ( iter->fDataType != AliHLTTPCDefinitions::fgkDDLPackedRawDataType )
{
continue;
}
void AliHLTTPCSliceTrackerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
{
list.clear();
- list.push_back( AliHLTTPCDefinitions::gkClustersDataType );
- list.push_back( AliHLTTPCDefinitions::gkVertexDataType );
+ list.push_back( AliHLTTPCDefinitions::fgkClustersDataType );
+ list.push_back( AliHLTTPCDefinitions::fgkVertexDataType );
}
AliHLTComponentDataType AliHLTTPCSliceTrackerComponent::GetOutputDataType()
{
- return AliHLTTPCDefinitions::gkTrackSegmentsDataType;
+ return AliHLTTPCDefinitions::fgkTrackSegmentsDataType;
}
void AliHLTTPCSliceTrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
else
*slCntIter++;
- if ( iter->fDataType == AliHLTTPCDefinitions::gkVertexDataType )
+ if ( iter->fDataType == AliHLTTPCDefinitions::fgkVertexDataType )
{
inPtrV = (AliHLTTPCVertexData*)(iter->fPtr);
vertexIter = iter;
fVertex->Read( inPtrV );
vertexSlice = slice;
}
- if ( iter->fDataType == AliHLTTPCDefinitions::gkClustersDataType )
+ if ( iter->fDataType == AliHLTTPCDefinitions::fgkClustersDataType )
{
patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
if ( minPatch>patch )
for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
{
iter = blocks+ndx;
- if ( iter->fDataType == AliHLTTPCDefinitions::gkVertexDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
+ if ( iter->fDataType == AliHLTTPCDefinitions::fgkVertexDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
{
inPtrV = (AliHLTTPCVertexData*)(iter->fPtr);
vertexIter = iter;
{
iter = blocks+ndx;
- if ( iter->fDataType == AliHLTTPCDefinitions::gkClustersDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
+ if ( iter->fDataType == AliHLTTPCDefinitions::fgkClustersDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
{
patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
pIter = patchIndices.begin();
void AliHLTTPCVertexFinderComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
{
list.clear();
- list.push_back( AliHLTTPCDefinitions::gkClustersDataType );
+ list.push_back( AliHLTTPCDefinitions::fgkClustersDataType );
}
AliHLTComponentDataType AliHLTTPCVertexFinderComponent::GetOutputDataType()
{
- return AliHLTTPCDefinitions::gkVertexDataType;
+ return AliHLTTPCDefinitions::fgkVertexDataType;
}
void AliHLTTPCVertexFinderComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
iter = blocks+ndx;
mysize = 0;
offset = tSize;
- if ( iter->fDataType != AliHLTTPCDefinitions::gkClustersDataType )
+ if ( iter->fDataType != AliHLTTPCDefinitions::fgkClustersDataType )
{
continue;
}