Coding conventions + Bug fix in NextBunch function of AliAltroData. The GetStartBin...
authorcvetan <cvetan@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 23 Nov 2007 09:46:37 +0000 (09:46 +0000)
committercvetan <cvetan@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 23 Nov 2007 09:46:37 +0000 (09:46 +0000)
RAW/AliAltroBunch.cxx
RAW/AliAltroBunch.h
RAW/AliAltroData.cxx
RAW/AliAltroData.h
RAW/AliAltroDecoder.cxx
RAW/AliAltroDecoder.h

index 67d5c11..a0b57d1 100644 (file)
@@ -23,12 +23,12 @@ AliAltroBunch::AliAltroBunch() :
   fEndTimeBin(0),
   fStartTimeBin(999)
 {
-
+  // Default constructor
 }
 
 
 AliAltroBunch::~AliAltroBunch()
 {
-
+  // Default destructor
 }
 
index ee7b96f..008f2a4 100644 (file)
@@ -17,27 +17,22 @@ public:
   void   SetBunchSize(Int_t size) { fBunchSize = size; }
   UInt_t GetEndTimeBin()   const { return fEndTimeBin; }
   void   SetEndTimeBin(UInt_t bin) { fEndTimeBin = bin; }
-
-  //  UInt_t GetStartTimeBin() const { return fStartTimeBin; }
-
-
   UInt_t GetStartTimeBin() const 
     { 
-      return (fEndTimeBin - fBunchSize); 
+      return (fEndTimeBin - (fBunchSize -1)); 
     }
 
   void   SetStartTimeBin(UInt_t bin) { fStartTimeBin = bin; }
-  
 
 private:
 
   AliAltroBunch& operator = (const AliAltroBunch& bunch);
   AliAltroBunch(const AliAltroBunch& bunch);
 
-  UInt_t *fData; 
-  Int_t   fBunchSize;
-  UInt_t  fEndTimeBin;
-  UInt_t  fStartTimeBin;
+  UInt_t *fData;          // pointer to data of current bunch
+  Int_t   fBunchSize;     // total size of current bunch including timestamp and the size indicator (i.e a bunch with just one sample will have size 3)
+  UInt_t  fEndTimeBin;    // Time stamp of the last sample in the bunch in entities of sample indexes
+  UInt_t  fStartTimeBin;  // Time index of the first bin in the bunch 
 
   ClassDef(AliAltroBunch,0) // container class for Altro bunches
 };
index 3ae4de0..0799241 100644 (file)
@@ -40,8 +40,61 @@ AliAltroData::~AliAltroData()
 }
 
 
