coding conventions and documentation
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 2 Apr 2007 23:24:07 +0000 (23:24 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 2 Apr 2007 23:24:07 +0000 (23:24 +0000)
15 files changed:
HLT/BASE/AliHLTModuleAgent.h
HLT/BASE/util/AliHLTAgentUtil.h
HLT/BASE/util/AliHLTRootFileWriterComponent.cxx
HLT/SampleLib/AliHLTAgentSample.h
HLT/TPCLib/AliHLTTPCCATrackerComponent.cxx
HLT/TPCLib/AliHLTTPCCATrackerComponent.h
HLT/TPCLib/AliHLTTPCClusterFinderComponent.cxx
HLT/TPCLib/AliHLTTPCDefinitions.cxx
HLT/TPCLib/AliHLTTPCDefinitions.h
HLT/TPCLib/AliHLTTPCEsdWriterComponent.cxx
HLT/TPCLib/AliHLTTPCGlobalMergerComponent.cxx
HLT/TPCLib/AliHLTTPCGlobalMergerComponent.h
HLT/TPCLib/AliHLTTPCRawDataUnpackerComponent.cxx
HLT/TPCLib/AliHLTTPCSliceTrackerComponent.cxx
HLT/TPCLib/AliHLTTPCVertexFinderComponent.cxx

index 4e08e5f..d12fff3 100644 (file)
@@ -68,8 +68,8 @@ class AliHLTModuleAgent : public TObject, public AliHLTLogging {
    * 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,
@@ -81,7 +81,7 @@ class AliHLTModuleAgent : public TObject, public AliHLTLogging {
    * 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;
index cc98a21..f5159b4 100644 (file)
@@ -34,6 +34,7 @@ class AliHLTAgentUtil : public AliHLTModuleAgent {
    * 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
    */
index 87146df..e102ff7 100644 (file)
@@ -86,7 +86,7 @@ int AliHLTRootFileWriterComponent::ScanArgument(int argc, const char** argv)
   if (argc==0 && argv==NULL) {
     // this is just to get rid of the warning "unused parameter"
   }
-  int iResult=-EPROTO;
+  int iResult=-EINVAL;
   return iResult;
 }
 
index bc4a3d3..cb5ffab 100644 (file)
@@ -34,6 +34,7 @@ class AliHLTAgentSample : public AliHLTModuleAgent {
    * 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
    */
index 88e107c..02dd46d 100644 (file)
@@ -39,6 +39,7 @@ using namespace std;
 #include "AliHLTTPCTrackSegmentData.h"
 #include "AliHLTTPCTrackArray.h"
 #include "AliHLTTPCTrackletDataFormat.h"
+#include "AliHLTTPCDefinitions.h"
 //#include "AliHLTTPC.h"
 #include <stdlib.h>
 #include <iostream>
@@ -53,13 +54,36 @@ AliHLTTPCCATrackerComponent gAliHLTTPCCATrackerComponent;
 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.
@@ -67,23 +91,27 @@ AliHLTTPCCATrackerComponent::~AliHLTTPCCATrackerComponent()
 
 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;
@@ -91,11 +119,13 @@ void AliHLTTPCCATrackerComponent::GetOutputDataSize( unsigned long& constBase, d
 
 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 )
@@ -142,6 +172,7 @@ int AliHLTTPCCATrackerComponent::DoInit( int argc, const char** argv )
 
 int AliHLTTPCCATrackerComponent::DoDeinit()
     {
+  // see header file for class documentation
     if ( fTracker )
        delete fTracker;
     fTracker = NULL;
@@ -151,10 +182,11 @@ int AliHLTTPCCATrackerComponent::DoDeinit()
     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 )
       {
@@ -162,11 +194,11 @@ int AliHLTTPCCATrackerComponent::DoEvent( const AliHLTComponent_EventData& evtDa
        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;
 
@@ -223,7 +255,7 @@ int AliHLTTPCCATrackerComponent::DoEvent( const AliHLTComponent_EventData& evtDa
        else
            *slCntIter++;
 
-       if ( iter->fDataType == AliHLTTPCDefinitions::gkVertexDataType )
+       if ( iter->fDataType == AliHLTTPCDefinitions::fgkVertexDataType )
            {
            inPtrV = (AliHLTTPCVertexData*)(iter->fPtr);
            vertexIter = iter;
@@ -231,7 +263,7 @@ int AliHLTTPCCATrackerComponent::DoEvent( const AliHLTComponent_EventData& evtDa
            fVertex->Read( inPtrV );
            vertexSlice = slice;
            }
-       if ( iter->fDataType == AliHLTTPCDefinitions::gkClustersDataType )
+       if ( iter->fDataType == AliHLTTPCDefinitions::fgkClustersDataType )
            {
            patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
            if ( minPatch>patch )
@@ -288,7 +320,7 @@ int AliHLTTPCCATrackerComponent::DoEvent( const AliHLTComponent_EventData& evtDa
        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;
@@ -310,7 +342,7 @@ int AliHLTTPCCATrackerComponent::DoEvent( const AliHLTComponent_EventData& evtDa
        {
        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();
@@ -369,7 +401,7 @@ int AliHLTTPCCATrackerComponent::DoEvent( const AliHLTComponent_EventData& evtDa
     tSize += mysize+sizeof(AliHLTTPCTrackletData);
     outBPtr += mysize+sizeof(AliHLTTPCTrackletData);
     
-    AliHLTComponent_BlockData bd;
+    AliHLTComponentBlockData bd;
     FillBlockData( bd );
     bd.fOffset = offset;
     bd.fSize = tSize;
index bb3ca1b..171b104 100644 (file)
@@ -9,44 +9,70 @@
  */
 
 #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)
 
index 137ff46..0047280 100644 (file)
@@ -17,7 +17,7 @@
  * 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
@@ -103,15 +103,15 @@ void AliHLTTPCClusterFinderComponent::GetInputDataTypes( vector<AliHLTComponentD
     {
   // 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 )
@@ -321,23 +321,23 @@ int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponentEventData& ev
        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;
 
        }
        
index d8f21d9..2cdbb15 100644 (file)
 #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
 }
 
     
index 2c2bc2d..3d4e9a4 100644 (file)
  */
 
 #include "AliHLTDataTypes.h"
-#include "TObject.h"
+#include "Rtypes.h"
 
 class AliHLTTPCDefinitions
-    {
-    public:
+{
+public:
       AliHLTTPCDefinitions();
       virtual ~AliHLTTPCDefinitions();
 
@@ -59,18 +59,23 @@ class 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
index 413c4d1..e04e7a3 100644 (file)
@@ -106,8 +106,8 @@ int AliHLTTPCEsdWriterComponent::DumpEvent( const AliHLTComponentEventData& evtD
  
       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) {
index 47f9263..a7e4212 100644 (file)
@@ -16,7 +16,7 @@
  * 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.
@@ -36,6 +36,7 @@ using namespace std;
 #include "AliHLTTPCTrackletDataFormat.h"
 #include "AliHLTTPCSpacePointData.h"
 #include "AliHLTTPCClusterDataFormat.h"
+#include "AliHLTTPCDefinitions.h"
 #include <stdlib.h>
 #include <errno.h>
 
@@ -45,37 +46,64 @@ AliHLTTPCGlobalMergerComponent gAliHLTTPCGlobalMergerComponent;
 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;
@@ -83,16 +111,19 @@ void AliHLTTPCGlobalMergerComponent::GetOutputDataSize( unsigned long& constBase
 
 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();
@@ -103,6 +134,7 @@ int AliHLTTPCGlobalMergerComponent::DoInit( int argc, const char** argv )
 
 int AliHLTTPCGlobalMergerComponent::DoDeinit()
     {
+  // see header file for class documentation
     if ( fGlobalMerger )
        delete fGlobalMerger;
     fGlobalMerger = NULL;
@@ -116,6 +148,7 @@ int AliHLTTPCGlobalMergerComponent::DoEvent( const AliHLTComponentEventData& evt
                                              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;
@@ -160,7 +193,7 @@ int AliHLTTPCGlobalMergerComponent::DoEvent( const AliHLTComponentEventData& evt
            }
        if ( sdIter->fSlice == slice )
            {
-           if ( iter->fDataType == AliHLTTPCDefinitions::gkTrackSegmentsDataType )
+           if ( iter->fDataType == AliHLTTPCDefinitions::fgkTrackSegmentsDataType )
                {
                if ( !sdIter->fTrackletBlock )
                    {
@@ -174,7 +207,7 @@ int AliHLTTPCGlobalMergerComponent::DoEvent( const AliHLTComponentEventData& evt
                             slice, evtData.fEventID, evtData.fEventID, sdIter->fTrackletBlockIndex, ndx );
                    }
                }
-           if ( iter->fDataType == AliHLTTPCDefinitions::gkVertexDataType )
+           if ( iter->fDataType == AliHLTTPCDefinitions::fgkVertexDataType )
                {
                lastVertexBlock = iter;
                if ( !sdIter->fVertexBlock )
index a21a9df..0a09d0b 100644 (file)
 */
 
 #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);
 
@@ -42,25 +65,37 @@ class AliHLTTPCGlobalMergerComponent : public AliHLTProcessor
        // 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)
 
index 402dddc..4163bb8 100644 (file)
@@ -62,12 +62,12 @@ const char* AliHLTTPCRawDataUnpackerComponent::GetComponentID()
 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 )
@@ -159,11 +159,11 @@ int AliHLTTPCRawDataUnpackerComponent::DoEvent( const AliHLTComponentEventData&
        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;
            }
index 2d066ac..8ac1150 100644 (file)
@@ -112,13 +112,13 @@ const char* AliHLTTPCSliceTrackerComponent::GetComponentID()
 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 )
@@ -549,7 +549,7 @@ int AliHLTTPCSliceTrackerComponent::DoEvent( const AliHLTComponentEventData& evt
        else
            *slCntIter++;
 
-       if ( iter->fDataType == AliHLTTPCDefinitions::gkVertexDataType )
+       if ( iter->fDataType == AliHLTTPCDefinitions::fgkVertexDataType )
            {
            inPtrV = (AliHLTTPCVertexData*)(iter->fPtr);
            vertexIter = iter;
@@ -557,7 +557,7 @@ int AliHLTTPCSliceTrackerComponent::DoEvent( const AliHLTComponentEventData& evt
            fVertex->Read( inPtrV );
            vertexSlice = slice;
            }
-       if ( iter->fDataType == AliHLTTPCDefinitions::gkClustersDataType )
+       if ( iter->fDataType == AliHLTTPCDefinitions::fgkClustersDataType )
            {
            patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
            if ( minPatch>patch )
@@ -614,7 +614,7 @@ int AliHLTTPCSliceTrackerComponent::DoEvent( const AliHLTComponentEventData& evt
        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;
@@ -635,7 +635,7 @@ int AliHLTTPCSliceTrackerComponent::DoEvent( const AliHLTComponentEventData& evt
        {
        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();
index fe23aa8..27e9b33 100644 (file)
@@ -60,12 +60,12 @@ const char* AliHLTTPCVertexFinderComponent::GetComponentID()
 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 )
@@ -118,7 +118,7 @@ int AliHLTTPCVertexFinderComponent::DoEvent( const AliHLTComponentEventData& evt
        iter = blocks+ndx;
        mysize = 0;
        offset = tSize;
-       if ( iter->fDataType != AliHLTTPCDefinitions::gkClustersDataType )
+       if ( iter->fDataType != AliHLTTPCDefinitions::fgkClustersDataType )
            {
            continue;
            }