coding conventions, eff C++, formatting, AliHLTConsumerDescriptor moved from AliHLTDa...
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 27 Feb 2007 09:28:36 +0000 (09:28 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 27 Feb 2007 09:28:36 +0000 (09:28 +0000)
15 files changed:
HLT/BASE/AliHLTConsumerDescriptor.cxx [new file with mode: 0644]
HLT/BASE/AliHLTConsumerDescriptor.h [new file with mode: 0644]
HLT/BASE/AliHLTDataBuffer.cxx
HLT/BASE/AliHLTDataBuffer.h
HLT/BASE/HLTbaseLinkDef.h
HLT/TPCLib/AliHLTTPCDigitReaderRaw.cxx
HLT/TPCLib/AliHLTTPCDigitReaderRaw.h
HLT/TPCLib/AliHLTTPCFitter.cxx
HLT/TPCLib/AliHLTTPCFitter.h
HLT/TPCLib/AliHLTTPCMemHandler.cxx
HLT/TPCLib/AliHLTTPCMemHandler.h
HLT/TPCLib/AliHLTTPCSliceTrackerComponent.cxx
HLT/TPCLib/AliHLTTPCSliceTrackerComponent.h
HLT/TPCLib/mapping2array.cxx.in
HLT/libHLTbase.pkg

diff --git a/HLT/BASE/AliHLTConsumerDescriptor.cxx b/HLT/BASE/AliHLTConsumerDescriptor.cxx
new file mode 100644 (file)
index 0000000..521fed2
--- /dev/null
@@ -0,0 +1,137 @@
+// $Id$
+
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Authors: Matthias Richter <Matthias.Richter@ift.uib.no>                *
+ *          for The ALICE Off-line Project.                               *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/** @file   AliHLTConsumerDescriptor.cxx
+    @author Matthias Richter
+    @date   
+    @brief  Helper class to describe a consumer component.
+*/
+
+#if __GNUC__>= 3
+using namespace std;
+#endif
+
+#include "AliHLTConsumerDescriptor.h"
+
+/** ROOT macro for the implementation of ROOT specific class methods */
+ClassImp(AliHLTConsumerDescriptor)
+
+AliHLTConsumerDescriptor::AliHLTConsumerDescriptor()
+  :
+  fpConsumer(NULL),
+  fSegments()
+{
+  // see header file for class documentation
+  // or
+  // refer to README to build package
+  // or
+  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
+  fSegments.clear();
+}
+
+AliHLTConsumerDescriptor::AliHLTConsumerDescriptor(AliHLTComponent* pConsumer)
+  :
+  fpConsumer(pConsumer),
+  fSegments()
+{
+  // see header file for function documentation
+  fSegments.clear();
+}
+
+AliHLTConsumerDescriptor::AliHLTConsumerDescriptor(const AliHLTConsumerDescriptor& desc)
+  :
+  TObject(),
+  AliHLTLogging(),
+  fpConsumer(desc.fpConsumer),
+  fSegments()
+{
+  // see header file for function documentation
+
+  // 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)
+{ 
+  // see header file for function documentation
+
+  // 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()
+{
+  // see header file for function documentation
+  if (fSegments.size()>0) {
+    //HLTWarning("unreleased data segments found");
+  }
+}
+
+int AliHLTConsumerDescriptor::SetActiveDataSegment(AliHLTUInt32_t offset, AliHLTUInt32_t size)
+{
+  // see header file for function documentation
+  int iResult=0;
+  AliHLTDataBuffer::AliHLTDataSegment segment(offset, size);
+  fSegments.push_back(segment);
+  //HLTDebug("set active segment (%d:%d) for consumer %p", offset, size, this);
+  return iResult;
+}
+
+int AliHLTConsumerDescriptor::CheckActiveDataSegment(AliHLTUInt32_t offset, AliHLTUInt32_t size)
+{
+  // see header file for function documentation
+  int iResult=0;
+  if (fSegments.size()>0) {
+    vector<AliHLTDataBuffer::AliHLTDataSegment>::iterator segment=fSegments.begin();
+    while (segment!=fSegments.end()) {
+      if ((iResult=((*segment).fSegmentOffset==offset && (*segment).fSegmentSize==size))>0) {
+       break;
+      }
+      segment++;
+    }
+  } else {
+    //HLTWarning("no data segment active for consumer %p", this);
+    iResult=-ENODATA;
+  }
+  return iResult;
+}
+
+int AliHLTConsumerDescriptor::ReleaseActiveDataSegment(AliHLTUInt32_t offset, AliHLTUInt32_t size)
+{
+  // see header file for function documentation
+  int iResult=0;
+  if (fSegments.size()>0) {
+    vector<AliHLTDataBuffer::AliHLTDataSegment>::iterator segment=fSegments.begin();
+    while (segment!=fSegments.end()) {
+      if ((iResult=((*segment).fSegmentOffset==offset && (*segment).fSegmentSize==size))>0) {
+       fSegments.erase(segment);
+       break;
+      }
+      segment++;
+    }
+    if (iResult==0) {
+      //HLTWarning("no data segment (%d:%d) active for consumer %p", offset, size, this);
+      iResult=-ENOENT;
+    }
+  } else {
+    //HLTWarning("no data segment active for consumer %p", this);
+    iResult=-ENODATA;
+  }
+  return iResult;
+}
diff --git a/HLT/BASE/AliHLTConsumerDescriptor.h b/HLT/BASE/AliHLTConsumerDescriptor.h
new file mode 100644 (file)
index 0000000..a9bc069
--- /dev/null
@@ -0,0 +1,97 @@
+// @(#) $Id$
+
+#ifndef ALIHLTCONSUMERDESCRIPTOR_H
+#define ALIHLTCONSUMERDESCRIPTOR_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/** @file   AliHLTConsumerDescriptor.h
+    @author Matthias Richter
+    @date   
+    @brief  Helper class to describe a consumer component.
+    @note   The class is used in Offline (AliRoot) context
+*/
+
+#include "AliHLTDataBuffer.h"
+
+/**
+ * @class AliHLTConsumerDescriptor
+ * @brief Helper class to describe a consumer component.
+ *
+ * There is unfortunately no unique determination of the data type from the
+ * component itself possible, thats why both component and data type have to
+ * be initialized and are stored in a compound. The class is intended to make
+ * bookkeeping easier.
+ *
+ * @note This class is only used for the @ref alihlt_system.
+ *
+ * @ingroup alihlt_system
+ */
+class AliHLTConsumerDescriptor : public TObject, public AliHLTLogging {
+ public:
+  /** standard constructur */
+  AliHLTConsumerDescriptor();
+  /** constructur 
+   * @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();
+
+  /**
+   * Get the component of this descriptor.
+   * @return pointer to the component
+   */
+  AliHLTComponent* GetComponent() {return fpConsumer;}
+
+  /**
+   * Set an active data segment.
+   * the pointer will be handled in a container, no allocation, copy or
+   * cleanup.
+   * @param offset  offset of the segment in the buffer
+   * @param size    size of the segment in the buffer
+   * @return >=0 if succeeded
+   */
+  int SetActiveDataSegment(AliHLTUInt32_t offset, AliHLTUInt32_t size);
+
+  /**
+   * Check whether there is an active data segment of certain size with
+   * certain offset.
+   * @param offset  offset of the data segment in the data buffer
+   * @param size    size of the data segment in the data buffer
+   * @return > if existend, 0 if not
+   */
+  int CheckActiveDataSegment(AliHLTUInt32_t offset, AliHLTUInt32_t size);
+
+  /** find an active data segment of certain size with certain offset
+   * will see if this is necessary
+   * @param offset  offset of the data segment in the data buffer
+   * @param size    size of the data segment in the data buffer
+   * @return offset of the data segment
+   */
+  //AliHLTUInt32_t FindActiveDataSegment(AliHLTUInt32_t offset, AliHLTUInt32_t size);
+
+  /** get the number of active segments for this consumer
+   * @return number of active segments
+   */
+  int GetNofActiveSegments() {return fSegments.size();};
+
+  /**
+   */
+  int ReleaseActiveDataSegment(AliHLTUInt32_t offset, AliHLTUInt32_t size);
+
+ private:
+  /** consumer object */
+  AliHLTComponent* fpConsumer;                                     //! transient
+
+  /** list of data segments */
+  vector<AliHLTDataBuffer::AliHLTDataSegment> fSegments;           // see above
+
+  ClassDef(AliHLTConsumerDescriptor, 0)
+};
+
+#endif // ALIHLTDATABUFFER_H
index bb187c8..7dfba4d 100644 (file)
@@ -26,116 +26,11 @@ using namespace std;
 #endif
 
 #include "AliHLTDataBuffer.h"
+#include "AliHLTConsumerDescriptor.h"
 #include "AliHLTComponent.h"
 #include <string>
 #include "AliHLTSystem.h"
 
-AliHLTConsumerDescriptor::AliHLTConsumerDescriptor()
-  :
-  fpConsumer(NULL),
-  fSegments()
-{
-  // see header file for class documentation
-  // or
-  // refer to README to build package
-  // or
-  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
-  fSegments.clear();
-}
-
-AliHLTConsumerDescriptor::AliHLTConsumerDescriptor(AliHLTComponent* pConsumer)
-  :
-  fpConsumer(pConsumer),
-  fSegments()
-{
-  // see header file for function documentation
-  fSegments.clear();
-}
-
-AliHLTConsumerDescriptor::AliHLTConsumerDescriptor(const AliHLTConsumerDescriptor& desc)
-  :
-  TObject(),
-  AliHLTLogging(),
-  fpConsumer(desc.fpConsumer),
-  fSegments()
-{
-  // see header file for function documentation
-
-  // 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)
-{ 
-  // see header file for function documentation
-
-  // 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()
-{
-  // see header file for function documentation
-  if (fSegments.size()>0) {
-    //HLTWarning("unreleased data segments found");
-  }
-}
-
-int AliHLTConsumerDescriptor::SetActiveDataSegment(AliHLTUInt32_t offset, AliHLTUInt32_t size)
-{
-  // see header file for function documentation
-  int iResult=0;
-  AliHLTDataSegment segment(offset, size);
-  fSegments.push_back(segment);
-  //HLTDebug("set active segment (%d:%d) for consumer %p", offset, size, this);
-  return iResult;
-}
-
-int AliHLTConsumerDescriptor::CheckActiveDataSegment(AliHLTUInt32_t offset, AliHLTUInt32_t size)
-{
-  // see header file for function documentation
-  int iResult=0;
-  if (fSegments.size()>0) {
-    vector<AliHLTDataSegment>::iterator segment=fSegments.begin();
-    while (segment!=fSegments.end()) {
-      if ((iResult=((*segment).fSegmentOffset==offset && (*segment).fSegmentSize==size))>0) {
-       break;
-      }
-      segment++;
-    }
-  } else {
-    //HLTWarning("no data segment active for consumer %p", this);
-    iResult=-ENODATA;
-  }
-  return iResult;
-}
-
-int AliHLTConsumerDescriptor::ReleaseActiveDataSegment(AliHLTUInt32_t offset, AliHLTUInt32_t size)
-{
-  // see header file for function documentation
-  int iResult=0;
-  if (fSegments.size()>0) {
-    vector<AliHLTDataSegment>::iterator segment=fSegments.begin();
-    while (segment!=fSegments.end()) {
-      if ((iResult=((*segment).fSegmentOffset==offset && (*segment).fSegmentSize==size))>0) {
-       fSegments.erase(segment);
-       break;
-      }
-      segment++;
-    }
-    if (iResult==0) {
-      //HLTWarning("no data segment (%d:%d) active for consumer %p", offset, size, this);
-      iResult=-ENOENT;
-    }
-  } else {
-    //HLTWarning("no data segment active for consumer %p", this);
-    iResult=-ENODATA;
-  }
-  return iResult;
-}
-
 /** ROOT macro for the implementation of ROOT specific class methods */
 ClassImp(AliHLTDataBuffer)
 
@@ -183,8 +78,8 @@ AliHLTDataBuffer& AliHLTDataBuffer::operator=(const AliHLTDataBuffer&)
 }
 
 int AliHLTDataBuffer::fgNofInstances=0;
-vector<AliHLTRawBuffer*> AliHLTDataBuffer::fgFreeBuffers;
-vector<AliHLTRawBuffer*> AliHLTDataBuffer::fgActiveBuffers;
+vector<AliHLTDataBuffer::AliHLTRawBuffer*> AliHLTDataBuffer::fgFreeBuffers;
+vector<AliHLTDataBuffer::AliHLTRawBuffer*> AliHLTDataBuffer::fgActiveBuffers;
 AliHLTUInt32_t AliHLTDataBuffer::fgMargin=1024;
 AliHLTLogging AliHLTDataBuffer::fgLogging;
 
@@ -225,10 +120,10 @@ int AliHLTDataBuffer::FindMatchingDataBlocks(const AliHLTComponent* pConsumer, v
   // see header file for function documentation
   int iResult=0;
   if (pConsumer) {
-    vector<AliHLTDataSegment> segments;
+    vector<AliHLTDataBuffer::AliHLTDataSegment> segments;
     if ((iResult=FindMatchingDataSegments(pConsumer, segments))>=0) {
       if (tgtList) {
-       vector<AliHLTDataSegment>::iterator segment=segments.begin();
+       vector<AliHLTDataBuffer::AliHLTDataSegment>::iterator segment=segments.begin();
        while (segment!=segments.end()) {
          tgtList->push_back((*segment).fDataType);
          segment++;
@@ -242,14 +137,14 @@ int AliHLTDataBuffer::FindMatchingDataBlocks(const AliHLTComponent* pConsumer, v
   return iResult;
 }
 
-int AliHLTDataBuffer::FindMatchingDataSegments(const AliHLTComponent* pConsumer, vector<AliHLTDataSegment>& tgtList)
+int AliHLTDataBuffer::FindMatchingDataSegments(const AliHLTComponent* pConsumer, vector<AliHLTDataBuffer::AliHLTDataSegment>& tgtList)
 {
   // see header file for function documentation
   int iResult=0;
   if (pConsumer) {
     vector<AliHLTComponentDataType> dtlist;
     ((AliHLTComponent*)pConsumer)->GetInputDataTypes(dtlist);
-    vector<AliHLTDataSegment>::iterator segment=fSegments.begin();
+    vector<AliHLTDataBuffer::AliHLTDataSegment>::iterator segment=fSegments.begin();
     while (segment!=fSegments.end()) {
       vector<AliHLTComponentDataType>::iterator type=dtlist.begin();
       while (type!=dtlist.end()) {
@@ -277,14 +172,14 @@ int AliHLTDataBuffer::Subscribe(const AliHLTComponent* pConsumer, AliHLTComponen
     if (fpBuffer) {
       AliHLTConsumerDescriptor* pDesc=FindConsumer(pConsumer, fConsumers);
       if (pDesc) {
-       vector<AliHLTDataSegment> tgtList;
+       vector<AliHLTDataBuffer::AliHLTDataSegment> tgtList;
        /* TODO: think about a good policy for this check
         * is it enough that at least one segment is available, or have all to be available?
         * or is it possible to have optional segments?
         */
        if ((iResult=FindMatchingDataSegments(pConsumer, tgtList))>0) {
          int i =0;
-         vector<AliHLTDataSegment>::iterator segment=tgtList.begin();
+         vector<AliHLTDataBuffer::AliHLTDataSegment>::iterator segment=tgtList.begin();
          while (segment!=tgtList.end() && i<iArraySize) {
            // fill the block data descriptor
            arrayBlockDesc[i].fStructSize=sizeof(AliHLTComponentBlockData);
@@ -389,8 +284,8 @@ int AliHLTDataBuffer::SetSegments(AliHLTUInt8_t* pTgt, AliHLTComponentBlockData*
   if (pTgt && arrayBlockData && iSize>=0) {
     if (fpBuffer) {
       if (fpBuffer->fPtr==(void*)pTgt) {
-       AliHLTDataSegment segment;
-       memset(&segment, 0, sizeof(AliHLTDataSegment));
+       AliHLTDataBuffer::AliHLTDataSegment segment;
+       memset(&segment, 0, sizeof(AliHLTDataBuffer::AliHLTDataSegment));
        for (int i=0; i<iSize; i++) {
          if (arrayBlockData[i].fOffset+arrayBlockData[i].fSize<=fpBuffer->fSize) {
            segment.fSegmentOffset=arrayBlockData[i].fOffset;
@@ -446,7 +341,7 @@ int AliHLTDataBuffer::GetNofActiveConsumers()
   return iResult;
 }
 
-AliHLTRawBuffer* AliHLTDataBuffer::CreateRawBuffer(AliHLTUInt32_t size)
+AliHLTDataBuffer::AliHLTRawBuffer* AliHLTDataBuffer::CreateRawBuffer(AliHLTUInt32_t size)
 {
   // see header file for function documentation
   AliHLTRawBuffer* pRawBuffer=NULL;
@@ -572,7 +467,7 @@ int AliHLTDataBuffer::ResetDataBuffer()
   }
 
   // cleanup segments
-  vector<AliHLTDataSegment>::iterator segment=fSegments.begin();
+  vector<AliHLTDataBuffer::AliHLTDataSegment>::iterator segment=fSegments.begin();
   while (segment!=fSegments.end()) {
     fSegments.erase(segment);
     segment=fSegments.begin();
index 274fa7a..50a0f5f 100644 (file)
 //#include "TList.h"
 
 class AliHLTComponent;
-/* @name internal data structures
- */
-
-/**
- * @struct AliHLTDataSegment
- * @brief  Descriptor of a data segment within the buffer.
- * @ingroup alihlt_system
- */
-struct AliHLTDataSegment {
-  AliHLTDataSegment()
-    :
-    fDataType(),
-    fSegmentOffset(0),
-    fSegmentSize(0),
-    fSpecification(0)
-  {
-    memset(&fDataType, 0, sizeof(AliHLTComponentDataType));
-  }
-  AliHLTDataSegment(AliHLTUInt32_t offset, AliHLTUInt32_t size) 
-    :
-    fDataType(),
-    fSegmentOffset(offset),
-    fSegmentSize(size),
-    fSpecification(0)
-  {
-    memset(&fDataType, 0, sizeof(AliHLTComponentDataType));
-  }
-  /** the data type of this segment */
-  AliHLTComponentDataType fDataType;                               // see above
-  /** offset in byte within the data buffer */
-  AliHLTUInt32_t fSegmentOffset;                                   // see above
-  /** size of the actual content */
-  AliHLTUInt32_t fSegmentSize;                                     // see above
-  /** data specification */
-  AliHLTUInt32_t fSpecification;                                   // see above
-};
-
-/**
- * @struct AliHLTRawBuffer
- * @brief  Descriptor of the raw data buffer which can host several segments.
- * @ingroup alihlt_system
- */
-struct AliHLTRawBuffer {
-  /** size of the currently occupied partition of the buffer */
-  AliHLTUInt32_t fSize;                                            // see above
-  /** total size of the buffer, including safety margin */
-  AliHLTUInt32_t fTotalSize;                                       // see above
-  /** the buffer */
-  void* fPtr;                                                      //! transient
-};
-
-/**
- * @class AliHLTConsumerDescriptor
- * @brief Helper class to describe a consumer component.
- *
- * There is unfortunately no unique determination of the data type from the
- * component itself possible, thats why both component and data type have to
- * be initialized and are stored in a compound. The class is intended to make
- * bookkeeping easier.
- *
- * @note This class is only used for the @ref alihlt_system.
- *
- * @ingroup alihlt_system
- */
-class AliHLTConsumerDescriptor : public TObject, public AliHLTLogging {
- public:
-  /** standard constructur */
-  AliHLTConsumerDescriptor();
-  /** constructur 
-   * @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();
-
-  /**
-   * Get the component of this descriptor.
-   * @return pointer to the component
-   */
-  AliHLTComponent* GetComponent() {return fpConsumer;}
-
-  /**
-   * Set an active data segment.
-   * the pointer will be handled in a container, no allocation, copy or
-   * cleanup.
-   * @param offset  offset of the segment in the buffer
-   * @param size    size of the segment in the buffer
-   * @return >=0 if succeeded
-   */
-  int SetActiveDataSegment(AliHLTUInt32_t offset, AliHLTUInt32_t size);
-
-  /**
-   * Check whether there is an active data segment of certain size with
-   * certain offset.
-   * @param offset  offset of the data segment in the data buffer
-   * @param size    size of the data segment in the data buffer
-   * @return > if existend, 0 if not
-   */
-  int CheckActiveDataSegment(AliHLTUInt32_t offset, AliHLTUInt32_t size);
-
-  /** find an active data segment of certain size with certain offset
-   * will see if this is necessary
-   * @param offset  offset of the data segment in the data buffer
-   * @param size    size of the data segment in the data buffer
-   * @return offset of the data segment
-   */
-  //AliHLTUInt32_t FindActiveDataSegment(AliHLTUInt32_t offset, AliHLTUInt32_t size);
-
-  /** get the number of active segments for this consumer
-   * @return number of active segments
-   */
-  int GetNofActiveSegments() {return fSegments.size();};
-
-  /**
-   */
-  int ReleaseActiveDataSegment(AliHLTUInt32_t offset, AliHLTUInt32_t size);
-
- private:
-  /** consumer object */
-  AliHLTComponent* fpConsumer;                                     //! transient
-
-  /** list of data segments */
-  vector<AliHLTDataSegment> fSegments;                             // see above
-
-  //ClassDef(AliHLTConsumerDescriptor, 0)
-};
+class AliHLTConsumerDescriptor;
 
 /**
  * @class AliHLTDataBuffer
@@ -170,10 +41,11 @@ class AliHLTConsumerDescriptor : public TObject, public AliHLTLogging {
  *
  * @ingroup alihlt_system
  */
-class AliHLTDataBuffer : public TObject, public AliHLTLogging {
+class AliHLTDataBuffer : public TObject, public AliHLTLogging 
+{
  public:
   //////////////////////////////////////////////////////////////////////////////
-  // condtructors and destructors
+  // constructors and destructors
 
   /* standard constructor
    */
@@ -317,9 +189,55 @@ class AliHLTDataBuffer : public TObject, public AliHLTLogging {
    */
   int Reset();
 
+  /**
+   * @struct AliHLTDataSegment
+   * @brief  Descriptor of a data segment within the buffer.
+   */
+  struct AliHLTDataSegment {
+    AliHLTDataSegment()
+      :
+      fDataType(),
+      fSegmentOffset(0),
+      fSegmentSize(0),
+      fSpecification(0)
+    {
+      memset(&fDataType, 0, sizeof(AliHLTComponentDataType));
+    }
+    AliHLTDataSegment(AliHLTUInt32_t offset, AliHLTUInt32_t size) 
+      :
+      fDataType(),
+      fSegmentOffset(offset),
+      fSegmentSize(size),
+      fSpecification(0)
+    {
+      memset(&fDataType, 0, sizeof(AliHLTComponentDataType));
+    }
+    /** the data type of this segment */
+    AliHLTComponentDataType fDataType;                             // see above
+    /** offset in byte within the data buffer */
+    AliHLTUInt32_t fSegmentOffset;                                 // see above
+    /** size of the actual content */
+    AliHLTUInt32_t fSegmentSize;                                   // see above
+    /** data specification */
+    AliHLTUInt32_t fSpecification;                                 // see above
+  };
+
+  /**
+   * @struct AliHLTRawBuffer
+   * @brief  Descriptor of the raw data buffer which can host several segments.
+   */
+  struct AliHLTRawBuffer {
+    /** size of the currently occupied partition of the buffer */
+    AliHLTUInt32_t fSize;                                          // see above
+    /** total size of the buffer, including safety margin */
+    AliHLTUInt32_t fTotalSize;                                     // see above
+    /** the buffer */
+    void* fPtr;                                                    //! transient
+  };
+
  private:
   /* lets see if this is needed
-  AliHLTDataSegment* FindDataSegment(AliHLTComponentDataType datatype);
+     AliHLTDataSegment* FindDataSegment(AliHLTComponentDataType datatype);
   */
 
   /**
@@ -439,4 +357,5 @@ class AliHLTDataBuffer : public TObject, public AliHLTLogging {
 
   ClassDef(AliHLTDataBuffer, 0)
 };
+
 #endif // ALIHLTDATABUFFER_H
index 330c7ea..27e6be8 100644 (file)
@@ -15,6 +15,7 @@
 #pragma link C++ class AliHLTTask;
 #pragma link C++ class AliHLTLogging;
 #pragma link C++ class AliHLTDataBuffer;
+#pragma link C++ class AliHLTConsumerDescriptor;
 #pragma link C++ class AliHLTDataSource;
 #pragma link C++ class AliHLTDataSink;
 #pragma link C++ class AliHLTFilePublisher;
index e0c7ceb..586d91f 100644 (file)
@@ -41,6 +41,8 @@ AliHLTTPCDigitReaderRaw::AliHLTTPCDigitReaderRaw( unsigned formatVersion )
   fBufferSize(0),
   fPatch(-1),
   fSlice(-1),
+  fRow(-1),
+  fPad(-1),
   fDataFormatVersion(formatVersion),
   fVerify(false),
   
@@ -55,13 +57,18 @@ AliHLTTPCDigitReaderRaw::AliHLTTPCDigitReaderRaw( unsigned formatVersion )
   fData(NULL),
   fMapErrThrown(0)
 {
+  // see header file for class documentation
+  // or
+  // refer to README to build package
+  // or
+  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
 #ifndef HAVE_TPC_MAPPING
-  memset(fMapping0, 0, fMapping0Size*fMappingDimension*sizeof(Int_t));
-  memset(fMapping1, 0, fMapping1Size*fMappingDimension*sizeof(Int_t));
-  memset(fMapping2, 0, fMapping2Size*fMappingDimension*sizeof(Int_t));
-  memset(fMapping3, 0, fMapping3Size*fMappingDimension*sizeof(Int_t));
-  memset(fMapping4, 0, fMapping4Size*fMappingDimension*sizeof(Int_t));
-  memset(fMapping5, 0, fMapping5Size*fMappingDimension*sizeof(Int_t));
+  memset(fgMapping0, 0, fgkMapping0Size*fgkMappingDimension*sizeof(Int_t));
+  memset(fgMapping1, 0, fgkMapping1Size*fgkMappingDimension*sizeof(Int_t));
+  memset(fgMapping2, 0, fgkMapping2Size*fgkMappingDimension*sizeof(Int_t));
+  memset(fgMapping3, 0, fgkMapping3Size*fgkMappingDimension*sizeof(Int_t));
+  memset(fgMapping4, 0, fgkMapping4Size*fgkMappingDimension*sizeof(Int_t));
+  memset(fgMapping5, 0, fgkMapping5Size*fgkMappingDimension*sizeof(Int_t));
 #endif //#ifndef HAVE_TPC_MAPPING
 
     if ( fDataFormatVersion==0 || fDataFormatVersion==2 || fDataFormatVersion==4 )
@@ -94,6 +101,8 @@ AliHLTTPCDigitReaderRaw::AliHLTTPCDigitReaderRaw(const AliHLTTPCDigitReaderRaw&
   fBufferSize(0),
   fPatch(-1),
   fSlice(-1),
+  fRow(-1),
+  fPad(-1),
   fDataFormatVersion(src.fDataFormatVersion),
   fVerify(false),
   
@@ -108,31 +117,35 @@ AliHLTTPCDigitReaderRaw::AliHLTTPCDigitReaderRaw(const AliHLTTPCDigitReaderRaw&
   fData(NULL),
   fMapErrThrown(0)
 {
+  // see header file for class documentation
 #ifndef HAVE_TPC_MAPPING
-  memset(fMapping0, 0, fMapping0Size*fMappingDimension*sizeof(Int_t));
-  memset(fMapping1, 0, fMapping1Size*fMappingDimension*sizeof(Int_t));
-  memset(fMapping2, 0, fMapping2Size*fMappingDimension*sizeof(Int_t));
-  memset(fMapping3, 0, fMapping3Size*fMappingDimension*sizeof(Int_t));
-  memset(fMapping4, 0, fMapping4Size*fMappingDimension*sizeof(Int_t));
-  memset(fMapping5, 0, fMapping5Size*fMappingDimension*sizeof(Int_t));
+  memset(fgMapping0, 0, fgkMapping0Size*fgkMappingDimension*sizeof(Int_t));
+  memset(fgMapping1, 0, fgkMapping1Size*fgkMappingDimension*sizeof(Int_t));
+  memset(fgMapping2, 0, fgkMapping2Size*fgkMappingDimension*sizeof(Int_t));
+  memset(fgMapping3, 0, fgkMapping3Size*fgkMappingDimension*sizeof(Int_t));
+  memset(fgMapping4, 0, fgkMapping4Size*fgkMappingDimension*sizeof(Int_t));
+  memset(fgMapping5, 0, fgkMapping5Size*fgkMappingDimension*sizeof(Int_t));
 #endif //#ifndef HAVE_TPC_MAPPING
   HLTFatal("copy constructor not for use");
 }
 
 AliHLTTPCDigitReaderRaw& AliHLTTPCDigitReaderRaw::operator=(const AliHLTTPCDigitReaderRaw& src)
 {
+  // see header file for class documentation
 #ifndef HAVE_TPC_MAPPING
-  memset(fMapping0, 0, fMapping0Size*fMappingDimension*sizeof(Int_t));
-  memset(fMapping1, 0, fMapping1Size*fMappingDimension*sizeof(Int_t));
-  memset(fMapping2, 0, fMapping2Size*fMappingDimension*sizeof(Int_t));
-  memset(fMapping3, 0, fMapping3Size*fMappingDimension*sizeof(Int_t));
-  memset(fMapping4, 0, fMapping4Size*fMappingDimension*sizeof(Int_t));
-  memset(fMapping5, 0, fMapping5Size*fMappingDimension*sizeof(Int_t));
+  memset(fgMapping0, 0, fgkMapping0Size*fgkMappingDimension*sizeof(Int_t));
+  memset(fgMapping1, 0, fgkMapping1Size*fgkMappingDimension*sizeof(Int_t));
+  memset(fgMapping2, 0, fgkMapping2Size*fgkMappingDimension*sizeof(Int_t));
+  memset(fgMapping3, 0, fgkMapping3Size*fgkMappingDimension*sizeof(Int_t));
+  memset(fgMapping4, 0, fgkMapping4Size*fgkMappingDimension*sizeof(Int_t));
+  memset(fgMapping5, 0, fgkMapping5Size*fgkMappingDimension*sizeof(Int_t));
 #endif //#ifndef HAVE_TPC_MAPPING
   fBuffer=NULL;
   fBufferSize=0;
   fPatch=-1;
   fSlice=-1;
+  fRow=-1;
+  fPad=-1;
   fDataFormatVersion=src.fDataFormatVersion;
   fCurrentRow=0;
   fCurrentPad=0;
@@ -151,7 +164,9 @@ AliHLTTPCDigitReaderRaw& AliHLTTPCDigitReaderRaw::operator=(const AliHLTTPCDigit
   return (*this);
 }
 
-AliHLTTPCDigitReaderRaw::~AliHLTTPCDigitReaderRaw(){
+AliHLTTPCDigitReaderRaw::~AliHLTTPCDigitReaderRaw()
+{
+  // see header file for class documentation
   if ( fDataFormatVersion==0 || fDataFormatVersion==2 || fDataFormatVersion==4 )
     {
       if ( fData )
@@ -160,11 +175,15 @@ AliHLTTPCDigitReaderRaw::~AliHLTTPCDigitReaderRaw(){
     }
 }
 
-int AliHLTTPCDigitReaderRaw::InitBlock(void* ptr,unsigned long size,Int_t firstrow,Int_t lastrow, Int_t patch, Int_t slice) {
+int AliHLTTPCDigitReaderRaw::InitBlock(void* ptr,unsigned long size,Int_t firstrow,Int_t lastrow, Int_t patch, Int_t slice) 
+{
+  // see header file for class documentation
   return AliHLTTPCDigitReader::InitBlock(ptr, size, firstrow, lastrow, patch, slice);
 }
 
-int AliHLTTPCDigitReaderRaw::InitBlock(void* ptr,unsigned long size, Int_t patch, Int_t slice){
+int AliHLTTPCDigitReaderRaw::InitBlock(void* ptr,unsigned long size, Int_t patch, Int_t slice)
+{
+  // see header file for class documentation
 
     fBuffer = (AliHLTUInt8_t*) ptr;
     if (fBuffer==NULL) {
@@ -208,7 +227,7 @@ int AliHLTTPCDigitReaderRaw::InitBlock(void* ptr,unsigned long size, Int_t patch
        // Init array with -1
        memset( fData, 0xFF, sizeof(Int_t)*(fNMaxRows*fNMaxPads*fNTimeBins) );
 
-       const Int_t maxErrorPrintout=20;
+       const Int_t kMaxErrorPrintout=20;
        Int_t errorCount=0;
        Int_t entryCount=0;
        // read data and fill in array
@@ -224,7 +243,7 @@ int AliHLTTPCDigitReaderRaw::InitBlock(void* ptr,unsigned long size, Int_t patch
 
          if ( row < firstrow || row > lastrow || pad > AliHLTTPCTransform::GetNPads(row + offset) || bin > fNTimeBins || pad<0 || bin<0){
 //       if ( row < firstrow || row > lastrow || pad > AliHLTTPCTransform::GetNPads(row + offset) || bin > fNTimeBins){
-           if (errorCount++<maxErrorPrintout) {
+           if (errorCount++<kMaxErrorPrintout) {
              HLTFatal("Index out of range. Probably wrong patch! slice %d - patch %d", slice, patch);
              HLTFatal("PAD=%d out of %d ||| ROW=%d (%d to %d)  ||| BIN=%d out of %d  ||| OFFSET=%d ||| ROWOFFSET=%d",
                       pad, AliHLTTPCTransform::GetNPads(row + offset), row, firstrow, lastrow, bin, fNTimeBins,
@@ -242,7 +261,7 @@ int AliHLTTPCDigitReaderRaw::InitBlock(void* ptr,unsigned long size, Int_t patch
            //continue;
            break;
          } else if ((row-fRowOffset)*fNMaxPads*fNTimeBins+ pad*fNTimeBins + bin >=  fNMaxRows*fNMaxPads*fNTimeBins ) {
-           if (errorCount++<maxErrorPrintout) {
+           if (errorCount++<kMaxErrorPrintout) {
              HLTFatal("index out of range: PAD=%d ||| ROW=%d ||| BIN=%d ||| OFFSET=%d ||| ROWOFFSET=%d", pad, row, bin, offset, fRowOffset);
            }
            // stop at the fist error message in order to avoid endless messages and
@@ -261,7 +280,10 @@ int AliHLTTPCDigitReaderRaw::InitBlock(void* ptr,unsigned long size, Int_t patch
     return 0;
 }
 
-bool AliHLTTPCDigitReaderRaw::Next(){
+bool AliHLTTPCDigitReaderRaw::Next()
+{
+  // see header file for class documentation
+
   if ( fDataFormatVersion==0 || fDataFormatVersion==2 || fDataFormatVersion==4 )
     {
       Bool_t readvalue = kTRUE;
@@ -296,7 +318,10 @@ bool AliHLTTPCDigitReaderRaw::Next(){
     return RealNext();
 }
 
-int AliHLTTPCDigitReaderRaw::GetRow(){
+int AliHLTTPCDigitReaderRaw::GetRow()
+{
+  // see header file for class documentation
+
   if ( fDataFormatVersion==0 || fDataFormatVersion==2 || fDataFormatVersion==4 )
     {
       return (fCurrentRow + fRowOffset);
@@ -304,7 +329,11 @@ int AliHLTTPCDigitReaderRaw::GetRow(){
   else
     return GetRealRow();
 }
-int AliHLTTPCDigitReaderRaw::GetPad(){
+
+int AliHLTTPCDigitReaderRaw::GetPad()
+{
+  // see header file for class documentation
+
   if ( fDataFormatVersion==0 || fDataFormatVersion==2 || fDataFormatVersion==4 )
     {
       return fCurrentPad;
@@ -312,7 +341,11 @@ int AliHLTTPCDigitReaderRaw::GetPad(){
   else
     return GetRealPad();
 }
-int AliHLTTPCDigitReaderRaw::GetSignal(){
+
+int AliHLTTPCDigitReaderRaw::GetSignal()
+{
+  // see header file for class documentation
+
   if ( fDataFormatVersion==0 || fDataFormatVersion==2 || fDataFormatVersion==4 )
     {
       return fData[ fCurrentRow*fNMaxPads*fNTimeBins+ fCurrentPad*fNTimeBins + fCurrentBin ];
@@ -320,7 +353,11 @@ int AliHLTTPCDigitReaderRaw::GetSignal(){
   else
     return GetRealSignal();
 }
-int AliHLTTPCDigitReaderRaw::GetTime(){
+
+int AliHLTTPCDigitReaderRaw::GetTime()
+{
+  // see header file for class documentation
+
   if ( fDataFormatVersion==0 || fDataFormatVersion==2 || fDataFormatVersion==4 )
     {
       return fCurrentBin;
@@ -329,8 +366,10 @@ int AliHLTTPCDigitReaderRaw::GetTime(){
     return GetRealTime();
 }
 
+bool AliHLTTPCDigitReaderRaw::RealNext()
+{
+  // see header file for class documentation
 
-bool AliHLTTPCDigitReaderRaw::RealNext(){
 //    printf( "%u %u %u %u %u\n", fBunchPosition, fBunchLength, fBunchTimebinStart, fWordInBunch, (unsigned)fAltroBlock10BitWordCnt );
     fWordInBunch++; // use next word in bunch
     if ( fWordInBunch==fBunchLength ) { // we have a bunch at all but have reached its end (or do not have an altro block yet)
@@ -349,21 +388,35 @@ bool AliHLTTPCDigitReaderRaw::RealNext(){
     //HLTDebug( "%u %u %u %u %u\n", fBunchPosition, fBunchLength, fBunchTimebinStart, fWordInBunch, (unsigned)fAltroBlock10BitWordCnt );
     return true;
 }
-int AliHLTTPCDigitReaderRaw::GetRealRow(){
+
+int AliHLTTPCDigitReaderRaw::GetRealRow() const
+{
+  // see header file for class documentation
     return fRow;
 }
-int AliHLTTPCDigitReaderRaw::GetRealPad(){
+
+int AliHLTTPCDigitReaderRaw::GetRealPad() const
+{
+  // see header file for class documentation
     return fPad;
 }
-int AliHLTTPCDigitReaderRaw::GetRealSignal(){
+
+int AliHLTTPCDigitReaderRaw::GetRealSignal()
+{
+  // see header file for class documentation
     return GetAltroBlock10BitWord( fBunchPosition+fWordInBunch );
 }
-int AliHLTTPCDigitReaderRaw::GetRealTime(){
+
+int AliHLTTPCDigitReaderRaw::GetRealTime() const
+{
+  // see header file for class documentation
   //HLTDebug( "GetRealTime: %u - %u\n", fBunchTimebinStart, fWordInBunch );
     return fBunchTimebinStart-(fWordInBunch-2);
 }
 
-AliHLTUInt32_t AliHLTTPCDigitReaderRaw::GetRCUTrailer( unsigned offset ){
+AliHLTUInt32_t AliHLTTPCDigitReaderRaw::GetRCUTrailer( unsigned offset ) const
+{
+  // see header file for class documentation
   if (fBufferSize<=0) return 0;
   unsigned rcuDataBlockLen = GetRCUDataBlockLength(); 
   if ( offset >= rcuDataBlockLen ) return 0;
@@ -371,7 +424,8 @@ AliHLTUInt32_t AliHLTTPCDigitReaderRaw::GetRCUTrailer( unsigned offset ){
 }
 
 bool AliHLTTPCDigitReaderRaw::NextAltroBlock()
-    {
+{
+  // see header file for class documentation
     if (fBufferSize<=0) return 0;
     bool first = false;
     if ( !fAltroBlockLengthBytes )
@@ -430,7 +484,7 @@ bool AliHLTTPCDigitReaderRaw::NextAltroBlock()
       if (!ApplyMapping())
        {
          HLTFatal("Mapping failed Patch %d HWA %#x (%d) - maxHWA %#x (%d)",
-                  fPatch, fAltroBlockHWAddress, fAltroBlockHWAddress, fMaxHWA[fPatch], fMaxHWA[fPatch]);
+                  fPatch, fAltroBlockHWAddress, fAltroBlockHWAddress, fgMaxHWA[fPatch], fgMaxHWA[fPatch]);
 
        }
 
@@ -457,15 +511,23 @@ bool AliHLTTPCDigitReaderRaw::NextAltroBlock()
          }
       }
     return true;
-    }
+}
 
-AliHLTUInt32_t AliHLTTPCDigitReaderRaw::GetAltroBlockHWaddr(){
-return fAltroBlockHWAddress;
+AliHLTUInt32_t AliHLTTPCDigitReaderRaw::GetAltroBlockHWaddr() const
+{
+  // see header file for class documentation
+  return fAltroBlockHWAddress;
 }
-unsigned AliHLTTPCDigitReaderRaw::GetAltroBlock10BitWordCnt(){
-return fAltroBlock10BitWordCnt;
+
+unsigned AliHLTTPCDigitReaderRaw::GetAltroBlock10BitWordCnt() const
+{
+  // see header file for class documentation
+  return fAltroBlock10BitWordCnt;
 }
-AliHLTUInt64_t AliHLTTPCDigitReaderRaw::GetAltroBlock40BitWord( unsigned long ndx ){
+
+AliHLTUInt64_t AliHLTTPCDigitReaderRaw::GetAltroBlock40BitWord( unsigned long ndx ) const
+{
+  // see header file for class documentation
 AliHLTUInt64_t val=0;
 unsigned wordOffset32Bit = (ndx / 4)*5;
 switch ( ndx % 4 ) // 40 bit word index in a 4*40 bit=5*32 bit group
@@ -493,7 +555,10 @@ switch ( ndx % 4 ) // 40 bit word index in a 4*40 bit=5*32 bit group
     }
 return val;
 }
-AliHLTUInt16_t AliHLTTPCDigitReaderRaw::GetAltroBlock10BitWord( unsigned long ndx ){
+
+AliHLTUInt16_t AliHLTTPCDigitReaderRaw::GetAltroBlock10BitWord( unsigned long ndx )
+{
+  // see header file for class documentation
 unsigned long realNdx = ndx+fAltroBlock10BitFillWordCnt;
 unsigned long word40BitNdx = (realNdx / 4)+1;
 AliHLTUInt64_t word40Bit = GetAltroBlock40BitWord( word40BitNdx );
@@ -512,7 +577,9 @@ switch ( realNdx % 4 )
  return 0xFFFF; 
 }
 
-AliHLTUInt16_t AliHLTTPCDigitReaderRaw::GetAltroBlockReal10BitWord( unsigned long ndx ){
+AliHLTUInt16_t AliHLTTPCDigitReaderRaw::GetAltroBlockReal10BitWord( unsigned long ndx )
+{
+  // see header file for class documentation
 unsigned long word40BitNdx = (ndx / 4)+1;
 AliHLTUInt64_t word40Bit = GetAltroBlock40BitWord( word40BitNdx );
 switch ( ndx % 4 )
@@ -530,9 +597,10 @@ switch ( ndx % 4 )
  return 0xFFFF; 
 }
 
-// Return length of trailing RCU data block in bytes
 unsigned AliHLTTPCDigitReaderRaw::GetRCUDataBlockLength() const
-    {
+{
+  // see header file for class documentation
+  // Return length of trailing RCU data block in bytes
     switch ( fDataFormatVersion )
        {
        case 0:
@@ -550,15 +618,18 @@ unsigned AliHLTTPCDigitReaderRaw::GetRCUDataBlockLength() const
        default:
            return fBufferSize;
        }
-    }
+}
 
 unsigned AliHLTTPCDigitReaderRaw::GetCommonDataHeaderSize() const
-    {
-    return 32;
-    }
+{
+  // see header file for class documentation
+  return 32;
+}
 
 
-Bool_t AliHLTTPCDigitReaderRaw::ApplyMapping(){
+Bool_t AliHLTTPCDigitReaderRaw::ApplyMapping()
+{
+  // see header file for class documentation
 
 #ifndef HAVE_TPC_MAPPING
   if (fMapErrThrown++==0) {
@@ -566,7 +637,7 @@ Bool_t AliHLTTPCDigitReaderRaw::ApplyMapping(){
   }
   return -1;
 #endif //#ifndef HAVE_TPC_MAPPING
-    if ( (unsigned)fAltroBlockHWAddress > fMaxHWA[fPatch]){
+    if ( (unsigned)fAltroBlockHWAddress > fgMaxHWA[fPatch]){
        fPad = -1;
        fRow = -1;
        return kFALSE;
@@ -574,33 +645,33 @@ Bool_t AliHLTTPCDigitReaderRaw::ApplyMapping(){
 
     switch(fPatch){
        case 0:
-           fRow = fMapping0[(unsigned)fAltroBlockHWAddress][0];
-           fPad = fMapping0[(unsigned)fAltroBlockHWAddress][1];
+           fRow = fgMapping0[(unsigned)fAltroBlockHWAddress][0];
+           fPad = fgMapping0[(unsigned)fAltroBlockHWAddress][1];
            break;
         case 1:
-           fRow = AliHLTTPCDigitReaderRaw::fMapping1[(unsigned)fAltroBlockHWAddress][0];
-           fPad = AliHLTTPCDigitReaderRaw::fMapping1[(unsigned)fAltroBlockHWAddress][1];
+           fRow = AliHLTTPCDigitReaderRaw::fgMapping1[(unsigned)fAltroBlockHWAddress][0];
+           fPad = AliHLTTPCDigitReaderRaw::fgMapping1[(unsigned)fAltroBlockHWAddress][1];
 #if 0
-           printf ("pad %d # row %d (hwa: %u / 0x%08X\n", fMapping1[(unsigned)fAltroBlockHWAddress][0],fMapping1[(unsigned)fAltroBlockHWAddress][1], (unsigned)fAltroBlockHWAddress, (unsigned)fAltroBlockHWAddress);
-           printf ("pad %d # row %d (hwa: %u / 0x%08X\n", fMapping1[(unsigned)fAltroBlockHWAddress-1][0],fMapping1[(unsigned)fAltroBlockHWAddress-1][1], (unsigned)fAltroBlockHWAddress-1, (unsigned)fAltroBlockHWAddress-1);
-           printf ("pad %d # row %d (hwa: %u / 0x%08X\n", fMapping1[(unsigned)fAltroBlockHWAddress+1][0],fMapping1[(unsigned)fAltroBlockHWAddress+1][1], (unsigned)fAltroBlockHWAddress+1, (unsigned)fAltroBlockHWAddress+1);
+           printf ("pad %d # row %d (hwa: %u / 0x%08X\n", fgMapping1[(unsigned)fAltroBlockHWAddress][0],fgMapping1[(unsigned)fAltroBlockHWAddress][1], (unsigned)fAltroBlockHWAddress, (unsigned)fAltroBlockHWAddress);
+           printf ("pad %d # row %d (hwa: %u / 0x%08X\n", fgMapping1[(unsigned)fAltroBlockHWAddress-1][0],fgMapping1[(unsigned)fAltroBlockHWAddress-1][1], (unsigned)fAltroBlockHWAddress-1, (unsigned)fAltroBlockHWAddress-1);
+           printf ("pad %d # row %d (hwa: %u / 0x%08X\n", fgMapping1[(unsigned)fAltroBlockHWAddress+1][0],fgMapping1[(unsigned)fAltroBlockHWAddress+1][1], (unsigned)fAltroBlockHWAddress+1, (unsigned)fAltroBlockHWAddress+1);
 #endif
            break;
        case 2:
-           fRow = fMapping2[(unsigned)fAltroBlockHWAddress][0];
-           fPad = fMapping2[(unsigned)fAltroBlockHWAddress][1];
+           fRow = fgMapping2[(unsigned)fAltroBlockHWAddress][0];
+           fPad = fgMapping2[(unsigned)fAltroBlockHWAddress][1];
            break;
         case 3:
-           fRow = fMapping3[(unsigned)fAltroBlockHWAddress][0];
-           fPad = fMapping3[(unsigned)fAltroBlockHWAddress][1];
+           fRow = fgMapping3[(unsigned)fAltroBlockHWAddress][0];
+           fPad = fgMapping3[(unsigned)fAltroBlockHWAddress][1];
            break;
        case 4:
-           fRow = fMapping4[(unsigned)fAltroBlockHWAddress][0];
-           fPad = fMapping4[(unsigned)fAltroBlockHWAddress][1];
+           fRow = fgMapping4[(unsigned)fAltroBlockHWAddress][0];
+           fPad = fgMapping4[(unsigned)fAltroBlockHWAddress][1];
            break;
         case 5:
-           fRow = fMapping5[(unsigned)fAltroBlockHWAddress][0];
-           fPad = fMapping5[(unsigned)fAltroBlockHWAddress][1];
+           fRow = fgMapping5[(unsigned)fAltroBlockHWAddress][0];
+           fPad = fgMapping5[(unsigned)fAltroBlockHWAddress][1];
            break;
        default:
            fRow = -1;
@@ -613,71 +684,81 @@ Bool_t AliHLTTPCDigitReaderRaw::ApplyMapping(){
 
 Int_t AliHLTTPCDigitReaderRaw::GetRow( unsigned patch, unsigned hwAddr )
 {
+  // see header file for class documentation
+
 #ifndef HAVE_TPC_MAPPING
   if (fMapErrThrown++==0) {
     HLTFatal("mapping not available, you must compile with HAVE_TPC_MAPPING");
   }
   return -1;
 #endif //#ifndef HAVE_TPC_MAPPING
-    if ( (unsigned)hwAddr > fMaxHWA[fPatch]){
+    if ( (unsigned)hwAddr > fgMaxHWA[fPatch]){
        return -1;
     }
 
     switch(fPatch){
        case 0:
-           return fMapping0[hwAddr][0];
+           return fgMapping0[hwAddr][0];
         case 1:
-           return fMapping1[hwAddr][0];
+           return fgMapping1[hwAddr][0];
        case 2:
-           return fMapping2[hwAddr][0];
+           return fgMapping2[hwAddr][0];
         case 3:
-           return fMapping3[hwAddr][0];
+           return fgMapping3[hwAddr][0];
        case 4:
-           return fMapping4[hwAddr][0];
+           return fgMapping4[hwAddr][0];
         case 5:
-           return fMapping5[hwAddr][0];
+           return fgMapping5[hwAddr][0];
        default:
          return -1;
     }
 }
+
 Int_t AliHLTTPCDigitReaderRaw::GetPad( unsigned patch, unsigned hwAddr )
 {
+  // see header file for class documentation
+
 #ifndef HAVE_TPC_MAPPING
   if (fMapErrThrown++==0) {
     HLTFatal("mapping not available, you must compile with HAVE_TPC_MAPPING");
   }
   return -1;
 #endif //#ifndef HAVE_TPC_MAPPING
-    if ( (unsigned)hwAddr > fMaxHWA[fPatch]){
+    if ( (unsigned)hwAddr > fgMaxHWA[fPatch]){
        return -1;
     }
 
     switch(fPatch){
        case 0:
-           return fMapping0[hwAddr][1];
+           return fgMapping0[hwAddr][1];
         case 1:
-           return fMapping1[hwAddr][1];
+           return fgMapping1[hwAddr][1];
        case 2:
-           return fMapping2[hwAddr][1];
+           return fgMapping2[hwAddr][1];
         case 3:
-           return fMapping3[hwAddr][1];
+           return fgMapping3[hwAddr][1];
        case 4:
-           return fMapping4[hwAddr][1];
+           return fgMapping4[hwAddr][1];
         case 5:
-           return fMapping5[hwAddr][1];
+           return fgMapping5[hwAddr][1];
        default:
          return -1;
     }
 }
 
-unsigned AliHLTTPCDigitReaderRaw::GetMaxHWA( unsigned patch )
+unsigned AliHLTTPCDigitReaderRaw::GetMaxHWA( unsigned patch ) const
 {
-  if ( (int)patch>=fNofPatches )
+  // see header file for class documentation
+
+  if ( (int)patch>=fgkNofPatches )
     return 0;
-  return fMaxHWA[patch];
+  return fgMaxHWA[patch];
 }
 
-Int_t AliHLTTPCDigitReaderRaw::DecodeMode(Int_t mode) {
+Int_t AliHLTTPCDigitReaderRaw::DecodeMode(Int_t mode) 
+{
+  // see header file for class documentation
+
   Int_t decodedMode;
 
   if ( mode >= kNofRawReaderModes ) 
@@ -688,7 +769,10 @@ Int_t AliHLTTPCDigitReaderRaw::DecodeMode(Int_t mode) {
   return decodedMode;
 }
 
-Int_t AliHLTTPCDigitReaderRaw::DecodeMode(const Char_t *mode) {
+Int_t AliHLTTPCDigitReaderRaw::DecodeMode(const Char_t *mode) 
+{
+  // see header file for class documentation
+
   Int_t decodedMode;
   Char_t *cpErr;
 
@@ -737,11 +821,11 @@ Int_t AliHLTTPCDigitReaderRaw::DecodeMode(const Char_t *mode) {
 #include "mapping_array_out.inc"
 #else
 // dummy definitions in case of missing mapping
-unsigned AliHLTTPCDigitReaderRaw::fMaxHWA[fNofPatches];
-Int_t AliHLTTPCDigitReaderRaw::fMapping0[fMapping0Size][fMappingDimension];
-Int_t AliHLTTPCDigitReaderRaw::fMapping1[fMapping1Size][fMappingDimension];
-Int_t AliHLTTPCDigitReaderRaw::fMapping2[fMapping2Size][fMappingDimension];
-Int_t AliHLTTPCDigitReaderRaw::fMapping3[fMapping3Size][fMappingDimension];
-Int_t AliHLTTPCDigitReaderRaw::fMapping4[fMapping4Size][fMappingDimension];
-Int_t AliHLTTPCDigitReaderRaw::fMapping5[fMapping5Size][fMappingDimension];
+unsigned AliHLTTPCDigitReaderRaw::fgMaxHWA[fgkNofPatches];
+Int_t AliHLTTPCDigitReaderRaw::fgMapping0[fgkMapping0Size][fgkMappingDimension];
+Int_t AliHLTTPCDigitReaderRaw::fgMapping1[fgkMapping1Size][fgkMappingDimension];
+Int_t AliHLTTPCDigitReaderRaw::fgMapping2[fgkMapping2Size][fgkMappingDimension];
+Int_t AliHLTTPCDigitReaderRaw::fgMapping3[fgkMapping3Size][fgkMappingDimension];
+Int_t AliHLTTPCDigitReaderRaw::fgMapping4[fgkMapping4Size][fgkMappingDimension];
+Int_t AliHLTTPCDigitReaderRaw::fgMapping5[fgkMapping5Size][fgkMappingDimension];
 #endif //#if defined(HAVE_TPC_MAPPING)
index 92b0d42..6dd5d4e 100644 (file)
@@ -67,9 +67,9 @@ public:
    */
   AliHLTTPCDigitReaderRaw( unsigned formatVersion );
   /** not a valid copy constructor, defined according to effective C++ style */
-  AliHLTTPCDigitReaderRaw(const AliHLTTPCDigitReaderRaw&);
+  AliHLTTPCDigitReaderRaw(const AliHLTTPCDigitReaderRaw& src);
   /** not a valid assignment op, but defined according to effective C++ style */
-  AliHLTTPCDigitReaderRaw& operator=(const AliHLTTPCDigitReaderRaw&);
+  AliHLTTPCDigitReaderRaw& operator=(const AliHLTTPCDigitReaderRaw& src);
   /** destructor */
   virtual ~AliHLTTPCDigitReaderRaw();
     
@@ -119,36 +119,58 @@ public:
     return fVerify;
   }
 
+  //
   // Deliver values unsorted
-    bool RealNext();
-    int GetRealRow();
-    int GetRealPad();
-    int GetRealSignal();
-    int GetRealTime();
-
+  //
+  /** unsorted next value */
+  bool RealNext();
+  /** row of current value */
+  int GetRealRow() const;
+  /** pad of current value */
+  int GetRealPad() const;
+  /** signal of current value */
+  int GetRealSignal();
+  /** time of current value */
+  int GetRealTime() const;
+
+  //
   // Low level methods for accessing the data
-    AliHLTUInt32_t GetRCUTrailer( unsigned offset=0 );
-    bool NextAltroBlock();
-    AliHLTUInt32_t GetAltroBlockHWaddr();
-    unsigned GetAltroBlock10BitWordCnt();
-    AliHLTUInt64_t GetAltroBlock40BitWord( unsigned long ndx ); // ndx counts from end, 0 is last
-    AliHLTUInt16_t GetAltroBlock10BitWord( unsigned long ndx );
-    AliHLTUInt16_t GetAltroBlockReal10BitWord( unsigned long ndx );
+  //
+  /** get rcu trailer word of the raw data */
+  AliHLTUInt32_t GetRCUTrailer( unsigned offset=0 ) const;
+
+  /** move to next altro block and set internal variables */
+  bool NextAltroBlock();
+
+  /** hardware address of the current altro block */
+  AliHLTUInt32_t GetAltroBlockHWaddr() const;
+
+  /** get no of 10bit words in the current altro block */
+  unsigned GetAltroBlock10BitWordCnt() const;
+
+  /** ndx counts from end, 0 is last */
+  AliHLTUInt64_t GetAltroBlock40BitWord( unsigned long ndx ) const;
+
+  /** ndx counts from end, 0 is last */
+  AliHLTUInt16_t GetAltroBlock10BitWord( unsigned long ndx );
+
+  /** ndx counts from end, 0 is last */
+  AliHLTUInt16_t GetAltroBlockReal10BitWord( unsigned long ndx );
 
     unsigned GetAltroBlockPositionBytes() const
        {return fAltroBlockPositionBytes;}
     unsigned GetAltroBlockLengthBytes() const
        {return fAltroBlockLengthBytes;}
 
-    // Return length of trailing RCU data block in bytes
+    /** Return length of trailing RCU data block in bytes */
     unsigned GetRCUDataBlockLength() const;
     unsigned GetCommonDataHeaderSize() const;
        
     Bool_t ApplyMapping();
 
-  Int_t GetRow( unsigned patch, unsigned hw_addr );
-  Int_t GetPad( unsigned patch, unsigned hw_addr );
-  unsigned GetMaxHWA( unsigned patch );
+  Int_t GetRow( unsigned patch, unsigned hwAddr );
+  Int_t GetPad( unsigned patch, unsigned hwAddr );
+  unsigned GetMaxHWA( unsigned patch ) const;
 
   /**
    * This function decodes the rawreadermode set in HLT***Components
@@ -175,66 +197,91 @@ public:
 
 protected:
 
-  AliHLTUInt8_t* fBuffer; //! transient value
-  unsigned long fBufferSize;
+  /** the raw data buffer (external buffer) */
+  AliHLTUInt8_t* fBuffer;                                          //! transient
+  /** size of the raw data buffer */
+  unsigned long fBufferSize;                                       // see above
     /*
     Int_t fFirstRow;
     Int_t fLastRow;
     */
-  Int_t fPatch;
-  Int_t fSlice;
-  Int_t fRow;
-  Int_t fPad;
 
-  unsigned fAltroBlockPositionBytes;
-  unsigned fAltroBlockLengthBytes;
-  
-  AliHLTUInt16_t fAltroBlockHWAddress;
-  AliHLTUInt16_t fAltroBlock10BitWordCnt;
-  AliHLTUInt16_t fAltroBlock10BitFillWordCnt;
+  /** patch (readout partition) specification of the raw data buffer */
+  Int_t fPatch;                                                    // see above
+
+  /** slice (sector) specification of the raw data buffer */
+  Int_t fSlice;                                                    // see above
 
-  unsigned fDataFormatVersion;
+  /** the current row no */
+  Int_t fRow;                                                      // see above
+
+  /** the current pad no */
+  Int_t fPad;                                                      // see above
+
+
+  /** position of the current ALTRO block*/
+  unsigned fAltroBlockPositionBytes;                               // see above
+
+  /** length of the current ALTRO block*/
+  unsigned fAltroBlockLengthBytes;                                 // see above
   
-  unsigned fBunchPosition;
-  unsigned fBunchTimebinStart;
-  unsigned fBunchLength;
-  unsigned fWordInBunch;
+  /** hardware of the current ALTRO block*/
+  AliHLTUInt16_t fAltroBlockHWAddress;                             // see above
+
+  /** no of 10 bit words in the current ALTRO block*/
+  AliHLTUInt16_t fAltroBlock10BitWordCnt;                          // see above
+
+  /** no of additional 10 bit fill words in the current ALTRO block*/
+  AliHLTUInt16_t fAltroBlock10BitFillWordCnt;                      // see above
+
+  /** version of data format */
+  unsigned fDataFormatVersion;                                     // see above
+
+  /** position of the current bunch of timebins */  
+  unsigned fBunchPosition;                                         // see above
+  /** first timebin of current bunch */  
+  unsigned fBunchTimebinStart;                                     // see above
+  /** length of current bunch */  
+  unsigned fBunchLength;                                           // see above
+  /** word counter in bunch */  
+  unsigned fWordInBunch;                                           // see above
 
-  bool fVerify;
+  /** verify the consistency of the Altro blocks */
+  bool fVerify;                                                    // see above
 
 private:
   /** number of patches */ 
-  static const Int_t fNofPatches=6;
+  static const Int_t fgkNofPatches=6;                              // see above
   /** dimension of each mapping array */ 
-  static const Int_t fMappingDimension=2;
+  static const Int_t fgkMappingDimension=2;                        // see above
 
   /** size of mapping arrays */
-  static const Int_t fMapping0Size=3200;
+  static const Int_t fgkMapping0Size=3200;                         // see above
   /** size of mapping array for patch 1 */
-  static const Int_t fMapping1Size=3584;
+  static const Int_t fgkMapping1Size=3584;                         // see above
   /** size of mapping array for patch 2 */
-  static const Int_t fMapping2Size=3200;
+  static const Int_t fgkMapping2Size=3200;                         // see above
   /** size of mapping array for patch 3 */
-  static const Int_t fMapping3Size=3328;
+  static const Int_t fgkMapping3Size=3328;                         // see above
   /** size of mapping array for patch 4 */
-  static const Int_t fMapping4Size=3328;
+  static const Int_t fgkMapping4Size=3328;                         // see above
   /** size of mapping array for patch 5 */
-  static const Int_t fMapping5Size=3328;
+  static const Int_t fgkMapping5Size=3328;                         // see above
 
   /** mapping array for patch 0 */
-  static Int_t fMapping0[fMapping0Size][fMappingDimension];
+  static Int_t fgMapping0[fgkMapping0Size][fgkMappingDimension];   // see above
   /** mapping array for patch 1 */
-  static Int_t fMapping1[fMapping1Size][fMappingDimension];
+  static Int_t fgMapping1[fgkMapping1Size][fgkMappingDimension];   // see above
   /** mapping array for patch 2 */
-  static Int_t fMapping2[fMapping2Size][fMappingDimension];
+  static Int_t fgMapping2[fgkMapping2Size][fgkMappingDimension];   // see above
   /** mapping array for patch 3 */
-  static Int_t fMapping3[fMapping3Size][fMappingDimension];
+  static Int_t fgMapping3[fgkMapping3Size][fgkMappingDimension];   // see above
   /** mapping array for patch 4 */
-  static Int_t fMapping4[fMapping4Size][fMappingDimension];
+  static Int_t fgMapping4[fgkMapping4Size][fgkMappingDimension];   // see above
   /** mapping array for patch 5 */
-  static Int_t fMapping5[fMapping5Size][fMappingDimension];
+  static Int_t fgMapping5[fgkMapping5Size][fgkMappingDimension];   // see above
 
-  static unsigned fMaxHWA[fNofPatches];
+  static unsigned fgMaxHWA[fgkNofPatches];                         // see above
 
   // For reordering
   /** current row */
index 2a69d86..6a21f9a 100644 (file)
@@ -1,16 +1,26 @@
 // @(#) $Id$
 // Original: AliHLTFitter.cxx,v 1.14 2005/06/14 10:55:21 cvetan 
 
-// Author: Anders Vestbo <mailto:vestbo@fi.uib.no>
-//*-- Copyright &copy ALICE HLT Group 
-
-/** \class AliHLTTPCFitter
-<pre>
-//_____________________________________________________________
-// AliHLTTPCFitter
-//
-// Fit class HLT for helix
-</pre>
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Authors: Anders Vestbo                                                 *
+ *          Matthias Richter <Matthias.Richter@ift.uib.no>                *
+ *          for The ALICE Off-line Project.                               *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/** @file   AliHLTTPCFitter.cxx
+    @author Anders Vestbo, maintained by Matthias Richter
+    @date   
+    @brief  Fit class HLT for helix
 */
 
 #include <math.h>
@@ -31,11 +41,31 @@ ClassImp(AliHLTTPCFitter)
 
 
 AliHLTTPCFitter::AliHLTTPCFitter()
+  :
+  fTrack(NULL),
+  fVertex(NULL),
+  fVertexConstraint(0)
 {
   //constructor
-  fTrack=0;
-  fVertex=0;
   memset(fClusters,0,36*6*sizeof(AliHLTTPCSpacePointData*));
+  memset(fNcl,0,36*6*sizeof(UInt_t));
+}
+
+AliHLTTPCFitter::AliHLTTPCFitter(const AliHLTTPCFitter& src)
+  :
+  fTrack(NULL),
+  fVertex(NULL),
+  fVertexConstraint(0)
+{
+  // dummy copy constructor according to eff C++
+  memset(fClusters,0,36*6*sizeof(AliHLTTPCSpacePointData*));
+  memset(fNcl,0,36*6*sizeof(UInt_t));
+}
+
+AliHLTTPCFitter& AliHLTTPCFitter::operator=(const AliHLTTPCFitter& src)
+{ 
+  // dummy assignment operator according to eff C++
+  return *this;
 }
 
 AliHLTTPCFitter::AliHLTTPCFitter(AliHLTTPCVertex *vertex,Bool_t vertexconstraint)
index bcc93e5..8ece9c8 100644 (file)
@@ -3,22 +3,31 @@
 
 #ifndef ALIHLTTPCFITTER_H
 #define ALIHLTTPCFITTER_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
 
-//_____________________________________________________________
-// AliHLTTPCFitter
-//
-// Fit class HLT
-//
-// Author: Anders Vestbo <mailto:vestbo@fi.uib.no>
+/** @file   AliHLTTPCFitter.h
+    @author Anders Vestbo, maintained by Matthias Richter
+    @date   
+    @brief  Fit class HLT for helix
+*/
 
 class AliHLTTPCTrack;
 class AliHLTTPCVertex;
 class AliHLTTPCSpacePointData;
 
+/** 
+ * @class AliHLTTPCFitter
+ * Fit class HLT for helix
+ */
 class AliHLTTPCFitter {
 
   public:
   AliHLTTPCFitter();
+  /** not a valid copy constructor, defined according to effective C++ style */
+  AliHLTTPCFitter(const AliHLTTPCFitter& src);
+  /** not a valid assignment op, but defined according to effective C++ style */
+  AliHLTTPCFitter& operator=(const AliHLTTPCFitter& src);
   AliHLTTPCFitter(AliHLTTPCVertex *vertex,Bool_t vertexconstraint=kTRUE);
   virtual ~AliHLTTPCFitter();
   
index f631238..0b1f984 100644 (file)
@@ -79,23 +79,54 @@ using namespace std;
 ClassImp(AliHLTTPCMemHandler)
   
 AliHLTTPCMemHandler::AliHLTTPCMemHandler()
+  :
+  fRowMin(0),
+  fRowMax(0),
+  fSlice(0),
+  fPatch(0),
+  fInBinary(NULL),
+  fOutBinary(NULL),
+  fPt(NULL),
+  fSize(0),
+  fIsRandom(kFALSE),
+  fNRandom(0),
+  fNGenerate(0),
+  fNUsed(0),
+  fNDigits(0),
+  fDPt(NULL),
+  fRandomDigits(NULL),
+  fDummy(0)
 { 
   //Constructor
-  fPt = 0;
-  fSize =0;
-  fInBinary = 0;
-  fOutBinary = 0;
-  fNRandom = 0;
   Init(0,0);
-  fIsRandom = kFALSE;
-  fRandomDigits = 0;
-  fDPt =0;
-  fNGenerate = 0;
-  fNUsed = 0;
-  fNDigits = 0;
   ResetROI();
 }
 
+AliHLTTPCMemHandler::AliHLTTPCMemHandler(const AliHLTTPCMemHandler& src)
+  :
+  fRowMin(0),
+  fRowMax(0),
+  fSlice(0),
+  fPatch(0),
+  fInBinary(NULL),
+  fOutBinary(NULL),
+  fPt(NULL),
+  fSize(0),
+  fIsRandom(kFALSE),
+  fNRandom(0),
+  fNGenerate(0),
+  fNUsed(0),
+  fNDigits(0),
+  fDPt(NULL),
+  fRandomDigits(NULL),
+  fDummy(0)
+{
+}
+
+AliHLTTPCMemHandler& AliHLTTPCMemHandler::operator=(const AliHLTTPCMemHandler& src)
+{
+  return (*this);
+}
 
 AliHLTTPCMemHandler::~AliHLTTPCMemHandler()
 {
index 1ef6bbd..f9254f1 100644 (file)
@@ -32,9 +32,8 @@ class AliHLTTPCMemHandler {
  public:
   AliHLTTPCMemHandler();
   virtual ~AliHLTTPCMemHandler();
-  AliHLTTPCMemHandler(const AliHLTTPCMemHandler& /*m*/){};
-  AliHLTTPCMemHandler& operator=(const AliHLTTPCMemHandler& /*&m*/)
-    {return (*this);}
+  AliHLTTPCMemHandler(const AliHLTTPCMemHandler& src);
+  AliHLTTPCMemHandler& operator=(const AliHLTTPCMemHandler& src);
    
   void Reset(){CloseBinaryInput();CloseBinaryOutput();Free();}  
   void Init(Int_t s,Int_t p, Int_t *r=0);
index 77275b8..8720606 100644 (file)
@@ -47,61 +47,92 @@ AliHLTTPCSliceTrackerComponent gAliHLTTPCSliceTrackerComponent;
 ClassImp(AliHLTTPCSliceTrackerComponent)
 
 AliHLTTPCSliceTrackerComponent::AliHLTTPCSliceTrackerComponent()
-    {
-    fTracker = NULL;
-    fVertex = NULL;
-    fEta[0] = 0.;
-    fEta[1] = 1.1;
-    fDoNonVertex = false;
-    fMultiplicity = 4000;
-    fBField = 0.4;
-    fDoPP = false;
+  :
+  fTracker(NULL),
+  fVertex(NULL),
+  fDoNonVertex(false),
+  fMultiplicity(4000),
+  fBField(0.4),
+  fDoPP(false),
 // BEGINN ############################################## MODIFIY JMT
-    fnonvertextracking = kFALSE;   // enable NONVERTEX Tracking
-    fmainvertextracking = kTRUE;   // enable MAINVERTEX Tracking
+  fnonvertextracking(kFALSE),
+  fmainvertextracking(kTRUE)
 // END ################################################# MODIFIY JMT
-    }
+{
+  // see header file for class documentation
+  // or
+  // refer to README to build package
+  // or
+  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
+  fEta[0] = 0.;
+  fEta[1] = 1.1;
+}
+
+AliHLTTPCSliceTrackerComponent::AliHLTTPCSliceTrackerComponent(const AliHLTTPCSliceTrackerComponent& src)
+  :
+  fTracker(NULL),
+  fVertex(NULL),
+  fDoNonVertex(false),
+  fMultiplicity(4000),
+  fBField(0.4),
+  fDoPP(false),
+// BEGINN ############################################## MODIFIY JMT
+  fnonvertextracking(kFALSE),
+  fmainvertextracking(kTRUE)
+// END ################################################# MODIFIY JMT
+{
+  // see header file for class documentation
+  HLTFatal("copy constructor untested");
+}
+
+AliHLTTPCSliceTrackerComponent& AliHLTTPCSliceTrackerComponent::operator=(const AliHLTTPCSliceTrackerComponent& src)
+{ 
+  // see header file for class documentation
+  HLTFatal("assignment operator untested");
+  return *this;
+}
 
 AliHLTTPCSliceTrackerComponent::~AliHLTTPCSliceTrackerComponent()
-    {
-    }
+{
+}
 
 // Public functions to implement AliHLTComponent's interface.
 // These functions are required for the registration process
 
 const char* AliHLTTPCSliceTrackerComponent::GetComponentID()
-    {
-    return "TPCSliceTracker";
-    }
+{
+
+  return "TPCSliceTracker";
+}
 
 void AliHLTTPCSliceTrackerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
-    {
-    list.clear();
-    list.push_back( AliHLTTPCDefinitions::gkClustersDataType );
-    list.push_back( AliHLTTPCDefinitions::gkVertexDataType );
-    }
+{
+  list.clear();
+  list.push_back( AliHLTTPCDefinitions::gkClustersDataType );
+  list.push_back( AliHLTTPCDefinitions::gkVertexDataType );
+}
 
 AliHLTComponentDataType AliHLTTPCSliceTrackerComponent::GetOutputDataType()
-    {
-    return AliHLTTPCDefinitions::gkTrackSegmentsDataType;
-    }
+{
+  return AliHLTTPCDefinitions::gkTrackSegmentsDataType;
+}
 
 void AliHLTTPCSliceTrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
-    {
-    // XXX TODO: Find more realistic values.
-    constBase = 0;
-    inputMultiplier = 0.2;
-    }
+{
+  // XXX TODO: Find more realistic values.
+  constBase = 0;
+  inputMultiplier = 0.2;
+}
 
 AliHLTComponent* AliHLTTPCSliceTrackerComponent::Spawn()
-    {
-    return new AliHLTTPCSliceTrackerComponent;
-    }
+{
+  return new AliHLTTPCSliceTrackerComponent;
+}
 
-void AliHLTTPCSliceTrackerComponent::SetTrackerParam(Int_t phi_segments, Int_t eta_segments,
+void AliHLTTPCSliceTrackerComponent::SetTrackerParam(Int_t phiSegments, Int_t etaSegments,
                                   Int_t trackletlength, Int_t tracklength,
                                   Int_t rowscopetracklet, Int_t rowscopetrack,
-                                  Double_t min_pt_fit, Double_t maxangle,
+                                  Double_t minPtFit, Double_t maxangle,
                                   Double_t goodDist, Double_t hitChi2Cut,
                                   Double_t goodHitChi2, Double_t trackChi2Cut,
                                   Int_t maxdist, Double_t maxphi,Double_t maxeta, bool vertexConstraints )
@@ -110,8 +141,8 @@ void AliHLTTPCSliceTrackerComponent::SetTrackerParam(Int_t phi_segments, Int_t e
     //Set parameters input to the tracker
     //If no arguments are given, default parameters will be used
     
-    fTracker->SetNSegments(phi_segments,eta_segments);
-    fTracker->SetMaxDca(min_pt_fit);
+    fTracker->SetNSegments(phiSegments,etaSegments);
+    fTracker->SetMaxDca(minPtFit);
     //   fTracker->MainVertexSettings(trackletlength,tracklength,rowscopetracklet,rowscopetrack);
 
 // BEGINN ############################################## MODIFIY JMT
index be2368b..359c726 100644 (file)
@@ -16,10 +16,16 @@ class AliHLTTPCConfMapper;
 class AliHLTTPCVertex;
 
 class AliHLTTPCSliceTrackerComponent : public AliHLTProcessor
-    {
-    public:
-       AliHLTTPCSliceTrackerComponent();
-       virtual ~AliHLTTPCSliceTrackerComponent();
+{
+public:
+  /** default constructor */
+  AliHLTTPCSliceTrackerComponent();
+  /** not a valid copy constructor, defined according to effective C++ style */
+  AliHLTTPCSliceTrackerComponent(const AliHLTTPCSliceTrackerComponent&);
+  /** not a valid assignment op, but defined according to effective C++ style */
+  AliHLTTPCSliceTrackerComponent& operator=(const AliHLTTPCSliceTrackerComponent&);
+  /** destructor */
+  virtual ~AliHLTTPCSliceTrackerComponent();
 
        // Public functions to implement AliHLTComponent's interface.
        // These functions are required for the registration process
@@ -30,12 +36,12 @@ class AliHLTTPCSliceTrackerComponent : public AliHLTProcessor
        virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
        AliHLTComponent* Spawn();
 
-    protected:
+protected:
        
-       void SetTrackerParam(Int_t phi_segments=50,Int_t eta_segments=100,
+       void SetTrackerParam(Int_t phiSegments=50,Int_t etaSegments=100,
                             Int_t trackletlength=3,Int_t tracklength=5,
                             Int_t rowscopetracklet=2,Int_t rowscopetrack=3,
-                            Double_t min_pt_fit=0,Double_t maxangle=1.31,
+                            Double_t minPtFit=0,Double_t maxangle=1.31,
                             Double_t goodDist=5,Double_t hitChi2Cut=10,
                             Double_t goodHitChi2=20,Double_t trackChi2Cut=50,
                             Int_t maxdist=50,Double_t maxphi=0.1,Double_t maxeta=0.1,
@@ -59,22 +65,29 @@ class AliHLTTPCSliceTrackerComponent : public AliHLTProcessor
                     AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
                     AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks );
        
-    private:
+private:
 
-       AliHLTTPCConfMapper* fTracker;
-       AliHLTTPCVertex* fVertex;
-       Float_t fEta[2];
-       Bool_t fDoNonVertex;
-       Bool_t  fDoPP;
-       Int_t fMultiplicity;
-       Double_t fBField;
+  /** instance of the tracker */
+  AliHLTTPCConfMapper* fTracker;                                   //! transient
+  /** vertex object */
+  AliHLTTPCVertex* fVertex;                                        //! transient
+  /** eta range */
+  Float_t fEta[2];                                                 //  see above
+  /** switch for subsequent non-vertex tracking */
+  Bool_t fDoNonVertex;                                             //  see above
+  /** */
+  Bool_t  fDoPP;                                                   //  see above
+  /** multiplicity estimate */
+  Int_t fMultiplicity;                                             //  see above
+  /** magnetic field */
+  Double_t fBField;                                                //  see above
 
 // BEGINN ############################################## MODIFIY JMT
-       Bool_t fnonvertextracking;   // enable NONVERTEX Tracking
-       Bool_t fmainvertextracking;  // enable MAINVERTEX Tracking
+  Bool_t fnonvertextracking;   // enable NONVERTEX Tracking
+  Bool_t fmainvertextracking;  // enable MAINVERTEX Tracking
 // END ################################################# MODIFIY JMT
 
-       ClassDef(AliHLTTPCSliceTrackerComponent, 0)
+  ClassDef(AliHLTTPCSliceTrackerComponent, 0);
 
-    };
+};
 #endif
index ca08c5a..67858a6 100644 (file)
@@ -43,7 +43,7 @@ int main(){
 
        cout << numberOfChannels[ii] << "  "<< maxHWAddress[ii]<< endl;
        
-       outFile << "Int_t AliHLTTPCDigitReaderRaw::fMapping"<< ii << "["<< maxHWAddress[ii]+1 << "][2] = { " << endl;
+       outFile << "Int_t AliHLTTPCDigitReaderRaw::fgMapping"<< ii << "["<< maxHWAddress[ii]+1 << "][2] = { " << endl;
        tmpPad = new int[maxHWAddress[ii]+1];
        tmpRow = new int[maxHWAddress[ii]+1];
 
@@ -76,7 +76,7 @@ int main(){
        outFile << "};\n" << endl;
     }
 
-    outFile << "unsigned AliHLTTPCDigitReaderRaw::fMaxHWA[6]= {";
+    outFile << "unsigned AliHLTTPCDigitReaderRaw::fgMaxHWA[6]= {";
     for ( int ii=0; ii<6; ii++ )
       {
        outFile << maxHWAddress[ii];
index 5bdf3b4..8ca03e9 100644 (file)
@@ -11,6 +11,7 @@ MODULE_SRCS=  AliHLTComponent.cxx \
                AliHLTConfiguration.cxx \
                AliHLTLogging.cxx \
                AliHLTDataBuffer.cxx \
+               AliHLTConsumerDescriptor.cxx \
                AliHLTDataSource.cxx \
                AliHLTDataSink.cxx \
                AliHLTFilePublisher.cxx \
@@ -28,6 +29,7 @@ CLASS_HDRS:=          AliHLTComponent.h \
                AliHLTTask.h \
                AliHLTLogging.h \
                AliHLTDataBuffer.h \
+               AliHLTConsumerDescriptor.h \
                AliHLTDataSource.h \
                AliHLTDataSink.h \
                AliHLTFilePublisher.h \