+/*
+bool
+//AliHLTAltroData::NextBunch(AliHLTAltroBunch *altroBunch)
+AliAltroData::NextBunch(AliAltroBunch *altroBunch)
+{
+  //comment
+  if(fIsComplete == true)
+    {
+
+      if(fBunchCounter == 0)
+       {
+         fBunchData = &fData[fDataSize - 1];
+         altroBunch->fData = &fData[fDataSize - 1];
+         
+       }
+
+      if(fWc < fDataSize)
+       {
+         fWc += *fBunchData;
+         altroBunch->fBunchSize = *fBunchData;
+         altroBunch->fBunchDataSize = altroBunch->fBunchSize  -2;
+
+         fBunchData --;
+         altroBunch->fEndTimeBin = *fBunchData;
+         fBunchData ++;
+
+         fBunchData = fBunchData  -  (altroBunch->fBunchSize);
+         altroBunch->fData = altroBunch->fData -  (altroBunch->fBunchSize);
+         fBunchCounter ++;
+         return true;
+
+       }
+      else
+       {
+         fBunchCounter = 0;
+         fWc = 0;
+         return false;
+       }
+    }
+  else
+    {
+      printf("\nAliHLTAltroData::NextBunch: WARNING, dataset is not complet. 2AAA endmarker is missing ");
+      printf("\nfor branch %d, card %d, chip %d, channel %d\n",  GetBranch(), GetCard(), GetChip(), GetChannel());
+      return false;
+    }
+}
+
+*/
+
+
+
+
 Bool_t AliAltroData::NextBunch(AliAltroBunch *altroBunch)
 {
+
   if(fIsComplete == kTRUE)
     {
 
@@ -79,6 +132,8 @@ Bool_t AliAltroData::NextBunch(AliAltroBunch *altroBunch)
 
 }
 
+
+
 void AliAltroData::Reset()
 {
    fWc = 0;
index b91752a..2d94819 100644 (file)
@@ -12,24 +12,25 @@ public:
 
   AliAltroData();
   ~ AliAltroData();
-  Bool_t NextBunch(AliAltroBunch *altrobunch);
-
-  Int_t  GetChannel() const;
-  Int_t  GetChip() const;
-  Int_t  GetCard() const;
-  Int_t  GetBranch() const;
-  void   Reset();
-
-  Bool_t IsComplete()      const { return fIsComplete; }
-  void   SetIsComplete(Bool_t iscomplete) { fIsComplete = iscomplete; }
-  Int_t  GetHadd()         const { return fHadd; }
-  Int_t  GetPrevHadd()     const { return fPrevHadd; }
-  Bool_t IsNewHadd()       const { return (fHadd != fPrevHadd); }
-  void   SetHadd(Int_t add)      { fPrevHadd = fHadd; fHadd = add; }
-  const  UInt_t* GetData() const { return fData; }
-  void   SetData(UInt_t *data)   { fData = data; }
-  Int_t  GetDataSize()     const { return fDataSize; }
-  void   SetDataSize(Int_t size) { fDataSize = size; }
+  Bool_t  NextBunch(AliAltroBunch *altrobunch);
+
+  Int_t   GetChannel() const;
+  Int_t   GetChip() const;
+  Int_t   GetCard() const;
+  Int_t   GetBranch() const;
+  void    Reset();
+
+  Bool_t  IsComplete()      const { return fIsComplete; }
+  void    SetIsComplete(Bool_t iscomplete) { fIsComplete = iscomplete; }
+  Int_t   GetHadd()         const { return fHadd; }
+  Int_t   GetPrevHadd()     const { return fPrevHadd; }
+  Bool_t  IsNewHadd()       const { return (fHadd != fPrevHadd); }
+  void    SetHadd(Int_t add)      { fPrevHadd = fHadd; fHadd = add; }
+  const   UInt_t* GetData() const { return fData; }
+  void    SetData(UInt_t *data)   { fData = data; }
+  //  UInt_t* GetData() const { return fData; } 
+  Int_t   GetDataSize()     const { return fDataSize; }
+  void    SetDataSize(Int_t size) { fDataSize = size; }
 
 private:
 
index ebe1a9f..8ddf264 100644 (file)
 #include  "AliAltroDecoder.h"
 #include  "AliAltroData.h"
 
+// Class for fast decoding of RCU/Altro raw data format (DDL format)
+// to PC readable form. The decoding is done in 3 steps.
+// 1) The RCU payload consistist of a variable number of 160 bit words
+//    denoted a DDL block. All the DDL blocks of an RCU payload is transformed
+//    to 16 integers wich is then put into a buffer of integers big enought to contain the
+//    biggest number of samples possible
+// 2) The decoded buffer is then accesible for the NextChannel functions wich reads 
+//    the altro channel data (samples) contained in the payload. The first call to NextChannel gives the
+//    last altro channel of the back linked list, the next call the second last channel ..etc untill
+//    all channles are read.
+// 3) (optional) For each Altro channel one chan invoke the member function NextBunch which gives on first call
+//    The last bunch (the bunch with the highest timestamp), on next call the second last bunch..etc
+//    untill all bunches are read
+  
+
 ClassImp(AliAltroDecoder)
 
 AliAltroDecoder::AliAltroDecoder() : f32DtaPtr(0),
                                     f8DtaPtr(0),
-                                    fN32HeaderWords(8), 
+                                    fkN32HeaderWords(8), 
                                     fN40AltroWords(0), 
                                     fN40RcuAltroWords(0),
                                     fNDDLBlocks(0), 
@@ -37,19 +52,21 @@ AliAltroDecoder::AliAltroDecoder() : f32DtaPtr(0),
                                     fIsDecoded(kFALSE),
                                     fIsFatalCorruptedTrailer(kTRUE) 
 {
- // see header file for class documentation
+ // Default constructor
 }
 
 
 AliAltroDecoder::~AliAltroDecoder()
 {
-  // see header file for class documentation
+  // Default destructor
 }
 
 
-Bool_t AliAltroDecoder::CheckPayloadTrailer()
+Bool_t AliAltroDecoder::CheckPayloadTrailer() const
 {
-   // see header file for  documentation 
+  //Check wether or not there is consistency between the number of 40 bit altro words given by
+  //the RCU payload and the number of 40 bit words calculated from the size of the RCU payload.
+
   if(fN40AltroWords != fN40RcuAltroWords)
     {
       return  kFALSE;
@@ -63,6 +80,9 @@ Bool_t AliAltroDecoder::CheckPayloadTrailer()
 
 Bool_t AliAltroDecoder::Decode()
 { 
+  // Decodes the RCU payload (all altro channels in one go) from the DDL format to
+  // PC readable form
+
   if( fIsFatalCorruptedTrailer == kTRUE)
     {
       printf("\n AliAltroDecoder::Decode(), WARNING, attempt to decode badly corrupted data\n");
@@ -76,7 +96,7 @@ Bool_t AliAltroDecoder::Decode()
       fComplete = 0;
       fInComplete = 0;
 
-      Int_t tmpcnt = countAAApaddings();
+      Int_t tmpcnt = CountAAApaddings();
   
       if(tmpcnt == 3)
        {
@@ -125,6 +145,11 @@ Bool_t AliAltroDecoder::Decode()
 
 Bool_t AliAltroDecoder::NextChannel(AliAltroData *altroDataPtr)
 {
+  // Reads the next altro channel in the RCU payload after the RCU payload
+  // has been decoded. The channles are read strarting from the end (backlinked list) 
+  // Returns kTRUE as long as ther are unread channles in the payload
+  // Returns kFALSE when all the channels has been read. 
+
   if(fIsFatalCorruptedTrailer == kTRUE)
     {
       printf("\n AliAltroDecoder::NextChannel(), WARNING, attempt to decode badly corrupted data\n");
@@ -141,7 +166,7 @@ Bool_t AliAltroDecoder::NextChannel(AliAltroData *altroDataPtr)
          Decode();
        }
 
-      if(fOutBufferIndex >  fN32HeaderWords)
+      if(fOutBufferIndex >  fkN32HeaderWords)
        {
          if((fOutBuffer[fOutBufferIndex] << 4 ) | ((fOutBuffer[fOutBufferIndex-1] & 0x3c0) >> 6) == 0x2aaa)
            {
@@ -185,10 +210,14 @@ Bool_t AliAltroDecoder::NextChannel(AliAltroData *altroDataPtr)
     }
 }
 
-  
 
-Int_t AliAltroDecoder::countAAApaddings()
+Int_t AliAltroDecoder::CountAAApaddings() const
 {
+  // Use for simulated data only.
+  // Patch for incorrectly simulated data. Counts the number of 
+  // 2aaa word in the trailer of the payload and tries to figure out
+  // the correct number of 40 bit altro words in the RCU pauload
   UShort_t *tailPtr= (UShort_t *)(f32DtaPtr +f32PayloadSize);
   Int_t cnt = 0;
 
@@ -208,7 +237,9 @@ Int_t AliAltroDecoder::countAAApaddings()
 
 Float_t AliAltroDecoder::GetFailureRate()
 {
-   // see header file for documentation  
+  // Prints to stdout the percent of altroblocks that
+  // is missing the 2aaa trailer.
   Float_t tmp = 0;
   cout << "Number of Complete channles = " << fComplete <<endl;
   cout << "Number of InComplete channles = " << fInComplete <<endl;
@@ -220,7 +251,9 @@ Float_t AliAltroDecoder::GetFailureRate()
 
 void AliAltroDecoder::PrintInfo(AliAltroData &altrodata, Int_t n, Int_t nPerLine)
 {
-  // see header file for documentation 
+  // prints data and address information contained in altrodata 
+  // to the standard output
+
   cout << "altrodata.fDataSize = " << altrodata.GetDataSize() <<  endl;
   cout << "altrodata.fHadd = "     << altrodata.GetHadd()  <<endl;
   const UInt_t* data = altrodata.GetData();
@@ -238,6 +271,9 @@ void AliAltroDecoder::PrintInfo(AliAltroData &altrodata, Int_t n, Int_t nPerLine
 
 int AliAltroDecoder::SetMemory(UChar_t *dtaPtr, UInt_t size)
 {
+  // Sets the pointer to the memory block that should be decoded
+  // Returns a negative value if an inconsistency in the data is detected
+
   int iRet = 0;
   Int_t tmpTrailerSize;
   fIsDecoded = kFALSE; 
@@ -256,7 +292,7 @@ int AliAltroDecoder::SetMemory(UChar_t *dtaPtr, UInt_t size)
       tmpTrailerSize = 1; //assume that last word is ONE, and that the this word gives the number of 40 bit altro words
     }
 
-  f32PayloadSize = fSize/4 -  (fN32HeaderWords +  tmpTrailerSize);
+  f32PayloadSize = fSize/4 -  (fkN32HeaderWords +  tmpTrailerSize);
   fN40AltroWords = (32*f32PayloadSize)/40; 
   fNDDLBlocks =  f32PayloadSize/5;
   f32LastDDLBlockSize =  f32PayloadSize%DDL_32BLOCK_SIZE;
@@ -265,7 +301,7 @@ int AliAltroDecoder::SetMemory(UChar_t *dtaPtr, UInt_t size)
     {
       f32DtaPtr =  f32DtaPtr -  tmpTrailerSize;
       fN40RcuAltroWords =  *f32DtaPtr;
-      f32DtaPtr = (UInt_t *)dtaPtr + fN32HeaderWords;
+      f32DtaPtr = (UInt_t *)dtaPtr + fkN32HeaderWords;
       fIsFatalCorruptedTrailer = kFALSE; 
     }
   else
@@ -274,7 +310,6 @@ int AliAltroDecoder::SetMemory(UChar_t *dtaPtr, UInt_t size)
       fIsFatalCorruptedTrailer = kTRUE;
       iRet = -1;
     }
-
   
   return iRet;
 
@@ -283,7 +318,8 @@ int AliAltroDecoder::SetMemory(UChar_t *dtaPtr, UInt_t size)
 
 void AliAltroDecoder::DecodeDDLBlock()
 {
-  // see header file for documentation 
+  //Decode one 160 bit DDL block into 16 x 16 bit integers (only least significant 10 bits are filled)
+
   fOutBuffer[fOutBufferIndex] =  *f32DtaPtr & 0x3ff;  //s0 
   fOutBufferIndex ++;
   fOutBuffer[fOutBufferIndex] = (*f32DtaPtr & 0xffc00) >> 10; //s1
@@ -330,7 +366,11 @@ void AliAltroDecoder::DecodeDDLBlock()
 
 void AliAltroDecoder::DecodeLastDDLBlock()
 {
-  // see header file for documentation 
+  // Decode one 160 bit DDL block into 16 integers. 
+  // In order to use the same decoding function (DecodeDDLBlock()) 
+  // a copy of the the last DDL block is made and  
+  // if the las block does not align with 160 bits then it is padded with zeroes 
+
   for(Int_t i=0; i < f32LastDDLBlockSize; i++)
     {
       fDDLBlockDummy[i] = *f32DtaPtr;
index 594f3e2..3905411 100644 (file)
@@ -5,7 +5,19 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
+///////////////////////////////////////////////////////////////////////////////
+///
+/// This is the class for fats deocding of TPC/PHOS/EMCAL raw data
+//  see .cxx file for more detailed comments.
+///
+///////////////////////////////////////////////////////////////////////////////
+
+
+
 #include <TObject.h>
+
+#include <iostream>
+using namespace std;
  
 #define DDL_32BLOCK_SIZE         5
 #define MAX_BRANCHES             2
@@ -20,25 +32,9 @@ class AliAltroData;
 
 class AliAltroDecoder: public TObject {
  public:
-  /*
-   *Default constructor
-   **/
   AliAltroDecoder();
-
-  /*
-   *Default destructor
-   **/
   virtual ~AliAltroDecoder();
-
-  /*
-   *Decode the RCU/DDL payload 
-   **/
   Bool_t Decode();
-
-  /*
-   *Reads the next altro channels 
-   **/
   Bool_t NextChannel(AliAltroData *altroDataPtr);
 
   /* 
@@ -49,6 +45,7 @@ class AliAltroDecoder: public TObject {
   void  DumpData(T *array, Int_t N, Int_t nPerLine)
   {
     cout <<   "DumpData N=  " << N <<endl;
+
     for(Int_t i= 0; i< N; i++)
       {
        if((i%nPerLine == 0)  &&  (i != 0))
@@ -62,50 +59,20 @@ class AliAltroDecoder: public TObject {
   }
 
   int SetMemory(UChar_t  *dtaPtr, UInt_t size);
-
   void PrintInfo(AliAltroData &altrodata, Int_t n = 0, Int_t nPerLine = 4);
-
-  /*
-   *Prints to stdout the percent of altroblocks that
-   *is missing the 2aaa trailer.
-   **/
   Float_t GetFailureRate();
 
  private:
 
   AliAltroDecoder& operator = (const AliAltroDecoder& decoder);
   AliAltroDecoder(const AliAltroDecoder& decoder);
-
-  /*
-   *Check wether or not there is consistency between the number of 40 bit altro words given by
-   *the RCU payload and the number of 40 bit words calculated from the size of the RCU payload.
-   **/
-  Bool_t CheckPayloadTrailer();
-
-  /*
-   *Decode one 160 bit DDL block into 16 x 16 bit integers (only least significant 10 bits are filled)
-   **/
+  Bool_t CheckPayloadTrailer() const;
   void DecodeDDLBlock();
-  /*
-   *Decode one 160 bit DDL block into 16 integers. 
-   *In order to use the same decoding function (DecodeDDLBlock()) 
-   *a copy of the the last DDL block is made and  
-   *if the las block does not align with 160 bits then it is padded with zeroes 
-   **/
   void DecodeLastDDLBlock();
-
-  /*
-   *Use for simulated data only.
-   *Patch for incorrectly simulated data. Counts the number of 
-   *2aaa word in the trailer of the payload and tries to figure out
-   *the correct number of 40 bit altro words in the RCU pauload
-   **/
-  Int_t countAAApaddings();
-
+  Int_t CountAAApaddings() const;
   UInt_t  *f32DtaPtr;                        // Pointer to dat of the input buffer in entities of 32 bit words (the RCU/DDL block)
   UChar_t *f8DtaPtr;                         // Pointer to dat of the input buffer in entities of 8 bit words (the RCU/DDL block)
-  const Long_t fN32HeaderWords;              // Number of 32 bit words in the common data header
+  const Long_t fkN32HeaderWords;              // Number of 32 bit words in the common data header
   Int_t    fN40AltroWords;                   // Number of 40 bit altro words contained in the RCU payload as calculated form the payload size
   Int_t    fN40RcuAltroWords;                // Number of 40 bit altro words contained in the RCU payload as given by the RCU trailer        
   Int_t    fNDDLBlocks;                      // Number of DDL blocks in the payload (the last blocj might/ight not be 160 bits )
@@ -120,8 +87,7 @@ class AliAltroDecoder: public TObject {
   Int_t    fInComplete;                      // Number of altro channels that is read out properly
   Bool_t   fDecodeIfCorruptedTrailer;        // Wether or not to try to decode the data if the RCU trailer is incorrect (will succseed in most cases)
   Bool_t   fIsDecoded;                       // Wether or not the buffer set last by the "SetMemory()" function has been decoded
-
-  Bool_t  fIsFatalCorruptedTrailer;         //If trailer is fataly corrupted, not possible in any way to recover, then it is not allowed to decode the DDL payload.  
+  Bool_t  fIsFatalCorruptedTrailer;          // If trailer is fataly corrupted, not possible in any way to recover, then it is not allowed to decode the DDL payload.  
 
   ClassDef(AliAltroDecoder, 0)  // class for decoding Altro payload
 };