// 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"
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;
+}
+
* 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
///////////////////////////////////////////////////////////////////////////////
#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},
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;
* 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
///////////////////////////////////////////////////////////////////////////////
#include "AliITSRawStreamSPD.h"
+#include "AliRawReader.h"
ClassImp(AliITSRawStreamSPD)
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
///////////////////////////////////////////////////////////////////////////////
#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,
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;
* 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
// 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"
AliRawReader::AliRawReader()
{
+// default constructor: initialize data members
+
fMiniHeader = NULL;
fCount = 0;
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)
{
fSelectMaxDDLID = maxDDLID;
}
-Bool_t AliRawReader::IsSelected()
+Bool_t AliRawReader::IsSelected() const
{
// apply the selection (if any)
}
-Bool_t AliRawReader::CheckMiniHeader()
+Bool_t AliRawReader::CheckMiniHeader() const
{
// check the magic number of the mini header
* 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;
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
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
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();
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();
///////////////////////////////////////////////////////////////////////////////
#include "AliRawReaderRoot.h"
+#include "AliRawEvent.h"
ClassImp(AliRawReaderRoot)
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
}
-UInt_t AliRawReaderRoot::GetType()
+UInt_t AliRawReaderRoot::GetType() const
{
// get the type from the event header
return fEvent->GetHeader()->GetType();
}
-UInt_t AliRawReaderRoot::GetRunNumber()
+UInt_t AliRawReaderRoot::GetRunNumber() const
{
// get the run number from the event header
return fEvent->GetHeader()->GetRunNumber();
}
-const UInt_t* AliRawReaderRoot::GetEventId()
+const UInt_t* AliRawReaderRoot::GetEventId() const
{
// get the event id from the event header
return fEvent->GetHeader()->GetId();
}
-const UInt_t* AliRawReaderRoot::GetTriggerPattern()
+const UInt_t* AliRawReaderRoot::GetTriggerPattern() const
{
// get the trigger pattern from the event header
return fEvent->GetHeader()->GetTriggerPattern();
}
-const UInt_t* AliRawReaderRoot::GetDetectorPattern()
+const UInt_t* AliRawReaderRoot::GetDetectorPattern() const
{
// get the detector pattern from the event header
return fEvent->GetHeader()->GetDetectorPattern();
}
-const UInt_t* AliRawReaderRoot::GetAttributes()
+const UInt_t* AliRawReaderRoot::GetAttributes() const
{
// get the type attributes from the event header
return fEvent->GetHeader()->GetTypeAttribute();
}
-UInt_t AliRawReaderRoot::GetGDCId()
+UInt_t AliRawReaderRoot::GetGDCId() const
{
// get the GDC Id from the event header
/* 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);
* 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)
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
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;
Error("Next", "could not read sample amplitude");
return kFALSE;
}
- fSignal = fData[fPosition++] + kOffset;
+ fSignal = fData[fPosition++] + fgkOffset;
fCount--;
fBunchLength--;
}
-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;
* 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