- parameter protection in the TPC raw reader class
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 6 Sep 2006 12:52:13 +0000 (12:52 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 6 Sep 2006 12:52:13 +0000 (12:52 +0000)
- TPC digit reader classes fetch row range from AliHLTTPCTransform
- bugfix HLTComponentHandler::CreateComponent: result handling after DoInit
- bugfix ClusterFinder: index check for arrays of fixed size
- base line calculation and zero suppression fully implemented into
  Cluster Finder: new argument 'adc-threshold' for ClusterFinderComponent
- code documetation
- effective C++ corrections

19 files changed:
HLT/BASE/AliHLTComponentHandler.cxx
HLT/ChangeLog
HLT/TPCLib/AliHLTTPCClusterFinder.cxx
HLT/TPCLib/AliHLTTPCClusterFinder.h
HLT/TPCLib/AliHLTTPCClusterFinderComponent.cxx
HLT/TPCLib/AliHLTTPCClusterFinderComponent.h
HLT/TPCLib/AliHLTTPCDigitReader.cxx
HLT/TPCLib/AliHLTTPCDigitReader.h
HLT/TPCLib/AliHLTTPCDigitReaderPacked.cxx
HLT/TPCLib/AliHLTTPCDigitReaderPacked.h
HLT/TPCLib/AliHLTTPCDigitReaderRaw.cxx
HLT/TPCLib/AliHLTTPCDigitReaderRaw.h
HLT/TPCLib/AliHLTTPCDigitReaderUnpacked.cxx
HLT/TPCLib/AliHLTTPCDigitReaderUnpacked.h
HLT/TPCLib/AliHLTTPCDisplay.cxx
HLT/TPCLib/AliHLTTPCPad.cxx
HLT/TPCLib/AliHLTTPCPad.h
HLT/TPCLib/AliHLTTPCTransform.cxx
HLT/TPCLib/AliHLTTPCTransform.h

index 48310998ee8d9a3d01abcf7762de98208719539d..f59b9d4207222402970b53166680ecc3044c0842 100644 (file)
@@ -112,7 +112,11 @@ int AliHLTComponentHandler::CreateComponent(const char* componentID, void* pEnv,
       component=pSample->Spawn();
       if (component) {
        HLTDebug("component \"%s\" created (%p)", componentID, component);
-       component->Init(&fEnvironment, pEnv, argc, argv);
+       if ((iResult=component->Init(&fEnvironment, pEnv, argc, argv))!=0) {
+         HLTError("Initialization of component \"%s\" failed with error %d", componentID, iResult);
+         delete component;
+         component=NULL;
+       }
       } else {
        HLTError("can not spawn component \"%s\"", componentID);
        iResult=-ENOENT;
index f7c88ec7c35e65764c11849768328c01e483f948..e6c1f978621e1093ea39dd1ffd6a238ec2286876 100644 (file)
@@ -1,3 +1,12 @@
+2006-09-06 intermediate
+       - parameter protection in the TPC raw reader class
+       - TPC digit reader classes fetch row range from AliHLTTPCTransform
+       - bugfix HLTComponentHandler::CreateComponent: result handling after DoInit
+       - bugfix ClusterFinder: index check for arrays of fixed size
+       - base line calculation and zero suppression fully implemented into
+         Cluster Finder: new argument 'adc-threshold' for ClusterFinderComponent 
+       - code documetation
+       - effective C++ corrections
 2006-08-31 code from TPC commissioning version merged
        - DigitReaderRaw added with different read modes (sorted/unsorted;
          several data specifications to adapt to the real data)
index 6ceb41895c62f31d87930babe36cc77055a9a8aa..3ad37f0103007a780ddc5434228f99ee73b6ea0d 100644 (file)
@@ -99,6 +99,7 @@ AliHLTTPCClusterFinder::AliHLTTPCClusterFinder()
   :
   fMatch(1),
   fThreshold(10),
+  fSignalThreshold(-1),
   fXYErr(0.2),
   fZErr(0.3),
   fDeconvPad(kTRUE),
@@ -117,6 +118,7 @@ AliHLTTPCClusterFinder::AliHLTTPCClusterFinder(const AliHLTTPCClusterFinder& src
   :
   fMatch(src.fMatch),
   fThreshold(src.fThreshold),
+  fSignalThreshold(src.fSignalThreshold),
   fXYErr(src.fXYErr),
   fZErr(src.fZErr),
   fDeconvPad(src.fDeconvPad),
@@ -134,6 +136,7 @@ AliHLTTPCClusterFinder& AliHLTTPCClusterFinder::operator=(const AliHLTTPCCluster
 {
   fMatch=src.fMatch;
   fThreshold=src.fThreshold;
+  fSignalThreshold=src.fSignalThreshold;
   fXYErr=src.fXYErr;
   fZErr=src.fZErr;
   fDeconvPad=src.fDeconvPad;
@@ -213,9 +216,11 @@ void AliHLTTPCClusterFinder::ProcessDigits()
   fCurrentRow += rowOffset;
 
   UInt_t lastpad = 123456789;
-  AliClusterData *pad1[5000]; //2 lists for internal memory=2pads
-  AliClusterData *pad2[5000]; //2 lists for internal memory=2pads
-  AliClusterData clusterlist[10000]; //Clusterlist
+  const Int_t kPadArraySize=5000;
+  const Int_t kClusterListSize=10000;
+  AliClusterData *pad1[kPadArraySize]; //2 lists for internal memory=2pads
+  AliClusterData *pad2[kPadArraySize]; //2 lists for internal memory=2pads
+  AliClusterData clusterlist[kClusterListSize]; //Clusterlist
 
   AliClusterData **currentPt;  //List of pointers to the current pad
   AliClusterData **previousPt; //List of pointers to the previous pad
@@ -233,7 +238,11 @@ void AliHLTTPCClusterFinder::ProcessDigits()
   Int_t gatingGridOffset=50;
   AliHLTTPCPad baseline(gatingGridOffset, AliHLTTPCTransform::GetNTimeBins());
   // just to make later conversion to a list of objects easier
-  AliHLTTPCPad* pCurrentPad=&baseline;
+  AliHLTTPCPad* pCurrentPad=NULL;
+  if (fSignalThreshold>=0) {
+    pCurrentPad=&baseline;
+    baseline.SetThreshold(fSignalThreshold);
+  }
 
   while ( readValue ){   // Reads through all digits in block
 
@@ -292,7 +301,7 @@ void AliHLTTPCClusterFinder::ProcessDigits()
          }
          pCurrentPad->CalculateBaseLine(AliHLTTPCTransform::GetNTimeBins()/2);
          if (pCurrentPad->Next(kTRUE/*do zero suppression*/)==0) {
-           HLTDebug("no data available after zero suppression");
+           //HLTDebug("no data available after zero suppression");
            pCurrentPad->StopEvent();
            pCurrentPad->ResetHistory();
            break;
@@ -403,7 +412,7 @@ void AliHLTTPCClusterFinder::ProcessDigits()
 
 
     //Compare with results on previous pad:
-    for(UInt_t p=0; p<nprevious; p++){
+    for(UInt_t p=0; p<nprevious && p<kPadArraySize && ncurrent<kPadArraySize; p++){
       
       //dont merge sequences on the same pad twice
       if(previousPt[p]->fLastMergedPad==pad) continue;
@@ -445,7 +454,7 @@ void AliHLTTPCClusterFinder::ProcessDigits()
     } //Loop over results on previous pad.
 
 
-    if(newcluster){
+    if(newcluster && ncurrent<kPadArraySize){
       //Start a new cluster. Add it to the clusterlist, and update
       //the list of pointers to clusters in current pad.
       //current pad will be previous pad on next pad.
@@ -483,6 +492,11 @@ void AliHLTTPCClusterFinder::ProcessDigits()
 
 
     if(!readValue) break; //No more value
+    
+    if (ntotal>=kClusterListSize || ncurrent>=kPadArraySize) {
+      HLTWarning("pad array size exceeded ntotal=%d ncurrent=%d, skip rest of the data", ntotal, ncurrent);
+      break;
+    }
 
     if(fCurrentRow != newRow){
       WriteClusters(ntotal,clusterlist);
@@ -503,8 +517,6 @@ void AliHLTTPCClusterFinder::ProcessDigits()
 
   } // END while(readValue)
 
-  if (pCurrentPad) pCurrentPad->StopEvent();
-
   WriteClusters(ntotal,clusterlist);
 
   HLTInfo("ClusterFinder found %d clusters in slice %d patch %d", fNClusters, fCurrentSlice, fCurrentPatch);
index 135734ddded0bf0f0563a779ac0760da1635e8ad..b262e3c39dab48862f76e7b879b0e30dc1313712 100644 (file)
@@ -47,6 +47,8 @@ class AliHLTTPCClusterFinder : public AliHLTLogging {
   Int_t fCurrentPatch;   //current patch
   Int_t fMatch;          //size of match
   UInt_t fThreshold;     //threshold for clusters
+  /** threshold for zero suppression (applied per bin) */
+  Int_t fSignalThreshold;
   Int_t fNClusters;      //number of found clusters
   Int_t fMaxNClusters;   //max. number of clusters
   Float_t fXYErr;        //fixed error in XY
@@ -79,6 +81,7 @@ class AliHLTTPCClusterFinder : public AliHLTLogging {
   void SetZError(Float_t f) {fZErr=f;}
   void SetDeconv(Bool_t f) {fDeconvPad=f; fDeconvTime=f;}
   void SetThreshold(UInt_t i) {fThreshold=i;}
+  void SetSignalThreshold(Int_t i) {fSignalThreshold=i;}
   void SetMatchWidth(UInt_t i) {fMatch=i;}
   void SetSTDOutput(Bool_t f=kFALSE) {fStdout=f;}  
   void SetCalcErr(Bool_t f=kTRUE) {fCalcerr=f;}
index 51346d15d28dc06ef4e3cd9ecc9f20f2b735b12d..61a036820d405e68d071b96e3bb7113558b9454a 100644 (file)
@@ -126,6 +126,7 @@ int AliHLTTPCClusterFinderComponent::DoInit( int argc, const char** argv )
     fClusterFinder = new AliHLTTPCClusterFinder();
 
     Int_t rawreadermode =  -1;
+    Int_t sigthresh = -1;
 
     // Data Format version numbers:
     // 0: RCU Data format as delivered during TPC commissioning, pads/padrows are sorted, RCU trailer is one 32 bit word.
@@ -180,6 +181,17 @@ int AliHLTTPCClusterFinderComponent::DoInit( int argc, const char** argv )
        continue;
       }
 
+      // -- zero suppression threshold
+      if ( !strcmp( argv[i], "adc-threshold" ) ) {
+       sigthresh = strtoul( argv[i+1], &cpErr ,0);
+       if ( *cpErr ) {
+         HLTError("Cannot convert threshold specifier '%s'.", argv[i+1]);
+         return EINVAL;
+       }
+       i+=2;
+       continue;
+      }
+
       Logging(kHLTLogError, "HLT::TPCClusterFinder::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
       return EINVAL;
 
@@ -222,6 +234,7 @@ int AliHLTTPCClusterFinderComponent::DoInit( int argc, const char** argv )
     fClusterFinder->SetZError( fZClusterError );
     if ( (fXYClusterError>0) && (fZClusterError>0) )
       fClusterFinder->SetCalcErr( false );
+    fClusterFinder->SetSignalThreshold(sigthresh);
     
     return 0;
     }
index e9f4b1fa91ce6b1259a7fa8b59057d9ec749f8bc..b24ddba403b74d6f4efb72b7027a224ffd1fca2d 100644 (file)
 
 class AliHLTTPCClusterFinder;
 
+/**
+ * @class AliHLTTPCClusterFinderComponent
+ * Implementation of the cluster finder component.
+ * The component implements the interface methods of the @ref AliHLTProcessor.
+ * The actual cluster finding algorithm is implemented in @ref AliHLTTPCClusterFinder.
+ * 
+ * The component has the following component arguments:
+ * - rawreadermode   the mode for the @ref AliHLTTPCDigitReaderRaw
+ * - adc-threshold   ADC count threshold for zero suppression, if <0 the base line
+ *                   calculation and subtraction is switched off
+ * - pp-run          set parameters specific to a pp run; currently this switches
+ *                   cluster deconvolution off for pp runs
+ *
+ * @ingroup alihlt_tpc
+ */
 class AliHLTTPCClusterFinderComponent : public AliHLTProcessor
     {
     public:
index 1d6c3782a44516d8347b88427d42516cf1ad3033..43f8f8a5813b11f45141eddbf659cc6ce07e2c40 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-// base class for reading packed and unpacked data for the HLT               //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
+/** @file   AliHLTTPCDigitReader.cxx
+    @author Timm Steinbeck, Jochen Thaeder, Matthias Richter
+    @date   
+    @brief  An abstract reader class for TPC data.
+*/
 
 #if __GNUC__>= 3
 using namespace std;
 #endif
 
 #include "AliHLTTPCDigitReader.h"
+#include "AliHLTTPCTransform.h"
+#include "AliHLTStdIncludes.h"
 
 ClassImp(AliHLTTPCDigitReader)
 
@@ -37,3 +39,19 @@ AliHLTTPCDigitReader::AliHLTTPCDigitReader(){
 AliHLTTPCDigitReader::~AliHLTTPCDigitReader(){
 }
 
+int AliHLTTPCDigitReader::InitBlock(void* ptr,unsigned long size,Int_t firstrow,Int_t lastrow, Int_t patch, Int_t slice){
+  if (patch<0 || patch>=AliHLTTPCTransform::GetNumberOfPatches()) {
+    HLTError("invalid readout partition number %d", patch);
+    return -EINVAL;
+  }
+  if (firstrow!=AliHLTTPCTransform::GetFirstRow(patch)) {
+    HLTWarning("The firstrow parameter does not match the layout of the readout partition %d "
+              "(firstrow=%d). Parameter is ignored", patch, AliHLTTPCTransform::GetFirstRow(patch));
+  }
+  if (lastrow!=AliHLTTPCTransform::GetLastRow(patch)) {
+    HLTWarning("The lastrow parameter does not match the layout of the readout partition %d "
+              "(lastrow=%d). Parameter is ignored", patch, AliHLTTPCTransform::GetLastRow(patch));
+  }
+  return InitBlock(ptr, size, patch, slice);
+}
+
index 83330a46f78962f4cea38520ca3e46cac5b583be..d149f465259ca437aca4e579b21d90363d26ac6c 100644 (file)
@@ -7,22 +7,83 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/* AliHLTTPCDigitReader
- */
+/** @file   AliHLTTPCDigitReaderRaw.h
+    @author Timm Steinbeck, Jochen Thaeder, Matthias Richter
+    @date   
+    @brief  An abstract reader class for TPC data.
+*/
 
 #include "AliHLTLogging.h"
 #include "TObject.h"
 
+/**
+ * @class AliHLTTPCDigitReader
+ * An abstract reader class for the TPC data. The Data is treated as a stream
+ * of data points, each containing row number, pad number, time bin and ADC
+ * value. The class hides the actual encoding of the data stream for the sub-
+ * sequent components like the cluster finder.
+ * @ingroup alihlt_tpc
+ */
 class AliHLTTPCDigitReader : public AliHLTLogging {
 public:
+  /** standard constructor */
   AliHLTTPCDigitReader();
+  /** destructor */
   virtual ~AliHLTTPCDigitReader();
   
-  virtual int InitBlock(void* ptr,unsigned long size,Int_t firstrow,Int_t lastrow, Int_t patch, Int_t slice)=0;
+  /**
+   * Init the reader with a data block.
+   * The function fetches the first and last row for the readout partition
+   * from @ref AliHLTTransform. The method is pure virtual and must be implemented
+   * by the child class.
+   * @param ptr     pointer to data buffer
+   * @param size    size of the data buffer
+   * @param patch   patch (readout partition) number within the slice
+   * @param slice   sector no (0 to 35)
+   */
+  virtual int InitBlock(void* ptr,unsigned long size, Int_t patch, Int_t slice)=0;
+
+  /**
+   * Old Init function.
+   * <b>Note:</b> This method is for backward compatibility only, not for further
+   * use. The <i>firstrow</i> and <i>lastrow</i> parameters are fetched from
+   * @ref AliHLTTPCTransform.
+   *
+   * @param ptr       pointer to data buffer
+   * @param size      size of the data buffer
+   * @param firstrow  first row occuring in the data
+   * @param lastrow   last row occuring in the data
+   * @param patch     patch (readout partition) number within the slice
+   * @param slice     sector no (0 to 35)
+   */
+  int InitBlock(void* ptr,unsigned long size,Int_t firstrow,Int_t lastrow, Int_t patch, Int_t slice);
+
+  /**
+   * Set the reader position to the next value.
+   * If the reader was not yet initialized, initialization is carried out and
+   * the position set to the beginning of the stream (which is in essence the
+   * end of the data block due to the back-linked list).
+   */
   virtual bool Next()=0;
+
+  /**
+   * Get the row number of the current value.
+   */
   virtual int GetRow()=0;
+
+  /**
+   * Get the pad number of the current value.
+   */
   virtual int GetPad()=0;
+
+  /**
+   * Get the current ADC value.
+   */
   virtual int GetSignal()=0;
+
+  /**
+   * Get the time bin of the current value.
+   */
   virtual int GetTime()=0;
 
 protected:
index e3d097d26e0152a44b5c8d28a4b1d6b5f1be4d7f..0e3c45fbd9bdb86720b297d5efbdb34983eebad3 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-// class for reading packed data for the HLT                                 //
-// includes reordering of the pads                                           //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
-
+/** @file   AliHLTTPCDigitReaderPacked.cxx
+    @author Timm Steinbeck, Jochen Thaeder, Matthias Richter
+    @date   
+    @brief  A digit reader implementation for simulated, packed TPC 'raw' data.
+*/
 
 #if __GNUC__>= 3
 using namespace std;
@@ -43,27 +41,33 @@ using namespace std;
 
 ClassImp(AliHLTTPCDigitReaderPacked)
 
-AliHLTTPCDigitReaderPacked::AliHLTTPCDigitReaderPacked(){
+AliHLTTPCDigitReaderPacked::AliHLTTPCDigitReaderPacked()
+  :
+#if ENABLE_PAD_SORTING
+  fCurrentRow(0),
+  fCurrentPad(0),
+  fCurrentBin(-1),
+  fNRows(0),
+  fRowOffset(0),
+  fNMaxRows(0),
+  fNMaxPads(0),
+  fNTimeBins(0),
+  fData(NULL),
+#endif // ENABLE_PAD_SORTING  
+  fRawMemoryReader(NULL),
+  fTPCRawStream(NULL)
+{
   fRawMemoryReader = new AliRawReaderMemory;
   
   fTPCRawStream = new AliTPCRawStream( fRawMemoryReader );
 
 #if ENABLE_PAD_SORTING
-  fCurrentRow = 0;
-  fCurrentPad = 0;
-  fCurrentBin = -1;
-
-  fNRows = 0;
-  fRowOffset = 0;
-
   // get max number of rows
-  fNMaxRows = 0;
   for (Int_t ii=0; ii < 6; ii++)
       if (AliHLTTPCTransform::GetNRows(ii) > fNMaxRows) 
          fNMaxRows = AliHLTTPCTransform::GetNRows(ii);
 
   // get max number of pads
-  fNMaxPads = 0;
   for (Int_t ii=0; ii < AliHLTTPCTransform::GetNRows();ii++ )
       if (AliHLTTPCTransform::GetNPads(ii) > fNMaxPads) 
          fNMaxPads = AliHLTTPCTransform::GetNPads(ii);
@@ -71,7 +75,7 @@ AliHLTTPCDigitReaderPacked::AliHLTTPCDigitReaderPacked(){
   // get max number of bins
   fNTimeBins = AliHLTTPCTransform::GetNTimeBins();
 
-  HLTDebug("||| MAXPAD=%d ||| MAXROW=%d ||| MAXBIN=%d ||| MAXMUL=%d", 
+  HLTDebug("Array Borders  ||| MAXPAD=%d ||| MAXROW=%d ||| MAXBIN=%d ||| MAXMUL=%d", 
           fNMaxPads, fNMaxRows, fNTimeBins, fNTimeBins*fNMaxRows*fNMaxPads);
 
   // init Data array
@@ -79,6 +83,44 @@ AliHLTTPCDigitReaderPacked::AliHLTTPCDigitReaderPacked(){
 #endif // ENABLE_PAD_SORTING
 }
 
+AliHLTTPCDigitReaderPacked::AliHLTTPCDigitReaderPacked(const AliHLTTPCDigitReaderPacked& src)
+  :
+#if ENABLE_PAD_SORTING
+  fCurrentRow(0),
+  fCurrentPad(0),
+  fCurrentBin(-1),
+  fNRows(0),
+  fRowOffset(0),
+  fNMaxRows(0),
+  fNMaxPads(0),
+  fNTimeBins(0),
+  fData(NULL),
+#endif // ENABLE_PAD_SORTING  
+  fRawMemoryReader(NULL),
+  fTPCRawStream(NULL)
+{
+  HLTFatal("copy constructor not for use");
+}
+
+AliHLTTPCDigitReaderPacked& AliHLTTPCDigitReaderPacked::operator=(const AliHLTTPCDigitReaderPacked& src)
+{
+#if ENABLE_PAD_SORTING
+  fCurrentRow=0;
+  fCurrentPad=0;
+  fCurrentBin=-1;
+  fNRows=0;
+  fRowOffset=0;
+  fNMaxRows=0;
+  fNMaxPads=0;
+  fNTimeBins=0;
+  fData=NULL;
+#endif // ENABLE_PAD_SORTING  
+  fRawMemoryReader=NULL;
+  fTPCRawStream=NULL;
+  HLTFatal("assignment operator not for use");
+  return (*this);
+}
+
 AliHLTTPCDigitReaderPacked::~AliHLTTPCDigitReaderPacked(){
   if ( fRawMemoryReader )
     delete fRawMemoryReader;
@@ -93,7 +135,7 @@ AliHLTTPCDigitReaderPacked::~AliHLTTPCDigitReaderPacked(){
 #endif // ENABLE_PAD_SORTING
 }
 
-Int_t AliHLTTPCDigitReaderPacked::InitBlock(void* ptr,unsigned long size,Int_t firstrow, Int_t lastrow, Int_t patch, Int_t slice){
+Int_t AliHLTTPCDigitReaderPacked::InitBlock(void* ptr,unsigned long size, Int_t patch, Int_t slice){
 
   fRawMemoryReader->SetMemory( reinterpret_cast<UChar_t*>( ptr ), size );
 
@@ -115,6 +157,8 @@ Int_t AliHLTTPCDigitReaderPacked::InitBlock(void* ptr,unsigned long size,Int_t f
   fCurrentPad = 0;
   fCurrentBin = -1;
 
+  Int_t firstrow=AliHLTTPCTransform::GetFirstRow(patch);
+  Int_t lastrow=AliHLTTPCTransform::GetLastRow(patch);
   fNRows = lastrow - firstrow + 1;
 
   Int_t offset=0;
index b7698b7ca07a6f974520e5a945449423a1110b31..a0eb87c2b90b48f2fd75fae24ef3ceea271c3645 100644 (file)
@@ -4,15 +4,17 @@
 #ifndef ALIHLTTPCDIGITREADERPACKED_H
 #define ALIHLTTPCDIGITREADERPACKED_H
 
-#define ENABLE_PAD_SORTING 1
-
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/* AliHLTTPCDigitReaderPacked
- */
+/** @file   AliHLTTPCDigitReaderPacked.h
+    @author Timm Steinbeck, Jochen Thaeder, Matthias Richter
+    @date   
+    @brief  A digit reader implementation for simulated, packed TPC 'raw' data.
+*/
+
+#define ENABLE_PAD_SORTING 1
 
-#include "AliHLTLogging.h"
 #include "AliHLTTPCDigitReader.h"
 
 #if defined(HAVE_ALIRAWDATA) && defined(HAVE_ALITPCRAWSTREAM_H)
@@ -21,17 +23,38 @@ class AliRawReaderMemory;
 
 class AliTPCRawStream;
 
+/**
+ * @class AliHLTTPCDigitReaderPacked
+ * A digit reader implementation for simulated, packed TPC 'raw' data.
+ * Includes reordering of the pads if @ref ENABLE_PAD_SORTING is 1.
+ * @ingroup alihlt_tpc
+ */
 class AliHLTTPCDigitReaderPacked : public AliHLTTPCDigitReader{
 public:
-    AliHLTTPCDigitReaderPacked(); 
-    virtual ~AliHLTTPCDigitReaderPacked();
+  /** standard constructor */
+  AliHLTTPCDigitReaderPacked(); 
+  /** not a valid copy constructor, defined according to effective C++ style */
+  AliHLTTPCDigitReaderPacked(const AliHLTTPCDigitReaderPacked&);
+  /** not a valid assignment op, but defined according to effective C++ style */
+  AliHLTTPCDigitReaderPacked& operator=(const AliHLTTPCDigitReaderPacked&);
+  /** destructor */
+  virtual ~AliHLTTPCDigitReaderPacked();
   
-  Int_t InitBlock(void* ptr,ULong_t size, Int_t firstrow, Int_t lastrow, Int_t patch, Int_t slice);
-    Bool_t Next();
-    Int_t GetRow();
-    Int_t GetPad();
-    Int_t GetSignal();
-    Int_t GetTime();
+  /**
+   * Init the reader with a data block.
+   * The function fetches the first and last row for the readout partition
+   * from @ref AliHLTTransform.
+   * @param ptr     pointer to data buffer
+   * @param size    size of the data buffer
+   * @param patch   patch (readout partition) number within the slice
+   * @param slice   sector no (0 to 35)
+   */
+  Int_t InitBlock(void* ptr,ULong_t size, Int_t patch, Int_t slice);
+  Bool_t Next();
+  Int_t GetRow();
+  Int_t GetPad();
+  Int_t GetSignal();
+  Int_t GetTime();
     
 protected:
     
index 7e3d8432be00a637084997da2f7c5a1c099d6086..2526cd700e8b575ea0feef583da4ec68b2ff22e0 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-// base class for reading packed and unpacked data for the HLT               //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
+/** @file   AliHLTTPCDigitReaderRaw.cxx
+    @author Timm Steinbeck
+    @date   
+    @brief  A digit reader implementation for the RAW data coming from the RCU.
+*/
 
 #if __GNUC__>= 3
 using namespace std;
@@ -37,32 +37,26 @@ using namespace std;
 
 ClassImp(AliHLTTPCDigitReaderRaw)
 
-  char gTmpHexBuffer[16][128];
-char* AsHex( AliHLTUInt64_t value, unsigned off=0 )
+AliHLTTPCDigitReaderRaw::AliHLTTPCDigitReaderRaw( unsigned formatVersion )
+  :
+  fBuffer(NULL),
+  fBufferSize(0),
+  fPatch(-1),
+  fSlice(-1),
+  fDataFormatVersion(formatVersion),
+  fCurrentRow(0),
+  fCurrentPad(0),
+  fCurrentBin(-1),
+  fVerify(false),
+  
+  // For sorting
+  fNRows(0),
+  fRowOffset(0),
+  fNMaxRows(0),
+  fNMaxPads(0),
+  fNTimeBins(0),
+  fData(NULL)
 {
-  sprintf( gTmpHexBuffer[off], "%016LX", (unsigned long long)value );
-  return gTmpHexBuffer[off];
-}
-
-AliHLTTPCDigitReaderRaw::AliHLTTPCDigitReaderRaw( unsigned formatVersion ){
-    fBuffer = NULL;
-    fBufferSize = 0;
-    fPatch = -1;
-    fSlice = -1;
-    fDataFormatVersion = formatVersion;
-    fCurrentRow = 0;
-    fCurrentPad = 0;
-    fCurrentBin = -1;
-    fVerify = false;
-    
-    // For sorting
-    fNRows = 0;
-    fRowOffset = 0;
-    fNMaxRows = 0;
-    fNMaxPads = 0;
-    fNTimeBins = 0;
-    fData = NULL;
-
     if ( fDataFormatVersion==0 || fDataFormatVersion==2 )
       {
        
@@ -79,15 +73,60 @@ AliHLTTPCDigitReaderRaw::AliHLTTPCDigitReaderRaw( unsigned formatVersion ){
        // get max number of bins
        fNTimeBins = AliHLTTPCTransform::GetNTimeBins();
        
-       LOG(AliHLTTPCLog::kDebug,"AliHLTTPCDigitReaderRaw::AliHLTTPCDigitReaderRaw","Array Borders") 
-         << " ||| MAXPAD="   << fNMaxPads  << " ||| MAXROW="  << fNMaxRows 
-         << " ||| MAXBIN="   << fNTimeBins << " ||| MAXMUL="  << fNTimeBins*fNMaxRows*fNMaxPads << ENDLOG;
+       HLTDebug("Array Borders ||| MAXPAD=%d ||| MAXROW=%d ||| MAXBIN=%d ||| MAXMUL=%d", 
+                fNMaxPads, fNMaxRows, fNTimeBins, fNTimeBins*fNMaxRows*fNMaxPads);
        
        // init Data array
        fData = new Int_t[ fNMaxRows*fNMaxPads*fNTimeBins ];
       }
 }
 
+AliHLTTPCDigitReaderRaw::AliHLTTPCDigitReaderRaw(const AliHLTTPCDigitReaderRaw& src)
+  :
+  fBuffer(NULL),
+  fBufferSize(0),
+  fPatch(-1),
+  fSlice(-1),
+  fDataFormatVersion(src.fDataFormatVersion),
+  fCurrentRow(0),
+  fCurrentPad(0),
+  fCurrentBin(-1),
+  fVerify(false),
+  
+  // For sorting
+  fNRows(0),
+  fRowOffset(0),
+  fNMaxRows(0),
+  fNMaxPads(0),
+  fNTimeBins(0),
+  fData(NULL)
+{
+  HLTFatal("copy constructor not for use");
+}
+
+AliHLTTPCDigitReaderRaw& AliHLTTPCDigitReaderRaw::operator=(const AliHLTTPCDigitReaderRaw& src)
+{
+  fBuffer=NULL;
+  fBufferSize=0;
+  fPatch=-1;
+  fSlice=-1;
+  fDataFormatVersion=src.fDataFormatVersion;
+  fCurrentRow=0;
+  fCurrentPad=0;
+  fCurrentBin=-1;
+  fVerify=false;
+  
+  // For sorting
+  fNRows=0;
+  fRowOffset=0;
+  fNMaxRows=0;
+  fNMaxPads=0;
+  fNTimeBins=0;
+  fData=NULL;
+  HLTFatal("assignment operator not for use");
+  return (*this);
+}
+
 AliHLTTPCDigitReaderRaw::~AliHLTTPCDigitReaderRaw(){
   if ( fDataFormatVersion==0 || fDataFormatVersion==2 )
     {
@@ -97,10 +136,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 patch, Int_t slice){
 
     fBuffer = (AliHLTUInt8_t*) ptr;
+    if (fBuffer==NULL) {
+      HLTError("invalid data buffer");
+      return -EINVAL;
+    }
     fBufferSize = size;
+    if (fBufferSize<=0) HLTWarning("no data available: zero length buffer");
     fPatch = patch;
     fSlice = slice;
     fPad = -1;
@@ -115,6 +159,8 @@ int AliHLTTPCDigitReaderRaw::InitBlock(void* ptr,unsigned long size,Int_t firstr
     fBunchLength = 0;
     fWordInBunch = (unsigned)-1;
 
+    Int_t firstrow=AliHLTTPCTransform::GetFirstRow(patch);
+    Int_t lastrow=AliHLTTPCTransform::GetLastRow(patch);
 
     if ( fDataFormatVersion==0 || fDataFormatVersion==2 )
       {
@@ -133,44 +179,49 @@ int AliHLTTPCDigitReaderRaw::InitBlock(void* ptr,unsigned long size,Int_t firstr
        
        // Init array with -1
        memset( fData, 0xFF, sizeof(Int_t)*(fNMaxRows*fNMaxPads*fNTimeBins) );
-       
+
+       const Int_t maxErrorPrintout=20;
+       Int_t errorCount=0;
+       Int_t entryCount=0;
        // read data and fill in array
+
        while( RealNext()){
-         
+
+         entryCount++;
          Int_t row = GetRealRow();
          Int_t pad = GetRealPad();
          Int_t bin = GetRealTime();
          
-//       LOG(AliHLTTPCLog::kFatal,"AliHLTTPCDigitReaderRaw::FILL","Index out of array range") 
-//             << "PAD=" << pad  << " ||| ROW=" << row << " ||| BIN="  <<  bin   <<" ||| OFFSET="<< offset <<" ||| ROWOFFSET="<< fRowOffset << ENDLOG;
+//       HLTFatal("Index out of array range: PAD=%d ||| ROW=%d ||| BIN=%d ||| OFFSET=%d ||| ROWOFFSET=%d", pad, row, bin, offset, fRowOffset);
 
          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){
-           LOG(AliHLTTPCLog::kFatal,"AliHLTTPCDigitReaderRaw::InitBlock","Index out of Range") << "Probably wrong patch!"<< slice << "-" << patch << ENDLOG;
-           LOG(AliHLTTPCLog::kFatal,"AliHLTTPCDigitReaderRaw::FILL","Index out of array range") 
-             << "PAD=" << pad <<"|" << AliHLTTPCTransform::GetNPads(row + offset)
-             << " ||| ROW=" << row <<"|" << firstrow <<"|" << lastrow
-             << " ||| BIN="  <<  bin <<"|" <<  fNTimeBins
-             <<" ||| OFFSET="<< offset <<" ||| ROWOFFSET="<< fRowOffset << ENDLOG;
-
-           if ( row < firstrow || row > lastrow ) 
-             LOG(AliHLTTPCLog::kFatal,"AliHLTTPCDigitReaderRaw::InitBlock","Row out of Range") << firstrow << "<" << row << "<" << lastrow << ENDLOG;
-           if ( pad > AliHLTTPCTransform::GetNPads(row + offset) ) 
-             LOG(AliHLTTPCLog::kFatal,"AliHLTTPCDigitReaderRaw::InitBlock","Pad out of Range") << pad << "<" << AliHLTTPCTransform::GetNPads(row + offset)  << ENDLOG;
-           if ( bin > fNTimeBins )
-             LOG(AliHLTTPCLog::kFatal,"AliHLTTPCDigitReaderRaw::InitBlock","Bin out of Range") << bin << "<" << fNTimeBins << ENDLOG;
-         }
-         else {  
-           if ((row-fRowOffset)*fNMaxPads*fNTimeBins+ pad*fNTimeBins + bin >=  fNMaxRows*fNMaxPads*fNTimeBins ) {
-             LOG(AliHLTTPCLog::kFatal,"AliHLTTPCDigitReaderRaw::FILL","Index out of array range") 
-               << "PAD=" << pad  << " ||| ROW=" << row << " ||| BIN="  <<  bin   <<" ||| OFFSET="<< offset <<" ||| ROWOFFSET="<< fRowOffset << ENDLOG;
-             continue;
+           if (errorCount++<maxErrorPrintout) {
+             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,
+                      offset, fRowOffset);
+
+             if ( row < firstrow || row > lastrow ) 
+               HLTFatal("Row out of range: %d  ( %d to %d)", row, firstrow, lastrow);
+             if ( pad > AliHLTTPCTransform::GetNPads(row + offset) ) 
+               HLTFatal("Pad out of range: %d  (pad count %d)", pad, AliHLTTPCTransform::GetNPads(row + offset));
+             if ( bin > fNTimeBins )
+               HLTFatal("Time bin out of range: %d (bin count %d)", bin, fNTimeBins);
            }
-           else {
-             fData[ (row-fRowOffset)*fNMaxPads*fNTimeBins+ pad*fNTimeBins + bin ] = GetRealSignal() ;
+           continue;
+         } else if ((row-fRowOffset)*fNMaxPads*fNTimeBins+ pad*fNTimeBins + bin >=  fNMaxRows*fNMaxPads*fNTimeBins ) {
+           if (errorCount++<maxErrorPrintout) {
+             HLTFatal("index out of range: PAD=%d ||| ROW=%d ||| BIN=%d ||| OFFSET=%d ||| ROWOFFSET=%d", pad, row, bin, offset, fRowOffset);
            }
+           continue;
+         } else {
+           fData[ (row-fRowOffset)*fNMaxPads*fNTimeBins+ pad*fNTimeBins + bin ] = GetRealSignal() ;
          }
        }
+       if (errorCount>0) {
+         HLTFatal("%d of %d entries out of range", errorCount, entryCount);
+       }
       }
 
     return 0;
@@ -198,7 +249,7 @@ bool AliHLTTPCDigitReaderRaw::Next(){
        }
        
        if (fCurrentRow*fNMaxPads*fNTimeBins+ fCurrentPad*fNTimeBins + fCurrentBin >=  fNMaxRows*fNMaxPads*fNTimeBins ) {
-         LOG(AliHLTTPCLog::kFatal,"AliHLTTPCDigitReaderRaw::NEXT","Overflow") << fCurrentRow << " " << fCurrentPad << " " << fCurrentBin << ENDLOG;
+         HLTFatal("Overflow: fCurrentRow=%d fCurrentPad=%d fCurrentBin=%d", fCurrentRow, fCurrentPad, fCurrentBin);
          readvalue = kFALSE;
          break;
        }
@@ -261,7 +312,7 @@ bool AliHLTTPCDigitReaderRaw::RealNext(){
        fBunchTimebinStart = GetAltroBlock10BitWord( fBunchPosition+1 );
        fWordInBunch = 2;
     }
-//    printf( "%u %u %u %u %u\n", fBunchPosition, fBunchLength, fBunchTimebinStart, fWordInBunch, (unsigned)fAltroBlock10BitWordCnt );
+    //HLTDebug( "%u %u %u %u %u\n", fBunchPosition, fBunchLength, fBunchTimebinStart, fWordInBunch, (unsigned)fAltroBlock10BitWordCnt );
     return true;
 }
 int AliHLTTPCDigitReaderRaw::GetRealRow(){
@@ -274,17 +325,19 @@ int AliHLTTPCDigitReaderRaw::GetRealSignal(){
     return GetAltroBlock10BitWord( fBunchPosition+fWordInBunch );
 }
 int AliHLTTPCDigitReaderRaw::GetRealTime(){
-  //printf( "GetRealTime: %u - %u\n", fBunchTimebinStart, fWordInBunch );
+  //HLTDebug( "GetRealTime: %u - %u\n", fBunchTimebinStart, fWordInBunch );
     return fBunchTimebinStart-(fWordInBunch-2);
 }
 
 AliHLTUInt32_t AliHLTTPCDigitReaderRaw::GetRCUTrailer(){
-unsigned rcuDataBlockLen = GetRCUDataBlockLength(); 
-return *((AliHLTUInt32_t*)(fBuffer+fBufferSize-rcuDataBlockLen));
+  if (fBufferSize<=0) return 0;
+  unsigned rcuDataBlockLen = GetRCUDataBlockLength(); 
+  return *((AliHLTUInt32_t*)(fBuffer+fBufferSize-rcuDataBlockLen));
 }
 
 bool AliHLTTPCDigitReaderRaw::NextAltroBlock()
     {
+    if (fBufferSize<=0) return 0;
     if ( !fAltroBlockLengthBytes )
        {
        // First block in back linked list (last block in memory)
@@ -294,8 +347,7 @@ bool AliHLTTPCDigitReaderRaw::NextAltroBlock()
        {
        if ( fAltroBlockPositionBytes<fAltroBlockLengthBytes+GetCommonDataHeaderSize() )
          {
-           LOG(AliHLTTPCLog::kFatal,"AliHLTTPCDigitReaderRaw::NextAltroBlock","Data Error")
-             << "Inconsistent Data: fAltroBlockPositionBytes: " << AliHLTTPCLog::kDec << fAltroBlockPositionBytes << " - fAltroBlockLengthBytes: " << fAltroBlockLengthBytes << "." << ENDLOG;
+           HLTFatal("Inconsistent Data: fAltroBlockPositionBytes=%d fAltroBlockLengthBytes=%d", fAltroBlockPositionBytes, fAltroBlockLengthBytes);
          }
        if ( fAltroBlockPositionBytes<=fAltroBlockLengthBytes+GetCommonDataHeaderSize() )
            return false; // We have reached the end of the back linked list
@@ -306,9 +358,9 @@ bool AliHLTTPCDigitReaderRaw::NextAltroBlock()
 
       if ( fVerify && ((altroTrailerWord & 0xFFFC000000ULL)!=0xAAA8000000ULL) )
        {
-         LOG(AliHLTTPCLog::kFatal,"AliHLTTPCDigitReaderRaw::NextAltroBlock","Data Error")
-           << "Data inconsistency in Altro Block at byte position 0x" << AsHex( fAltroBlockPositionBytes, 0 ) << " (" << AliHLTTPCLog::kDec
-           << fAltroBlockPositionBytes << "): Expected 0x2AAA in high 14 bits of altro trailer word; Found 0x" << AsHex( ((altroTrailerWord & 0xFFFC000000ULL) >> 26), 1 ) << " (" << AsHex( altroTrailerWord, 2 ) << ")" << "." << ENDLOG;
+         HLTFatal("Data inconsistency in Altro Block at byte position %#x (%d): Expected 0x2AAA in high 14 bits of altro trailer word; Found %#llx (%#llx)",
+                  fAltroBlockPositionBytes, fAltroBlockPositionBytes, 
+                  ((altroTrailerWord & 0xFFFC000000ULL) >> 26), altroTrailerWord);
 
 
          return false;
@@ -316,9 +368,8 @@ bool AliHLTTPCDigitReaderRaw::NextAltroBlock()
 
       if ( fVerify && ((altroTrailerWord & 0x000000F000ULL)!=0x000000A000ULL) )
        {
-         LOG(AliHLTTPCLog::kFatal,"AliHLTTPCDigitReaderRaw::NextAltroBlock","Data Error")
-           << "Data inconsistency in Altro Block at byte position 0x" << AsHex( fAltroBlockPositionBytes, 0 ) << " (" << AliHLTTPCLog::kDec
-           << fAltroBlockPositionBytes << "): Expected 0xA in bits 12-15 of altro trailer word; Found 0x" << AsHex( ((altroTrailerWord & 0x000000F000ULL) >> 12), 1 ) << "." << ENDLOG;
+         HLTFatal("Data inconsistency in Altro Block at byte position %#x (%d): Expected 0xA in bits 12-15 of altro trailer word; Found %#llx .",
+                  fAltroBlockPositionBytes, fAltroBlockPositionBytes,  ((altroTrailerWord & 0x000000F000ULL) >> 12)); 
 
          return false;
        }
@@ -329,11 +380,8 @@ bool AliHLTTPCDigitReaderRaw::NextAltroBlock()
       // ApplyMapping
       if (!ApplyMapping())
        {
-         LOG(AliHLTTPCLog::kFatal,"AliHLTTPCDigitReaderRaw::NextAltroBlock","Mapping Error")
-           << "Mapping failed Patch " << AliHLTTPCLog::kDec << fPatch << " HWA 0x"
-           << AsHex( fAltroBlockHWAddress, 0 ) << " (" << AliHLTTPCLog::kDec
-           << fAltroBlockHWAddress << ") - maxHWA 0x" << AsHex( fMaxHWA[fPatch], 1 )
-           << AliHLTTPCLog::kDec << " (" << fMaxHWA[fPatch] << ")." << ENDLOG;
+         HLTFatal("Mapping failed Patch %d HWA %#x (%d) - maxHWA %#x (%d)",
+                  fPatch, fAltroBlockHWAddress, fAltroBlockHWAddress, fMaxHWA[fPatch], fMaxHWA[fPatch]);
 
        }
 
@@ -352,10 +400,8 @@ bool AliHLTTPCDigitReaderRaw::NextAltroBlock()
          {
            if ( GetAltroBlockReal10BitWord(b)!=0x2AA )
              {
-               LOG(AliHLTTPCLog::kFatal,"AliHLTTPCDigitReaderRaw::NextAltroBlock","Data Error")
-                 << "Data inconsistency in trailing 10 bit fill word of Altro Block at byte position 0x" << AliHLTTPCLog::kHex
-                 << AsHex( fAltroBlockPositionBytes, 0 ) << " (" << AliHLTTPCLog::kDec
-                 << fAltroBlockPositionBytes << "): Expected 0x2AA; Found 0x" << AliHLTTPCLog::kHex << AsHex( GetAltroBlockReal10BitWord(b), 1 ) << "." << ENDLOG;
+               HLTFatal("Data inconsistency in trailing 10 bit fill word of Altro Block at byte position %#x (%d): Expected 0x2AA; Found %#x",
+                        fAltroBlockPositionBytes, fAltroBlockPositionBytes, GetAltroBlockReal10BitWord(b));
                
                return false;
              }
index ac95a51487a22cdbdf4ad854fecaf2c7bf6319e5..28489aeb467030929309a980f4e233a9ed1ab991 100644 (file)
@@ -7,35 +7,66 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/* AliHLTTPCDigitReaderRaw
- */
+/** @file   AliHLTTPCDigitReaderRaw.h
+    @author Timm Steinbeck, Jochen Thaeder, Matthias Richter
+    @date   
+    @brief  A digit reader implementation for the RAW data coming from the RCU.
+*/
 
 #include "TObject.h"
 
-#include "AliHLTLogging.h"
-
 #if defined(HAVE_TPC_MAPPING)
 #include "AliHLTTPCDigitReader.h"
 #include "AliHLTDataTypes.h"
 
-
+/**
+ * @class AliHLTTPCDigitReaderRaw
+ * A digit reader implementation for the RAW data coming from the RCU.
+ * The reader decodes the data package to the level of the ALtro 10 bit words.
+ *
+ * The reader supports the following data format modes:
+ *  - 0: RCU Data format as delivered during TPC commissioning, pads/padrows 
+ *    are sorted, RCU trailer is one 32 bit word.
+ *  - 1: As 0, but pads/padrows are delivered "as is", without sorting
+ *  - 2: As 0, but RCU trailer is 3 32 bit words.
+ *  - 3: As 1, but RCU trailer is 3 32 bit words.
+ * @ingroup alihlt_tpc
+ */
 class AliHLTTPCDigitReaderRaw : public AliHLTTPCDigitReader  {
 public:
-  // Data Format version numbers:
-  // 0: RCU Data format as delivered during TPC commissioning, pads/padrows are sorted, RCU trailer is one 32 bit word.
-  // 1: As 0, but pads/padrows are delivered "as is", without sorting
-  // 2: As 0, but RCU trailer is 3 32 bit words.
-  // 3: As 1, but RCU trailer is 3 32 bit words.
-    AliHLTTPCDigitReaderRaw( unsigned formatVersion );
-    virtual ~AliHLTTPCDigitReaderRaw();
+  /** standard constructor
+   * @param formatVersion  Data Format version numbers:
+   *  - 0: RCU Data format as delivered during TPC commissioning, pads/padrows
+   *    are sorted, RCU trailer is one 32 bit word.
+   *  - 1: As 0, but pads/padrows are delivered "as is", without sorting
+   *  - 2: As 0, but RCU trailer is 3 32 bit words.
+   *  - 3: As 1, but RCU trailer is 3 32 bit words.
+   */
+  AliHLTTPCDigitReaderRaw( unsigned formatVersion );
+  /** not a valid copy constructor, defined according to effective C++ style */
+  AliHLTTPCDigitReaderRaw(const AliHLTTPCDigitReaderRaw&);
+  /** not a valid assignment op, but defined according to effective C++ style */
+  AliHLTTPCDigitReaderRaw& operator=(const AliHLTTPCDigitReaderRaw&);
+  /** destructor */
+  virtual ~AliHLTTPCDigitReaderRaw();
     
-    virtual int InitBlock(void* ptr,unsigned long size,Int_t firstrow,Int_t lastrow, Int_t patch, Int_t slice);
+  /**
+   * Init the reader with a data block.
+   * The function fetches the first and last row for the readout partition
+   * from @ref AliHLTTransform.
+   * @param ptr     pointer to data buffer
+   * @param size    size of the data buffer
+   * @param patch   patch (readout partition) number within the slice
+   * @param slice   sector no (0 to 35)
+   */
+  virtual int InitBlock(void* ptr,unsigned long size, Int_t patch, Int_t slice);
+
   // Deliver values sorted for format 0, otherwise pass through to corresponding *Real* method
-    virtual bool Next();
-    virtual int GetRow();
-    virtual int GetPad();
-    virtual int GetSignal();
-    virtual int GetTime();
+  virtual bool Next();
+  virtual int GetRow();
+  virtual int GetPad();
+  virtual int GetSignal();
+  virtual int GetTime();
 
   bool Verify( bool verify )
   {
index 7c568350145e00fb49382e5956a45d5887356a28..a15efb64184d4c3da35d39b2610704e1694a6830 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-// class for reading unpacked data for the HLT                               //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
+/** @file   AliHLTTPCDigitReaderUnpacked.cxx
+    @author Timm Steinbeck, Jochen Thaeder, Matthias Richter
+    @date   
+    @brief  A digit reader implementation for unpacked TPC data.
+*/
 
 #if __GNUC__== 3
 using namespace std;
@@ -30,25 +30,59 @@ using namespace std;
 #include "AliHLTTPCDigitReaderUnpacked.h"
 #include "AliHLTTPCDigitData.h"
 #include "AliHLTTPCRawDataFormat.h"
+#include "AliHLTTPCTransform.h"
+#include "AliHLTStdIncludes.h"
 
-#include "AliHLTTPCLogging.h"
+ClassImp(AliHLTTPCDigitReaderUnpacked)
 
-#include <stdlib.h>
-#include <errno.h>
+AliHLTTPCDigitReaderUnpacked::AliHLTTPCDigitReaderUnpacked()
+  :
+  fDigitRowData(NULL),
+  fActRowData(NULL),
+  fData(NULL),
+  fPtr(NULL),
+  fSize(0),
+  fBin(0),
+  fRow(0),
+  fFirstRow(0),
+  fLastRow(0)
+{
+}
 
-ClassImp(AliHLTTPCDigitReaderUnpacked)
+AliHLTTPCDigitReaderUnpacked::AliHLTTPCDigitReaderUnpacked(const AliHLTTPCDigitReaderUnpacked& src)
+  :
+  fDigitRowData(NULL),
+  fActRowData(NULL),
+  fData(NULL),
+  fPtr(NULL),
+  fSize(0),
+  fBin(0),
+  fRow(0),
+  fFirstRow(0),
+  fLastRow(0)
+{
+  HLTFatal("copy constructor not for use");
+}
 
-AliHLTTPCDigitReaderUnpacked::AliHLTTPCDigitReaderUnpacked(){
-  fBin = 0;
-  fRow = 0;
-  fFirstRow = 0;
-  fLastRow = 0;
+AliHLTTPCDigitReaderUnpacked& AliHLTTPCDigitReaderUnpacked::operator=(const AliHLTTPCDigitReaderUnpacked& src)
+{
+  fDigitRowData=NULL;
+  fActRowData=NULL;
+  fData=NULL;
+  fPtr=NULL;
+  fSize=0;
+  fBin=0;
+  fRow=0;
+  fFirstRow=0;
+  fLastRow=0;
+  HLTFatal("assignment operator not for use");
+  return (*this);
 }
 
 AliHLTTPCDigitReaderUnpacked::~AliHLTTPCDigitReaderUnpacked(){
 }
 
-int AliHLTTPCDigitReaderUnpacked::InitBlock(void* ptr,unsigned long size, Int_t firstrow, Int_t lastrow, Int_t patch, Int_t slice){
+int AliHLTTPCDigitReaderUnpacked::InitBlock(void* ptr,unsigned long size, Int_t patch, Int_t slice){
   AliHLTTPCUnpackedRawData *tmpptr;
   fPtr = ptr;
   fSize = size;
@@ -59,13 +93,14 @@ int AliHLTTPCDigitReaderUnpacked::InitBlock(void* ptr,unsigned long size, Int_t
 
   fBin = -1;
 
-  fFirstRow = firstrow;
-  fLastRow = lastrow;
+  fFirstRow=AliHLTTPCTransform::GetFirstRow(patch);
+  fLastRow=AliHLTTPCTransform::GetLastRow(patch);
+
   return 0;
   fRow = fFirstRow; 
 
   if ((Int_t)fActRowData->fRow != fRow){
-      LOG(AliHLTTPCLog::kWarning,"AliHLTTPCDigitReaderUnpacked::Next","Digits") << "Row number should match!" << fActRowData->fRow << " " << fRow << ENDLOG;
+      HLTWarning("Row number should match! fActRowData->fRow=%d fRow=%d", fActRowData->fRow, fRow);
   }
 }
 
@@ -99,7 +134,7 @@ bool AliHLTTPCDigitReaderUnpacked::Next(){
     }
     
     if ((Int_t)fActRowData->fRow != fRow){
-      LOG(AliHLTTPCLog::kWarning,"AliHLTTPCDigitReaderUnpacked::Next","Digits") << "Row number should match!" << fActRowData->fRow << " " << fRow << ENDLOG;
+      HLTWarning("Row number should match! fActRowData->fRow=%d fRow=%d", fActRowData->fRow, fRow);
     }
   }
 
index e4e67c98a871fb370d5fb1ea8e4e26f01c9dcd60..c015d0e27c5ba82e7010b8ef22264d709e3de43c 100644 (file)
@@ -7,20 +7,34 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/* AliHLTTPCDigitReaderUnpacked
- */
+/** @file   AliHLTTPCDigitReaderUnpacked.h
+    @author Timm Steinbeck, Jochen Thaeder, Matthias Richter
+    @date   
+    @brief  A digit reader implementation for unpacked TPC data.
+*/
 
 #include "AliHLTTPCDigitReader.h"
 #include "AliHLTTPCDigitData.h"
 
 class AliHLTTPCDigitRowData;
 
+/**
+ * @class AliHLTTPCDigitReaderPacked
+ * A digit reader implementation for unpacked TPC data.
+ * @ingroup alihlt_tpc
+ */
 class AliHLTTPCDigitReaderUnpacked : public AliHLTTPCDigitReader{
 public:
+  /** standard constructor */
   AliHLTTPCDigitReaderUnpacked();
+  /** not a valid copy constructor, defined according to effective C++ style */
+  AliHLTTPCDigitReaderUnpacked(const AliHLTTPCDigitReaderUnpacked&);
+  /** not a valid assignment op, but defined according to effective C++ style */
+  AliHLTTPCDigitReaderUnpacked& operator=(const AliHLTTPCDigitReaderUnpacked&);
+  /** destructor */
   virtual ~AliHLTTPCDigitReaderUnpacked();
   
-  int InitBlock(void* ptr,unsigned long size,Int_t firstrow,Int_t lastrow, Int_t patch, Int_t slice);
+  int InitBlock(void* ptr,unsigned long size, Int_t patch, Int_t slice);
   bool Next();
   int GetRow();
   int GetPad();
@@ -34,7 +48,7 @@ private:
   AliHLTTPCDigitRowData *fDigitRowData; //!
   AliHLTTPCDigitRowData *fActRowData; //!
   AliHLTTPCDigitData *fData; //!
-  void* fPtr;
+  void* fPtr; //!
   unsigned long fSize;
   Int_t fBin;
   Int_t fRow;
index 914a8a6fcba968dd975370e1170bc45e7431944d..e0506319bcec15fcabad5ca777b55bd07871cef2 100644 (file)
@@ -387,7 +387,7 @@ void AliHLTTPCDisplay::SetupHist(){
 // ####################################################################################################
 void AliHLTTPCDisplay::FillPadRow(Int_t patch, ULong_t dataBlock, ULong_t dataLen){
 #if defined(HAVE_ALIRAWDATA) && defined(HAVE_ALITPCRAWSTREAM_H)
-    AliHLTTPCDigitReaderPacked* fDigitReader = new AliHLTTPCDigitReaderPacked();
+    AliHLTTPCDigitReader* digitReader = new AliHLTTPCDigitReaderPacked();
     bool readValue = true;
     Int_t rowOffset = 0;
 
@@ -400,9 +400,9 @@ void AliHLTTPCDisplay::FillPadRow(Int_t patch, ULong_t dataBlock, ULong_t dataLe
 
     // Initialize block for reading packed data
     void* tmpdataBlock = (void*) dataBlock;
-    fDigitReader->InitBlock(tmpdataBlock,dataLen,firstRow,lastRow,patch,0);
+    digitReader->InitBlock(tmpdataBlock,dataLen,firstRow,lastRow,patch,0);
 
-    readValue = fDigitReader->Next();
+    readValue = digitReader->Next();
 
     if (!readValue){   
        LOG(AliHLTTPCLog::kError,"AliHLTTPCDisplay::FillPadRow","Read first value") << "No value in data block" << ENDLOG;
@@ -419,10 +419,10 @@ void AliHLTTPCDisplay::FillPadRow(Int_t patch, ULong_t dataBlock, ULong_t dataLe
        // read number of entries in colorbin
        while ( readValue ){ 
 
-           Int_t row = fDigitReader->GetRow() + rowOffset;
+           Int_t row = digitReader->GetRow() + rowOffset;
            
            if (row == fPadRow){    
-               UInt_t charge = fDigitReader->GetSignal();
+               UInt_t charge = digitReader->GetSignal();
                
                for (UInt_t ii=0;ii < 19;ii++){
                    if ( charge > (ii*15) && charge <= ((ii*15) + 15) ) fcolorbin[ii]++;
@@ -432,7 +432,7 @@ void AliHLTTPCDisplay::FillPadRow(Int_t patch, ULong_t dataBlock, ULong_t dataLe
            }
 
            // read next value
-           readValue = fDigitReader->Next();
+           readValue = digitReader->Next();
       
            if(!readValue) break; //No more value
        } 
@@ -459,21 +459,21 @@ void AliHLTTPCDisplay::FillPadRow(Int_t patch, ULong_t dataBlock, ULong_t dataLe
        fpmarr[19] = new Float_t[fcolorbin[19]*3]; 
        
        // Rewind the raw reader and fill the polymarker3D
-       fDigitReader->InitBlock(tmpdataBlock,dataLen,firstRow,lastRow,patch,0);
+       digitReader->InitBlock(tmpdataBlock,dataLen,firstRow,lastRow,patch,0);
        
-       readValue = fDigitReader->Next();
+       readValue = digitReader->Next();
     } // END if (fSwitch3DPadRow)
 
     // -- Fill Raw Data
     while ( readValue ){ 
 
-       Int_t row = fDigitReader->GetRow() + rowOffset;
+       Int_t row = digitReader->GetRow() + rowOffset;
 
        // select padrow to fill in histogramm
        if (row == fPadRow){    
-           UChar_t pad = fDigitReader->GetPad();
-           UShort_t time = fDigitReader->GetTime();
-           UInt_t charge = fDigitReader->GetSignal();
+           UChar_t pad = digitReader->GetPad();
+           UShort_t time = digitReader->GetTime();
+           UInt_t charge = digitReader->GetSignal();
            Float_t xyz[3];
            fHistraw->Fill(pad,time,charge);
 
@@ -505,15 +505,15 @@ void AliHLTTPCDisplay::FillPadRow(Int_t patch, ULong_t dataBlock, ULong_t dataLe
        }
        
        // read next value
-       readValue = fDigitReader->Next();
+       readValue = digitReader->Next();
       
        //Check where to stop:
        if(!readValue) break; //No more value
     } 
     
-    if ( fDigitReader )
-       delete fDigitReader;
-    fDigitReader = NULL;
+    if ( digitReader )
+       delete digitReader;
+    digitReader = NULL;
 
     AliHLTTPCSpacePointData *points = fClusters[fSlicePadRow][patch];
     if(!points) return;
index 36d35fc8969e2e5546976a05f0bea55fa49027b4..c6f663701398af951bae614bb7821472f17635fc 100644 (file)
@@ -25,6 +25,7 @@ using namespace std;
 
 #include <cerrno>
 #include "AliHLTTPCPad.h"
+#include "AliHLTStdIncludes.h"
 
 /** margin for the base line be re-avaluated */
 #define ALIHLTPAD_BASELINE_MARGIN (2*fAverage)
@@ -42,6 +43,8 @@ AliHLTTPCPad::AliHLTTPCPad()
   fSum(0),
   fBLMax(-1),
   fBLMaxBin(-1),
+  fBLMin(-1),
+  fBLMinBin(-1),
   fCount(0),
   fTotal(0),
   fpRawData(NULL),
@@ -61,6 +64,8 @@ AliHLTTPCPad::AliHLTTPCPad(Int_t offset, Int_t nofBins)
   fSum(0),
   fBLMax(-1),
   fBLMaxBin(-1),
+  fBLMin(-1),
+  fBLMinBin(-1),
   fCount(0),
   fTotal(0),
   fpRawData(NULL),
@@ -80,6 +85,8 @@ AliHLTTPCPad::AliHLTTPCPad(const AliHLTTPCPad& srcPad)
   fSum(0),
   fBLMax(-1),
   fBLMaxBin(-1),
+  fBLMin(-1),
+  fBLMinBin(-1),
   fCount(0),
   fTotal(0),
   fpRawData(NULL),
@@ -116,6 +123,8 @@ Int_t AliHLTTPCPad::StartEvent()
   if (fpRawData==NULL) {
     fBLMax=-1;
     fBLMaxBin=-1;
+    fBLMin=-1;
+    fBLMinBin=-1;
     fSum=0;
     fCount=0;
     fTotal=0;
@@ -139,21 +148,22 @@ Int_t AliHLTTPCPad::CalculateBaseLine(Int_t reqMinCount)
 {
   Int_t iResult=0;
   AliHLTTPCSignal_t avBackup=fAverage;
+  //HLTDebug("reqMinCount=%d fCount=%d fTotal=%d fSum=%d fBLMax=%d fBLMin=%d", reqMinCount, fCount, fTotal, fSum, fBLMax, fBLMin);
   if (fCount>=reqMinCount && fCount>=fTotal/2) {
     fAverage=fCount>0?fSum/fCount:0;
     if (fAverage>0) {
-      HLTDebug("average for current event %f", fAverage);
+      //HLTDebug("average for current event %d (%d - %d)", fAverage, fBLMax, fBLMin);
       fCount=0;fSum=-1;
       if (fBLMax>ALIHLTPAD_BASELINE_MARGIN) {
        // calculate again
-       HLTDebug("maximum value %f exceeds margin for base line %f "
+       HLTDebug("maximum value %d exceeds margin for base line (%d) "
                 "-> re-evaluate base line", fBLMax, ALIHLTPAD_BASELINE_MARGIN);
        if (fpRawData) {
          for (Int_t i=fFirstBLBin; i<fNofBins; i++)
            if (fpRawData[i]>=0) AddBaseLineValue(i, fpRawData[i]);
          if (fCount>0 && fCount>=reqMinCount && fCount>=fTotal/2) {
            fAverage=fSum/fCount;
-           HLTDebug("new average %f", fAverage);
+           HLTDebug("new average %d", fAverage);
          } else {
            HLTDebug("baseline re-eveluation skipped because of to few "
                       "contributing bins: total=%d, contributing=%d, req=%d"
@@ -170,7 +180,7 @@ Int_t AliHLTTPCPad::CalculateBaseLine(Int_t reqMinCount)
       if (iResult>=0) {
        // calculate average for all events
        fAverage=((avBackup*fNofEvents)+fAverage)/(fNofEvents+1);
-       HLTDebug("base line average for %d events: %f", fNofEvents+1, fAverage);
+       //HLTDebug("base line average for %d event(s): %d", fNofEvents+1, fAverage);
       } else {
        fAverage=avBackup;      
       }
@@ -232,9 +242,15 @@ Int_t AliHLTTPCPad::AddBaseLineValue(Int_t bin, AliHLTTPCSignal_t value)
        fBLMax=value;
        fBLMaxBin=bin;
       }
+      if (fBLMin<0 || fBLMin>value) {
+       // keep the minimum value for later quality control of the base 
+       // line calculation
+       fBLMin=value;
+       fBLMinBin=bin;
+      }
     } else {
-      HLTDebug("ignoring value %f of bin %d for base line calculation "
-              "- average %f",
+      HLTDebug("ignoring value %d (bin %d) for base line calculation "
+              "(current average is %d)",
               value, bin, fAverage);
     }
   }
@@ -252,7 +268,7 @@ Int_t AliHLTTPCPad::SetRawData(Int_t bin, AliHLTTPCSignal_t value)
          fTotal++;
        } else {
          // ignore value for average calculation
-         HLTWarning("overriding content of bin %d (%f)", bin, fpRawData[bin]);
+         HLTWarning("overriding content of bin %d (%d)", bin, fpRawData[bin]);
        }
        fpRawData[bin]=value;
       } else {
@@ -310,12 +326,27 @@ AliHLTTPCSignal_t AliHLTTPCPad::GetCorrectedData(Int_t bin) const
   if (fThreshold>0) data-=fThreshold;
   if (data<0) data=0;
   if (bin<fFirstBLBin) data=0;
+  //HLTDebug("fReadPos=%d data=%d threshold=%d raw data=%d base line=%d", fReadPos, data, fThreshold, GetRawData(bin), GetBaseLine(bin));
   return data;
 }
 
 AliHLTTPCSignal_t AliHLTTPCPad::GetBaseLine(Int_t bin) const
 {
-  return fAverage>0?fAverage:0;
+  AliHLTTPCSignal_t val=0;
+  if (fAverage>0) {
+    // we take the minumum value as the base line if it doesn't differ from
+    // the average to much
+    const AliHLTTPCSignal_t kMaxDifference=15;
+    val=fAverage;
+    if ((fAverage-fBLMin)<=kMaxDifference) val=fBLMin;
+    else val>kMaxDifference?val-=kMaxDifference:0;
+  }
+  if (val<0) {
+    // here we should never get
+    val=0;
+    HLTFatal("wrong base line value");
+  }
+  return val;
 }
 
 AliHLTTPCSignal_t AliHLTTPCPad::GetAverage() const
index ccfcae78f6c64c05a878b7b5c8bdc0722686f302..2db9520ce94ddba385f0c501f4b7119181a2feba 100644 (file)
@@ -238,6 +238,10 @@ class AliHLTTPCPad : public AliHLTLogging {
   AliHLTTPCSignal_t fBLMax;
   /** The bin for the maximum bl value within one event */
   Int_t fBLMaxBin;
+  /** The minimum base line value within one event */
+  AliHLTTPCSignal_t fBLMin;
+  /** The bin for the minimum bl value within one event */
+  Int_t fBLMinBin;
   /** The first bin included in the base line calculation */
   Int_t fFirstBLBin;
   /** Number of bins */
index cd8c0ccbc367ca8a3d0a520f8f38d3b8e217b2fb..8a810a509111a0b7431c8b3ba8f16f2eb1ae4789 100644 (file)
@@ -476,7 +476,7 @@ Double_t AliHLTTPCTransform::fgX[159] = { 85.195,
                                     245.930
 };
 
-#if 0
+#if 1
 // New  number of pads changed 2006-04-15 Jochen Thaeder
 // changed according to formula in AliTPCROC.cxx
 // according to real Pad Distribution on build TPC
@@ -1464,6 +1464,10 @@ Int_t AliHLTTPCTransform::GetNPads(Int_t row)
   return fgNPads[row];
 }
 
+Int_t AliHLTTPCTransform::GetNumberOfPatches() {
+  return fgNPatches;
+}
+
 Int_t AliHLTTPCTransform::GetFirstRow(Int_t patch)
 {
   //get first row per patch
index ce30891ee31bbe65e582bc7afe5bad4ab0b9a5c0..375be8140e4d7bac90a10d4a13f42c7983dbe9cd 100644 (file)
@@ -152,6 +152,7 @@ class AliHLTTPCTransform {
   static Double_t ToRad() {return 1./fgkToDeg;}
   static Double_t ToDeg() {return fgkToDeg;}
 
+  static Int_t GetNumberOfPatches();
   static Int_t GetFirstRow(Int_t patch);
   static Int_t GetLastRow(Int_t patch);
   static Int_t GetFirstRowOnDDL(Int_t patch);