corrections to obey coding conventions
authortkuhr <tkuhr@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 14 Nov 2003 12:54:52 +0000 (12:54 +0000)
committertkuhr <tkuhr@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 14 Nov 2003 12:54:52 +0000 (12:54 +0000)
16 files changed:
RAW/AliITSRawStream.cxx
RAW/AliITSRawStream.h
RAW/AliITSRawStreamSDD.cxx
RAW/AliITSRawStreamSDD.h
RAW/AliITSRawStreamSPD.cxx
RAW/AliITSRawStreamSPD.h
RAW/AliITSRawStreamSSD.cxx
RAW/AliITSRawStreamSSD.h
RAW/AliRawReader.cxx
RAW/AliRawReader.h
RAW/AliRawReaderFile.cxx
RAW/AliRawReaderFile.h
RAW/AliRawReaderRoot.cxx
RAW/AliRawReaderRoot.h
RAW/AliTPCRawStream.cxx
RAW/AliTPCRawStream.h

index 733d17b..5f0b47c 100644 (file)
 // This is a base class for reading ITS raw data files and providing
 // information about digits
 //
+// Derived class should implement the Next method.
+//
+// It loops over all ITS digits in the raw data given by the AliRawReader.
+// The Next method goes to the next digit. If there are no digits left
+// it returns kFALSE.
+// Several getters provide information about the current digit.
+//
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "AliITSRawStream.h"
@@ -32,3 +39,17 @@ AliITSRawStream::AliITSRawStream(AliRawReader* rawReader)
   fRawReader = rawReader;
   fModuleID = fPrevModuleID = fCoord1 = fCoord2 = fSignal = -1;
 }
+
+AliITSRawStream::AliITSRawStream(const AliITSRawStream& stream) :
+  TObject(stream)
+{
+  Fatal("AliITSRawStream", "copy constructor not implemented");
+}
+
+AliITSRawStream& AliITSRawStream::operator = (const AliITSRawStream& 
+                                             /* stream */)
+{
+  Fatal("operator =", "assignment operator not implemented");
+  return *this;
+}
+
index 7dffd8d..96c27b0 100644 (file)
@@ -4,21 +4,25 @@
  * See cxx source for full Copyright notice                               */
 
 #include <TObject.h>
-#include "AliRawReader.h"
+
+class AliRawReader;
 
 
 class AliITSRawStream: public TObject {
   public :
     AliITSRawStream(AliRawReader* rawReader);
+    AliITSRawStream(const AliITSRawStream& stream);
+    AliITSRawStream& operator = (const AliITSRawStream& stream);
+    virtual ~AliITSRawStream() {};
 
     virtual Bool_t   Next() = 0;
 
-    inline Int_t     GetModuleID() const {return fModuleID;};
-    inline Int_t     GetPrevModuleID() const {return fPrevModuleID;};
-    inline Bool_t    IsNewModule() const {return fModuleID != fPrevModuleID;};
-    inline Int_t     GetCoord1() const {return fCoord1;};
-    inline Int_t     GetCoord2() const {return fCoord2;};
-    inline Int_t     GetSignal() const {return fSignal;};
+    Int_t            GetModuleID() const {return fModuleID;};
+    Int_t            GetPrevModuleID() const {return fPrevModuleID;};
+    Bool_t           IsNewModule() const {return fModuleID != fPrevModuleID;};
+    Int_t            GetCoord1() const {return fCoord1;};
+    Int_t            GetCoord2() const {return fCoord2;};
+    Int_t            GetSignal() const {return fSignal;};
 
   protected :
     AliRawReader*    fRawReader;    // object for reading the raw data
index 28c0fe6..9dcf42b 100644 (file)
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "AliITSRawStreamSDD.h"
+#include "AliRawReader.h"
 
 ClassImp(AliITSRawStreamSDD)
 
 
-const Int_t AliITSRawStreamSDD::kDDLsNumber;
-const Int_t AliITSRawStreamSDD::kModulesPerDDL;
-const Int_t AliITSRawStreamSDD::kDDLModuleMap[kDDLsNumber][kModulesPerDDL] = {
+const Int_t AliITSRawStreamSDD::fgkDDLsNumber;
+const Int_t AliITSRawStreamSDD::fgkModulesPerDDL;
+const Int_t AliITSRawStreamSDD::fgkDDLModuleMap[fgkDDLsNumber][fgkModulesPerDDL] = {
   {240,241,242,246,247,248,252,253,254,258,259,260,264,265,266,270,271,272,276,277,278,-1},
   {243,244,245,249,250,251,255,256,257,261,262,263,267,268,269,273,274,275,279,280,281,-1},
   {282,283,284,288,289,290,294,295,296,300,301,302,306,307,308,312,313,314,318,319,320,-1},
@@ -58,9 +59,9 @@ Bool_t AliITSRawStreamSDD::Next()
 
   fPrevModuleID = fModuleID;
   if (!fRawReader->ReadNextInt(fData)) return kFALSE;
-  
+
   UInt_t relModuleID = (fData >> 25) & 0x0000007F;
-  fModuleID = kDDLModuleMap[fRawReader->GetDDLID()][relModuleID];
+  fModuleID = fgkDDLModuleMap[fRawReader->GetDDLID()][relModuleID];
   fCoord1 = (fData >> 16) & 0x000001FF;
   fCoord2 = (fData >> 8) & 0x000000FF;
   fSignal = fData & 0x000000FF;
index 74909a9..399ff0a 100644 (file)
@@ -4,23 +4,25 @@
  * See cxx source for full Copyright notice                               */
 
 #include "AliITSRawStream.h"
-#include "AliRawReader.h"
+
+class AliRawReader;
 
 
 class AliITSRawStreamSDD: public AliITSRawStream {
   public :
     AliITSRawStreamSDD(AliRawReader* rawReader);
+    virtual ~AliITSRawStreamSDD() {};
 
     virtual Bool_t   Next();
 
-    inline Int_t     GetAnode() const {return fCoord1;};
-    inline Int_t     GetTime() const {return fCoord2;};
-
-    static const Int_t kDDLsNumber = 12;      // number of DDLs in SDD
-    static const Int_t kModulesPerDDL = 22;   // number of modules in each DDL 
-    static const Int_t kDDLModuleMap[kDDLsNumber][kModulesPerDDL];
+    Int_t            GetAnode() const {return fCoord1;};
+    Int_t            GetTime() const {return fCoord2;};
 
   private :
+    static const Int_t fgkDDLsNumber = 12;      // number of DDLs in SDD
+    static const Int_t fgkModulesPerDDL = 22;   // number of modules in each DDL 
+    static const Int_t fgkDDLModuleMap[fgkDDLsNumber][fgkModulesPerDDL];  // mapping DDL/module -> module number
+
     UInt_t           fData;         // data read for file
 
     ClassDef(AliITSRawStreamSDD, 0) // class for reading ITS SDD raw digits
index d46338f..4d6ca93 100644 (file)
@@ -21,6 +21,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "AliITSRawStreamSPD.h"
+#include "AliRawReader.h"
 
 ClassImp(AliITSRawStreamSPD)
 
index 47f1200..acc1f15 100644 (file)
@@ -9,11 +9,12 @@
 class AliITSRawStreamSPD: public AliITSRawStream {
   public :
     AliITSRawStreamSPD(AliRawReader* rawReader);
+    virtual ~AliITSRawStreamSPD() {};
 
     virtual Bool_t   Next();
 
-    inline Int_t     GetRow() const {return fCoord1;};
-    inline Int_t     GetColumn() const {return fCoord2;};
+    Int_t            GetRow() const {return fCoord1;};
+    Int_t            GetColumn() const {return fCoord2;};
 
   private :
     UShort_t         fData;         // data read for file
index f8bbc84..fe7cfb5 100644 (file)
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "AliITSRawStreamSSD.h"
+#include "AliRawReader.h"
 
 ClassImp(AliITSRawStreamSSD)
 
 
-const Int_t AliITSRawStreamSSD::kDDLsNumber;
-const Int_t AliITSRawStreamSSD::kModulesPerDDL;
-const Int_t AliITSRawStreamSSD::kDDLModuleMap[kDDLsNumber][kModulesPerDDL] = {
+const Int_t AliITSRawStreamSSD::fgkDDLsNumber;
+const Int_t AliITSRawStreamSSD::fgkModulesPerDDL;
+const Int_t AliITSRawStreamSSD::fgkDDLModuleMap[fgkDDLsNumber][fgkModulesPerDDL] = {
     //104
     //DDL[32][]=
     { 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510,
@@ -225,7 +226,7 @@ Bool_t AliITSRawStreamSSD::Next()
   if (!fRawReader->ReadNextInt(fData)) return kFALSE;
   
   UInt_t relModuleID = (fData >> 21) & 0x000007FF;
-  fModuleID = kDDLModuleMap[fRawReader->GetDDLID()][relModuleID];
+  fModuleID = fgkDDLModuleMap[fRawReader->GetDDLID()][relModuleID];
   fCoord1 = (fData >> 20) & 0x00000001;
   fCoord2 = (fData >> 10) & 0x000003FF;
   fSignal = (fData & 0x000003FF) + 1;
index c1ca960..ba16975 100644 (file)
@@ -4,23 +4,25 @@
  * See cxx source for full Copyright notice                               */
 
 #include "AliITSRawStream.h"
-#include "AliRawReader.h"
+
+class AliRawReader;
 
 
 class AliITSRawStreamSSD: public AliITSRawStream {
   public :
     AliITSRawStreamSSD(AliRawReader* rawReader);
+    virtual ~AliITSRawStreamSSD() {};
 
     virtual Bool_t   Next();
 
-    inline Int_t     GetSideFlag() const {return fCoord1;};
-    inline Int_t     GetStrip() const {return fCoord2;};
-
-    static const Int_t kDDLsNumber = 16;      // number of DDLs in SSD
-    static const Int_t kModulesPerDDL = 109;  // number of modules in each DDL 
-    static const Int_t kDDLModuleMap[kDDLsNumber][kModulesPerDDL];
+    Int_t            GetSideFlag() const {return fCoord1;};
+    Int_t            GetStrip() const {return fCoord2;};
 
   private :
+    static const Int_t fgkDDLsNumber = 16;      // number of DDLs in SSD
+    static const Int_t fgkModulesPerDDL = 109;  // number of modules in each DDL 
+    static const Int_t fgkDDLModuleMap[fgkDDLsNumber][fgkModulesPerDDL];  // mapping DDL/module -> module number
+
     UInt_t           fData;         // data read for file
 
     ClassDef(AliITSRawStreamSSD, 0) // class for reading ITS SSD raw digits
index 609cd28..e830b26 100644 (file)
 // This is the base class for reading raw data and providing
 // information about digits
 //
+// The derived classes, which operate on concrete raw data formats,
+// should implement
+// - ReadMiniHeader to read the next mini header
+// - ReadNextData to read the next raw data block (=1 DDL)
+// - ReadNext to read a given number of bytes
+// - several getters like GetType
+//
+// Sequential access to the raw data is provided by the methods
+// ReadMiniHeader, ReadNextData, ReadNextInt, ReadNextShort, ReadNextChar
+//
+// If only data from a specific detector (and a given range of DDL numbers)
+// should be read, this can be achieved by the Select method.
+// Several getter provide information about the current event and the
+// current type of raw data.
+//
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "AliRawReader.h"
@@ -28,6 +43,8 @@ ClassImp(AliRawReader)
 
 AliRawReader::AliRawReader()
 {
+// default constructor: initialize data members
+
   fMiniHeader = NULL;
   fCount = 0;
 
@@ -36,6 +53,33 @@ AliRawReader::AliRawReader()
   fSelectMaxDDLID = -1;
 }
 
+AliRawReader::AliRawReader(const AliRawReader& rawReader) :
+  TObject(rawReader)
+{
+// copy constructor
+
+  fMiniHeader = rawReader.fMiniHeader;
+  fCount = rawReader.fCount;
+
+  fSelectDetectorID = rawReader.fSelectDetectorID;
+  fSelectMinDDLID = rawReader.fSelectMinDDLID;
+  fSelectMaxDDLID = rawReader.fSelectMaxDDLID;
+}
+
+AliRawReader& AliRawReader::operator = (const AliRawReader& rawReader)
+{
+// assignment operator
+
+  fMiniHeader = rawReader.fMiniHeader;
+  fCount = rawReader.fCount;
+
+  fSelectDetectorID = rawReader.fSelectDetectorID;
+  fSelectMinDDLID = rawReader.fSelectMinDDLID;
+  fSelectMaxDDLID = rawReader.fSelectMaxDDLID;
+
+  return *this;
+}
+
 
 void AliRawReader::Select(Int_t detectorID, Int_t minDDLID, Int_t maxDDLID)
 {
@@ -48,7 +92,7 @@ void AliRawReader::Select(Int_t detectorID, Int_t minDDLID, Int_t maxDDLID)
   fSelectMaxDDLID = maxDDLID;
 }
 
-Bool_t AliRawReader::IsSelected()
+Bool_t AliRawReader::IsSelected() const
 {
 // apply the selection (if any)
 
@@ -63,7 +107,7 @@ Bool_t AliRawReader::IsSelected()
 }
 
 
-Bool_t AliRawReader::CheckMiniHeader()
+Bool_t AliRawReader::CheckMiniHeader() const
 {
 // check the magic number of the mini header
 
index 564524c..7467532 100644 (file)
@@ -4,37 +4,32 @@
  * See cxx source for full Copyright notice                               */
 
 #include <TObject.h>
+#include "AliMiniHeader.h"
 
 
-struct AliMiniHeader {
-  UInt_t    fSize;
-  UChar_t   fDetectorID;
-  UChar_t   fMagicWord[3];
-  UChar_t   fVersion;
-  UChar_t   fCompressionFlag;
-  UShort_t  fDDLID;
-};
-
 class AliRawReader: public TObject {
   public :
     AliRawReader();
+    AliRawReader(const AliRawReader& rawReader);
+    AliRawReader& operator = (const AliRawReader& rawReader);
+    virtual ~AliRawReader() {};
 
     void             Select(Int_t detectorID, 
                            Int_t minDDLID = -1, Int_t maxDDLID = -1);
 
-    virtual UInt_t   GetType() = 0;
-    virtual UInt_t   GetRunNumber() = 0;
-    virtual const UInt_t* GetEventId() = 0;
-    virtual const UInt_t* GetTriggerPattern() = 0;
-    virtual const UInt_t* GetDetectorPattern() = 0;
-    virtual const UInt_t* GetAttributes() = 0;
-    virtual UInt_t   GetGDCId() = 0;
+    virtual UInt_t   GetType() const = 0;
+    virtual UInt_t   GetRunNumber() const = 0;
+    virtual const UInt_t* GetEventId() const = 0;
+    virtual const UInt_t* GetTriggerPattern() const = 0;
+    virtual const UInt_t* GetDetectorPattern() const = 0;
+    virtual const UInt_t* GetAttributes() const = 0;
+    virtual UInt_t   GetGDCId() const = 0;
 
-    inline Int_t     GetDataSize() const {return fMiniHeader->fSize;};
-    inline Int_t     GetDetectorID() const {return fMiniHeader->fDetectorID;};
-    inline Int_t     GetDDLID() const {return fMiniHeader->fDDLID;};
-    inline Int_t     GetVersion() const {return fMiniHeader->fVersion;};
-    inline Bool_t    IsCompressed() const {return fMiniHeader->fCompressionFlag != 0;};
+    Int_t            GetDataSize() const {return fMiniHeader->fSize;};
+    Int_t            GetDetectorID() const {return fMiniHeader->fDetectorID;};
+    Int_t            GetDDLID() const {return fMiniHeader->fDDLID;};
+    Int_t            GetVersion() const {return fMiniHeader->fVersion;};
+    Bool_t           IsCompressed() const {return fMiniHeader->fCompressionFlag != 0;};
 
     virtual Bool_t   ReadMiniHeader() = 0;
     virtual Bool_t   ReadNextData(UChar_t*& data) = 0;
@@ -45,9 +40,9 @@ class AliRawReader: public TObject {
     virtual Bool_t   Reset() = 0;
 
   protected :
-    Bool_t           IsSelected();
+    Bool_t           IsSelected() const;
 
-    Bool_t           CheckMiniHeader();
+    Bool_t           CheckMiniHeader() const;
     virtual Bool_t   ReadNext(UChar_t* data, Int_t size) = 0;
 
     AliMiniHeader*   fMiniHeader;  // current mini header
index fb18b8f..f3b447e 100644 (file)
@@ -49,6 +49,19 @@ AliRawReaderFile::AliRawReaderFile(const char* fileName, Bool_t addNumber)
   fBufferSize = 0;
 }
 
+AliRawReaderFile::AliRawReaderFile(const AliRawReaderFile& rawReader) :
+  AliRawReader(rawReader)
+{
+  Fatal("AliRawReaderFile", "copy constructor not implemented");
+}
+
+AliRawReaderFile& AliRawReaderFile::operator = (const AliRawReaderFile& 
+                                             /* rawReader */)
+{
+  Fatal("operator =", "assignment operator not implemented");
+  return *this;
+}
+
 AliRawReaderFile::~AliRawReaderFile()
 {
 // close the input file
@@ -68,6 +81,9 @@ AliRawReaderFile::~AliRawReaderFile()
 
 Bool_t AliRawReaderFile::OpenNextFile()
 {
+// open the next file
+// returns kFALSE if the current file is the last one
+
   if (fStream) {
 #if defined(__HP_aCC) || defined(__DECCXX)
     if (fStream->rdbuf()->is_open()) fStream->close();
index e261ed7..c4f29d1 100644 (file)
@@ -15,15 +15,17 @@ class fstream;
 class AliRawReaderFile: public AliRawReader {
   public :
     AliRawReaderFile(const char* fileName, Bool_t addNumber = kTRUE);
+    AliRawReaderFile(const AliRawReaderFile& rawReader);
+    AliRawReaderFile& operator = (const AliRawReaderFile& rawReader);
     virtual ~AliRawReaderFile();
 
-    virtual UInt_t   GetType() {return 0;};
-    virtual UInt_t   GetRunNumber() {return 0;};
-    virtual const UInt_t* GetEventId() {return 0;};
-    virtual const UInt_t* GetTriggerPattern() {return 0;};
-    virtual const UInt_t* GetDetectorPattern() {return 0;};
-    virtual const UInt_t* GetAttributes() {return 0;};
-    virtual UInt_t   GetGDCId() {return 0;};
+    virtual UInt_t   GetType() const {return 0;};
+    virtual UInt_t   GetRunNumber() const {return 0;};
+    virtual const UInt_t* GetEventId() const {return 0;};
+    virtual const UInt_t* GetTriggerPattern() const {return 0;};
+    virtual const UInt_t* GetDetectorPattern() const {return 0;};
+    virtual const UInt_t* GetAttributes() const {return 0;};
+    virtual UInt_t   GetGDCId() const {return 0;};
 
 
     virtual Bool_t   ReadMiniHeader();
index bcd41cc..7c87d53 100644 (file)
@@ -21,6 +21,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "AliRawReaderRoot.h"
+#include "AliRawEvent.h"
 
 
 ClassImp(AliRawReaderRoot)
@@ -73,12 +74,40 @@ AliRawReaderRoot::AliRawReaderRoot(AliRawEvent* event)
   fSubEventIndex = 0;
   fSubEvent = NULL;
   fRawData = NULL;
-  fMiniHeader =  NULL;
+  fMiniHeader = NULL;
 
   fCount = 0;
   fPosition = fEnd = NULL;
 }
 
+AliRawReaderRoot::AliRawReaderRoot(const AliRawReaderRoot& rawReader) :
+  AliRawReader(rawReader)
+{
+// copy constructor
+
+  fFile = NULL;
+  fEvent = rawReader.fEvent;
+  
+  fSubEventIndex = rawReader.fSubEventIndex;
+  fSubEvent = rawReader.fSubEvent;
+  fRawData = rawReader.fRawData;
+  fMiniHeader = rawReader.fMiniHeader;
+
+  fCount = rawReader.fCount;
+  fPosition = rawReader.fPosition;
+  fEnd = rawReader.fEnd;
+}
+
+AliRawReaderRoot& AliRawReaderRoot::operator = (const AliRawReaderRoot& 
+                                               rawReader)
+{
+// assignment operator
+
+  this->~AliRawReaderRoot();
+  new(this) AliRawReaderRoot(rawReader);
+  return *this;
+}
+
 AliRawReaderRoot::~AliRawReaderRoot()
 {
 // delete objects and close root file
@@ -91,7 +120,7 @@ AliRawReaderRoot::~AliRawReaderRoot()
 }
 
 
-UInt_t AliRawReaderRoot::GetType()
+UInt_t AliRawReaderRoot::GetType() const
 {
 // get the type from the event header
 
@@ -99,7 +128,7 @@ UInt_t AliRawReaderRoot::GetType()
   return fEvent->GetHeader()->GetType();
 }
 
-UInt_t AliRawReaderRoot::GetRunNumber()
+UInt_t AliRawReaderRoot::GetRunNumber() const
 {
 // get the run number from the event header
 
@@ -107,7 +136,7 @@ UInt_t AliRawReaderRoot::GetRunNumber()
   return fEvent->GetHeader()->GetRunNumber();
 }
 
-const UInt_t* AliRawReaderRoot::GetEventId()
+const UInt_t* AliRawReaderRoot::GetEventId() const
 {
 // get the event id from the event header
 
@@ -115,7 +144,7 @@ const UInt_t* AliRawReaderRoot::GetEventId()
   return fEvent->GetHeader()->GetId();
 }
 
-const UInt_t* AliRawReaderRoot::GetTriggerPattern()
+const UInt_t* AliRawReaderRoot::GetTriggerPattern() const
 {
 // get the trigger pattern from the event header
 
@@ -123,7 +152,7 @@ const UInt_t* AliRawReaderRoot::GetTriggerPattern()
   return fEvent->GetHeader()->GetTriggerPattern();
 }
 
-const UInt_t* AliRawReaderRoot::GetDetectorPattern()
+const UInt_t* AliRawReaderRoot::GetDetectorPattern() const
 {
 // get the detector pattern from the event header
 
@@ -131,7 +160,7 @@ const UInt_t* AliRawReaderRoot::GetDetectorPattern()
   return fEvent->GetHeader()->GetDetectorPattern();
 }
 
-const UInt_t* AliRawReaderRoot::GetAttributes()
+const UInt_t* AliRawReaderRoot::GetAttributes() const
 {
 // get the type attributes from the event header
 
@@ -139,7 +168,7 @@ const UInt_t* AliRawReaderRoot::GetAttributes()
   return fEvent->GetHeader()->GetTypeAttribute();
 }
 
-UInt_t AliRawReaderRoot::GetGDCId()
+UInt_t AliRawReaderRoot::GetGDCId() const
 {
 // get the GDC Id from the event header
 
index 265a7ec..ab98a43 100644 (file)
@@ -3,25 +3,28 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-#include <TObject.h>
-#include <Riostream.h>
-#include "AliRawEvent.h"
 #include "AliRawReader.h"
 
+class AliRawEvent;
+class AliRawData;
+class TFile;
+
 
 class AliRawReaderRoot: public AliRawReader {
   public :
     AliRawReaderRoot(const char* fileName, Int_t eventNumber);
     AliRawReaderRoot(AliRawEvent* event);
+    AliRawReaderRoot(const AliRawReaderRoot& rawReader);
+    AliRawReaderRoot& operator = (const AliRawReaderRoot& rawReader);
     virtual ~AliRawReaderRoot();
 
-    virtual UInt_t   GetType();
-    virtual UInt_t   GetRunNumber();
-    virtual const UInt_t* GetEventId();
-    virtual const UInt_t* GetTriggerPattern();
-    virtual const UInt_t* GetDetectorPattern();
-    virtual const UInt_t* GetAttributes();
-    virtual UInt_t   GetGDCId();
+    virtual UInt_t   GetType() const;
+    virtual UInt_t   GetRunNumber() const;
+    virtual const UInt_t* GetEventId() const;
+    virtual const UInt_t* GetTriggerPattern() const;
+    virtual const UInt_t* GetDetectorPattern() const;
+    virtual const UInt_t* GetAttributes() const;
+    virtual UInt_t   GetGDCId() const;
 
     virtual Bool_t   ReadMiniHeader();
     virtual Bool_t   ReadNextData(UChar_t*& data);
index 2d239f5..2f71b80 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
+/* $Id$ */
+
 ///////////////////////////////////////////////////////////////////////////////
 //
 // This is a base class for reading TPC raw data and providing
 // information about digits
 //
+// It loops over all TPC digits in the raw data given by the AliRawReader.
+// The Next method goes to the next digit. If there are no digits left
+// it returns kFALSE.
+// Several getters provide information about the current digit.
+//
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "AliTPCRawStream.h"
 #include "AliTPCHuffman.h"
+#include "AliRawReader.h"
 
 ClassImp(AliTPCRawStream)
 
@@ -35,18 +43,31 @@ AliTPCRawStream::AliTPCRawStream(AliRawReader* rawReader)
 
   fRawReader = rawReader;
   fRawReader->Select(0);
-  fData = new UShort_t[kDataMax];
+  fData = new UShort_t[fgkDataMax];
   fDataSize = fPosition = 0;
   fCount = fBunchLength = 0;
 
   if (!fgRootNode) {
-    fgRootNode = new AliTPCHNode*[kNumTables];
-    fCompression.CreateTreesFromFile(fgRootNode, kNumTables);
+    fgRootNode = new AliTPCHNode*[fgkNumTables];
+    fCompression.CreateTreesFromFile(fgRootNode, fgkNumTables);
   }
 
   fSector = fPrevSector = fRow = fPrevRow = fPad = fPrevPad = fTime = fSignal = -1;
 }
 
+AliTPCRawStream::AliTPCRawStream(const AliTPCRawStream& stream) :
+  TObject(stream)
+{
+  Fatal("AliTPCRawStream", "copy constructor not implemented");
+}
+
+AliTPCRawStream& AliTPCRawStream::operator = (const AliTPCRawStream& 
+                                             /* stream */)
+{
+  Fatal("operator =", "assignment operator not implemented");
+  return *this;
+}
+
 AliTPCRawStream::~AliTPCRawStream()
 {
 // clean up
@@ -73,7 +94,7 @@ Bool_t AliTPCRawStream::Next()
 
       if (fRawReader->IsCompressed()) {  // compressed data
        UInt_t size = 0;
-       fCompression.Decompress(fgRootNode, kNumTables, 
+       fCompression.Decompress(fgRootNode, fgkNumTables, 
                                (char*) data, fRawReader->GetDataSize(),
                                fData, size);
        fDataSize = size;
@@ -139,7 +160,7 @@ Bool_t AliTPCRawStream::Next()
     Error("Next", "could not read sample amplitude");
     return kFALSE;
   }
-  fSignal = fData[fPosition++] + kOffset;
+  fSignal = fData[fPosition++] + fgkOffset;
   fCount--;
   fBunchLength--;
 
@@ -147,9 +168,10 @@ Bool_t AliTPCRawStream::Next()
 }
 
 
-UShort_t AliTPCRawStream::Get10BitWord(UChar_t* buffer, Int_t position)
-// return a word in a 10 bit array as an UShort_t
+UShort_t AliTPCRawStream::Get10BitWord(UChar_t* buffer, Int_t position) const
 {
+// return a word in a 10 bit array as an UShort_t
+
   Int_t iBit = position * 10;
   Int_t iByte = iBit / 8;
   Int_t shift = iBit % 8;
index 68781aa..1d6d5b6 100644 (file)
@@ -4,45 +4,48 @@
  * See cxx source for full Copyright notice                               */
 
 #include <TObject.h>
-#include "AliRawReader.h"
 #include "AliTPCCompression.h"
 
+class AliRawReader;
+
 
 class AliTPCRawStream: public TObject {
   public :
     AliTPCRawStream(AliRawReader* rawReader);
+    AliTPCRawStream(const AliTPCRawStream& stream);
+    AliTPCRawStream& operator = (const AliTPCRawStream& stream);
     virtual ~AliTPCRawStream();
 
     virtual Bool_t   Next();
 
-    inline Int_t     GetSector() const {return fSector;};
-    inline Int_t     GetPrevSector() const {return fPrevSector;};
-    inline Bool_t    IsNewSector() const {return fSector != fPrevSector;};
-    inline Int_t     GetRow() const {return fRow;};
-    inline Int_t     GetPrevRow() const {return fPrevRow;};
-    inline Bool_t    IsNewRow() const {return (fRow != fPrevRow) || IsNewSector();};
-    inline Int_t     GetPad() const {return fPad;};
-    inline Int_t     GetPrevPad() const {return fPrevPad;};
-    inline Bool_t    IsNewPad() const {return (fPad != fPrevPad) || IsNewRow();};
-    inline Int_t     GetTime() const {return fTime;};
-    inline Int_t     GetSignal() const {return fSignal;};
+    Int_t            GetSector() const {return fSector;};
+    Int_t            GetPrevSector() const {return fPrevSector;};
+    Bool_t           IsNewSector() const {return fSector != fPrevSector;};
+    Int_t            GetRow() const {return fRow;};
+    Int_t            GetPrevRow() const {return fPrevRow;};
+    Bool_t           IsNewRow() const {return (fRow != fPrevRow) || IsNewSector();};
+    Int_t            GetPad() const {return fPad;};
+    Int_t            GetPrevPad() const {return fPrevPad;};
+    Bool_t           IsNewPad() const {return (fPad != fPrevPad) || IsNewRow();};
+    Int_t            GetTime() const {return fTime;};
+    Int_t            GetSignal() const {return fSignal;};
 
   protected :
-    UShort_t         Get10BitWord(UChar_t* buffer, Int_t position);
+    UShort_t         Get10BitWord(UChar_t* buffer, Int_t position) const;
 
     AliRawReader*    fRawReader;    // object for reading the raw data
 
     AliTPCCompression    fCompression;   // object for decompression
-    static const Int_t   kNumTables = 5; // number of (de)compression tables
+    static const Int_t   fgkNumTables = 5; // number of (de)compression tables
     static AliTPCHNode** fgRootNode;     // (de)compression tables
 
-    static const Int_t kDataMax = 10000000; // size of array for uncompressed raw data
+    static const Int_t fgkDataMax = 10000000; // size of array for uncompressed raw data
     UShort_t*        fData;         // uncompressed raw data
     Int_t            fDataSize;     // actual size of the uncompressed raw data
     Int_t            fPosition;     // current position in fData
     Int_t            fCount;        // counter of words to be read for current trailer
     Int_t            fBunchLength;  // remaining number of signal bins in the current bunch
-    static const Int_t kOffset = 1; // offset of signal
+    static const Int_t fgkOffset = 1; // offset of signal
 
     Int_t            fSector;       // index of current sector
     Int_t            fPrevSector;   // index of previous sector