New code for reading of altro data by Per Thomas. The code is much faster than the...
authorcvetan <cvetan@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 2 Aug 2007 13:41:05 +0000 (13:41 +0000)
committercvetan <cvetan@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 2 Aug 2007 13:41:05 +0000 (13:41 +0000)
RAW/AliAltroBunch.cxx [new file with mode: 0644]
RAW/AliAltroBunch.h [new file with mode: 0644]
RAW/AliAltroData.cxx [new file with mode: 0644]
RAW/AliAltroData.h [new file with mode: 0644]
RAW/AliAltroDecoder.cxx [new file with mode: 0644]
RAW/AliAltroDecoder.h [new file with mode: 0644]
RAW/AliAltroRawStreamFast.cxx [new file with mode: 0644]
RAW/AliAltroRawStreamFast.h [new file with mode: 0644]
RAW/RAWrecLinkDef.h
RAW/libRAWDatarec.pkg

diff --git a/RAW/AliAltroBunch.cxx b/RAW/AliAltroBunch.cxx
new file mode 100644 (file)
index 0000000..67d5c11
--- /dev/null
@@ -0,0 +1,34 @@
+/**************************************************************************
+ * This file is property of and copyright by the ALICE HLT Project        * 
+ * All rights reserved.                                                   *
+ *                                                                        *
+ * Primary Author: Per Thomas Hille  <perthi@fys.uio.no>                  *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          * 
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+#include "AliAltroBunch.h"
+
+ClassImp(AliAltroBunch)
+
+AliAltroBunch::AliAltroBunch() : 
+  fData(NULL),
+  fBunchSize(-1),
+  fEndTimeBin(0),
+  fStartTimeBin(999)
+{
+
+}
+
+
+AliAltroBunch::~AliAltroBunch()
+{
+
+}
+
diff --git a/RAW/AliAltroBunch.h b/RAW/AliAltroBunch.h
new file mode 100644 (file)
index 0000000..85086ed
--- /dev/null
@@ -0,0 +1,37 @@
+#ifndef ALIALTROBUNCH_H
+#define ALIALTROBUNCH_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+#include <TObject.h>
+
+class AliAltroBunch: public TObject {
+public:
+
+  AliAltroBunch();
+  ~ AliAltroBunch();
+
+  const  UInt_t* GetData() const { return fData; }
+  void   SetData(UInt_t *data) { fData = data; }
+  Int_t  GetBunchSize()    const { return fBunchSize; }
+  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; }
+  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;
+
+  ClassDef(AliAltroBunch,0) // container class for Altro bunches
+};
+
+#endif
+
diff --git a/RAW/AliAltroData.cxx b/RAW/AliAltroData.cxx
new file mode 100644 (file)
index 0000000..ed087fe
--- /dev/null
@@ -0,0 +1,108 @@
+/**************************************************************************
+ * This file is property of and copyright by the ALICE HLT Project        * 
+ * All rights reserved.                                                   *
+ *                                                                        *
+ * Primary Author:  Per Thomas Hille  <perthi@fys.uio.no>                 *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          * 
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+#include "AliAltroData.h"
+#include "AliAltroBunch.h"
+
+ClassImp(AliAltroData)
+
+AliAltroData::AliAltroData(): fData(0),
+                                   fBunchData(0),
+                                   fDataSize(0),
+                                   fWc(0),
+                                   fHadd(0),
+                                   fBunchCounter(0),
+                                   fIsComplete(0)
+{
+
+
+}
+
+
+
+AliAltroData::~AliAltroData()
+{
+
+
+}
+
+
+Bool_t AliAltroData::NextBunch(AliAltroBunch *altroBunch)
+{
+  if(fIsComplete == kTRUE)
+    {
+
+      if(fBunchCounter == 0)
+       {
+         fBunchData = &fData[fDataSize - 1];
+       }
+
+      if(fWc < fDataSize)
+       {
+         if(*fBunchData == 0){ fWc += 1;};
+         fWc += *fBunchData;
+         altroBunch->SetData( fData - *fBunchData -1 );
+         altroBunch->SetBunchSize( *fBunchData -2 );
+         fBunchData --;
+         altroBunch->SetEndTimeBin( *fBunchData );
+         fBunchData -= (altroBunch->GetBunchSize() +1);
+
+
+         fBunchCounter ++;
+         return kTRUE;
+       }
+      else
+       {
+         fBunchCounter = 0;
+         fWc = 0;
+         return kFALSE;
+       }
+    }
+  else
+    {
+      printf("\nAliAltroData::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 kFALSE;
+    }
+
+}
+
+void AliAltroData::Reset()
+{
+   fWc = 0;
+   fBunchCounter = 0;
+}
+
+
+Int_t AliAltroData::GetChannel() const
+{
+ return  fHadd & 0xf;
+}
+
+Int_t AliAltroData::GetChip() const
+{
+ return  (fHadd & 0x70) >> 4 ;
+}
+
+Int_t AliAltroData::GetCard() const
+{
+ return   (fHadd & 0x780) >>  7;
+}
+
+
+Int_t AliAltroData::GetBranch() const
+{
+ return   (fHadd & 0x800 ) >> 11;
+}
diff --git a/RAW/AliAltroData.h b/RAW/AliAltroData.h
new file mode 100644 (file)
index 0000000..792fb4e
--- /dev/null
@@ -0,0 +1,50 @@
+#ifndef ALIALTRODATA_H
+#define ALIALTRODATA_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+#include <TObject.h>
+
+class AliAltroBunch;
+
+class AliAltroData: public TObject {
+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; }
+  void   SetHadd(Int_t add) { 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; }
+
+private:
+
+  AliAltroData& operator = (const AliAltroData& altrodata);
+  AliAltroData(const AliAltroData& altrodata);
+
+  UInt_t *fData;
+  UInt_t *fBunchData;
+  Int_t   fDataSize;
+  Int_t   fWc;
+  Int_t   fHadd;
+  Int_t   fBunchCounter;
+  Bool_t  fIsComplete;
+
+  ClassDef(AliAltroData, 0)  // container class for Altro payload
+
+};
+
+#endif
+
diff --git a/RAW/AliAltroDecoder.cxx b/RAW/AliAltroDecoder.cxx
new file mode 100644 (file)
index 0000000..1025d5d
--- /dev/null
@@ -0,0 +1,303 @@
+/**************************************************************************
+ * This file is property of and copyright by the ALICE HLT Project        * 
+ * All rights reserved.                                                   *
+ *                                                                        *
+ * Primary Authors: Per Thomas Hille  <perthi@fys.uio.no>                 *
+ *                  Ã˜ystein Djuvsland <oystein.djuvsland@gmail.com>       *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          * 
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+#include  <Riostream.h>
+#include  "AliAltroDecoder.h"
+#include  "AliAltroData.h"
+
+ClassImp(AliAltroDecoder)
+
+AliAltroDecoder::AliAltroDecoder() : f32DtaPtr(0),
+                                      f8DtaPtr(0),
+                                      fN32HeaderWords(8), 
+                                      fN40AltroWords(0), 
+                                      fN40RcuAltroWords(0),
+                                      fNDDLBlocks(0), 
+                                      f32LastDDLBlockSize(5), 
+                                      f32PayloadSize(0),
+                                      fOutBufferIndex(0),
+                                      fSize(0), 
+                                      fNAltro10bitWords(0),
+                                      fComplete(0),
+                                      fInComplete(0),
+                                      fDecodeIfCorruptedTrailer(kTRUE),
+                                      fIsDecoded(kFALSE) 
+{
+ // see header file for class documentation
+}
+
+
+AliAltroDecoder::~AliAltroDecoder()
+{
+  // see header file for class documentation
+}
+
+
+Bool_t AliAltroDecoder::CheckPayloadTrailer()
+{
+   // see header file for  documentation 
+  if(fN40AltroWords != fN40RcuAltroWords)
+    {
+      return  kFALSE;
+    } 
+  else
+    {
+      return kTRUE;
+    }
+}
+
+
+Bool_t AliAltroDecoder::Decode()
+{
+  // see header file for class documentation
+  fComplete = 0;
+  fInComplete = 0;
+
+  Int_t tmpcnt = countAAApaddings();
+  
+  if(tmpcnt == 3)
+    {
+      fN40AltroWords = fN40AltroWords -1;
+    } 
+  else if(tmpcnt == 5)
+    {
+      fN40AltroWords = fN40AltroWords -2;
+    } 
+  else if(tmpcnt == 8)
+    {
+      fN40AltroWords = fN40AltroWords -3;
+    } 
+  
+  if(  ((CheckPayloadTrailer() == kTRUE) || fDecodeIfCorruptedTrailer == kTRUE  )  &&  (fSize > 32) )
+    {
+       //      fDDLBlockCnt = 0;
+      fOutBufferIndex = 0;
+
+      for(Int_t i = 0; i < fNDDLBlocks; i++)
+       {
+         DecodeDDLBlock();
+       }
+
+      DecodeLastDDLBlock(); 
+      fOutBufferIndex =  fN40AltroWords*4  -  1;
+  
+      //      DumpData(fOutBuffer, 400,4);
+    
+      fIsDecoded = kTRUE;
+      return kTRUE;
+    }
+
+  else
+    {
+      cout <<" ERROR: data integrity check failed, discarding data" << endl;
+      cout << "Size of datablock is  " << fSize   << endl;
+      cout << "fN40AltroWords = "      << fN40AltroWords   << endl;
+      cout << "fN40RcuAltroWords = "   << fN40RcuAltroWords  << endl;
+      return kFALSE;
+    }
+}
+
+
+Bool_t AliAltroDecoder::NextChannel(AliAltroData *altroDataPtr)
+{
+  if(fIsDecoded != kTRUE)
+    {
+      cout <<"AliAltroDecoder::NextChanne, WARNING, buffer was not decoded, decoding now.. "<< endl;
+      Decode();
+    }
+
+  if(fOutBufferIndex >  fN32HeaderWords)
+    {
+      if((fOutBuffer[fOutBufferIndex] << 4 ) | ((fOutBuffer[fOutBufferIndex-1] & 0x3c0) >> 6) == 0x2aaa)
+       {
+         altroDataPtr->SetIsComplete(kTRUE);
+         fComplete ++;
+       }
+      else
+       {
+         altroDataPtr->SetIsComplete(kFALSE);
+         fInComplete ++;
+       }
+
+      fOutBufferIndex --;
+      fNAltro10bitWords = ( (fOutBuffer[fOutBufferIndex] & 0x3f) << 4 )   |  ((fOutBuffer[fOutBufferIndex -1]  & (0xF << 6)) >> 6) ;
+      fOutBufferIndex --;
+      altroDataPtr->SetHadd( ((fOutBuffer[fOutBufferIndex] & 0x3)) << 10 | ( fOutBuffer[fOutBufferIndex-1] ) );
+      fOutBufferIndex --;
+
+      if(fNAltro10bitWords%4 == 0)
+       {
+         fOutBufferIndex = fOutBufferIndex  -  fNAltro10bitWords;
+       }
+      else
+       {
+         fOutBufferIndex = fOutBufferIndex - fNAltro10bitWords -(4 - fNAltro10bitWords%4);
+       }
+
+      altroDataPtr->SetData( &fOutBuffer[fOutBufferIndex] );
+      fOutBufferIndex --;
+      altroDataPtr->SetDataSize( fNAltro10bitWords );
+
+      return kTRUE;
+
+    }
+  else
+    {
+      return kFALSE;
+    }
+}
+
+  
+
+Int_t AliAltroDecoder::countAAApaddings()
+{
+  UShort_t *tailPtr= (UShort_t *)(f32DtaPtr +f32PayloadSize);
+  Int_t cnt = 0;
+
+  tailPtr --;
+
+  while(*tailPtr == 0xaaaa)
+    {
+      cnt ++;
+      tailPtr --;
+    }
+  
+  tailPtr  = tailPtr + cnt +1;
+
+  return cnt;
+}
+
+
+Float_t AliAltroDecoder::GetFailureRate()
+{
+   // see header file for documentation  
+  Float_t tmp = 0;
+  cout << "Number of Complete channles = " << fComplete <<endl;
+  cout << "Number of InComplete channles = " << fInComplete <<endl;
+  tmp = (100*(Float_t)fInComplete)/((Float_t)fComplete + (Float_t)fInComplete);
+  cout <<"There are "<<  tmp <<"% incomplete channels"<<endl;
+  return  tmp;
+}
+
+
+void AliAltroDecoder::PrintInfo(AliAltroData &altrodata, Int_t n, Int_t nPerLine)
+{
+  // see header file for documentation 
+  cout << "altrodata.fDataSize = " << altrodata.GetDataSize() <<  endl;
+  cout << "altrodata.fHadd = "     << altrodata.GetHadd()  <<endl;
+  const UInt_t* data = altrodata.GetData();
+  for(Int_t i= 0; i< n; i++)
+    {
+      if( (i%nPerLine == 0) && (i != 0) )
+       {
+         printf("\n");
+       }
+      printf("%d\t", data[i]);
+    }
+  printf("\n");
+}
+
+
+void AliAltroDecoder::SetMemory(UChar_t *dtaPtr, UInt_t size)
+{
+  // see header file for documentation 
+  Int_t tmpTrailerSize;
+  fIsDecoded = kFALSE; 
+  f8DtaPtr =dtaPtr;
+  fSize = size;
+  f8DtaPtr =f8DtaPtr + fSize;
+  f32DtaPtr = (UInt_t *)f8DtaPtr;
+  tmpTrailerSize = *(f32DtaPtr - 1);
+
+  if(tmpTrailerSize <=  MAX_TRAILER_WORDS)
+    {
+      tmpTrailerSize = tmpTrailerSize; //assume that the last word of the buffer gives the number of trailer words 
+    }
+  else
+    {
+      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);
+  fN40AltroWords = (32*f32PayloadSize)/40; 
+  fNDDLBlocks =  f32PayloadSize/5;
+  f32LastDDLBlockSize =  f32PayloadSize%DDL_32BLOCK_SIZE;
+  f32DtaPtr =  f32DtaPtr -  tmpTrailerSize;
+  fN40RcuAltroWords =  *f32DtaPtr;
+  f32DtaPtr = (UInt_t *)dtaPtr + fN32HeaderWords;
+}
+
+
+void AliAltroDecoder::DecodeDDLBlock()
+{
+  // see header file for documentation 
+  fOutBuffer[fOutBufferIndex] =  *f32DtaPtr & 0x3ff;  //s0 
+  fOutBufferIndex ++;
+  fOutBuffer[fOutBufferIndex] = (*f32DtaPtr & 0xffc00) >> 10; //s1
+  fOutBufferIndex ++; 
+  fOutBuffer[fOutBufferIndex] = (*f32DtaPtr & 0x3ff00000) >> 20; //s2
+  fOutBufferIndex ++; 
+  fOutBuffer[fOutBufferIndex] = (*f32DtaPtr & 0xc0000000) >> 30; //s3_1 
+  f32DtaPtr ++;
+  fOutBuffer[fOutBufferIndex] =  fOutBuffer[fOutBufferIndex] | ((*f32DtaPtr & 0xff) << 2); //s3_2 
+  fOutBufferIndex ++;
+  fOutBuffer[fOutBufferIndex] =  (*f32DtaPtr & 0x3ff00) >> 8; //s4
+  fOutBufferIndex ++;
+  fOutBuffer[fOutBufferIndex] =  (*f32DtaPtr & 0xffc0000) >> 18; //s5
+  fOutBufferIndex ++;
+  fOutBuffer[fOutBufferIndex] =  (*f32DtaPtr & 0xf0000000) >> 28; //s6_1
+  f32DtaPtr ++;
+  fOutBuffer[fOutBufferIndex] =  fOutBuffer[fOutBufferIndex] | ((*f32DtaPtr & 0x3f) << 4); //s6_2 
+  fOutBufferIndex ++;
+  fOutBuffer[fOutBufferIndex] =  (*f32DtaPtr & 0xffc0) >> 6; //s7
+  fOutBufferIndex ++;
+  fOutBuffer[fOutBufferIndex] =  (*f32DtaPtr & 0x3ff0000) >> 16; //s8
+  fOutBufferIndex ++;
+  fOutBuffer[fOutBufferIndex] =  (*f32DtaPtr & 0xFC000000) >> 26; //s9_1
+  f32DtaPtr ++;
+  fOutBuffer[fOutBufferIndex] =  fOutBuffer[fOutBufferIndex] | ((*f32DtaPtr & 0xf) << 6); //s9_2
+  fOutBufferIndex ++;
+  fOutBuffer[fOutBufferIndex] =  (*f32DtaPtr & 0x3ff0) >> 4; //s10
+  fOutBufferIndex ++;
+  fOutBuffer[fOutBufferIndex] =  (*f32DtaPtr & 0xffc000) >> 14; //s11
+  fOutBufferIndex ++;
+  fOutBuffer[fOutBufferIndex] =  (*f32DtaPtr & 0xff000000) >> 24; //s12_1
+  f32DtaPtr ++;
+  fOutBuffer[fOutBufferIndex] =  fOutBuffer[fOutBufferIndex] | ((*f32DtaPtr & 0x3) << 8); //s12_2
+  fOutBufferIndex ++;
+  fOutBuffer[fOutBufferIndex] =  (*f32DtaPtr & 0xffc) >> 2; //s13
+  fOutBufferIndex ++;
+  fOutBuffer[fOutBufferIndex] =  (*f32DtaPtr & 0x3ff000) >> 12; //s14
+  fOutBufferIndex ++;
+  fOutBuffer[fOutBufferIndex] =  (*f32DtaPtr & 0xffc00000) >> 22; //s15
+  f32DtaPtr ++;
+  fOutBufferIndex ++;
+}
+
+
+void AliAltroDecoder::DecodeLastDDLBlock()
+{
+  // see header file for documentation 
+  for(Int_t i=0; i < f32LastDDLBlockSize; i++)
+    {
+      fDDLBlockDummy[i] = *f32DtaPtr;
+      f32DtaPtr ++;
+    }
+  
+  f32DtaPtr = fDDLBlockDummy; 
+  f32DtaPtr ++;
+  DecodeDDLBlock();
+}
diff --git a/RAW/AliAltroDecoder.h b/RAW/AliAltroDecoder.h
new file mode 100644 (file)
index 0000000..e238ae9
--- /dev/null
@@ -0,0 +1,127 @@
+//#-*- Mode: c++ -*-
+
+#ifndef ALIALTRODECODER_H
+#define ALIALTRODECODER_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+#include <TObject.h>
+#define DDL_32BLOCK_SIZE         5
+#define MAX_BRANCHES             2
+#define MAX_FEE_PER_BRANCH       16
+#define MAX_ALTROS_PER_FEE       8
+#define CHANNELS_PER_ALTRO       16
+#define MAX_SAMPLES_PER_CHANNEL  1024
+#define ALTRO_TRAILER_SIZE       4
+#define MAX_TRAILER_WORDS        3
+
+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);
+
+  /* 
+   * DONT use !
+   * For debugging purphoses only, will be removed in near future
+   **/
+  template<typename T> 
+  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))
+         {
+           printf("\n");
+         }
+
+       cout << array[i]<< "\t";
+
+      }
+  }
+
+  void 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)
+   **/
+  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();
+
+  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
+  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 )
+  Int_t    f32LastDDLBlockSize;              // Size of the last DDL block
+  UInt_t   fDDLBlockDummy[DDL_32BLOCK_SIZE]; // buffer to contain the las DDL block, if the block is not aligned with 160 bitm the remaining fileds are padded with zeroes
+  UInt_t   f32PayloadSize;                   // The size of the payload in entities of 32 bit words (after subtraction of the RCU header and the RCU trailer words)
+  Long_t   fOutBufferIndex;                  // current buffer position of the buffer for the decoded data (10 bit words represnted as int's)
+  UInt_t   fSize;                            // The size of the input RCU/DDL payload in entities of bytes, inluding the RCU header and trailer
+  UInt_t   fOutBuffer[MAX_FEE_PER_BRANCH*MAX_BRANCHES*MAX_ALTROS_PER_FEE*CHANNELS_PER_ALTRO*(MAX_SAMPLES_PER_CHANNEL + ALTRO_TRAILER_SIZE)]; // Buffer to hold the decoded data
+  UInt_t   fNAltro10bitWords;                // The total number of 10 bit altro words in the RCU payload, including trailers (disregardin that the altro trialer is not aligned with 10 bit)
+  Int_t    fComplete;                        // Number of altro channels that is only partially read out  (0x2aaa pattern missing in trailer)
+  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
+
+  ClassDef(AliAltroDecoder, 0)  // class for decoding Altro payload
+};
+
+#endif
diff --git a/RAW/AliAltroRawStreamFast.cxx b/RAW/AliAltroRawStreamFast.cxx
new file mode 100644 (file)
index 0000000..348f90f
--- /dev/null
@@ -0,0 +1,100 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+///////////////////////////////////////////////////////////////////////////////
+///
+/// This class provides fast access to Altro raw data.
+///
+/// It loops over all Altro payload in the raw data given by the AliRawReader.
+///
+///
+///////////////////////////////////////////////////////////////////////////////
+
+#include "AliAltroRawStreamFast.h"
+#include "AliRawReader.h"
+#include "AliLog.h"
+
+ClassImp(AliAltroRawStreamFast)
+
+
+//_____________________________________________________________________________
+AliAltroRawStreamFast::AliAltroRawStreamFast(AliRawReader* rawReader) :
+  fDecoder(),
+  fData(),
+  fBunch(),
+  fRawReader(rawReader)
+{
+  // Default constructor
+  fRawReader->Reset();
+}
+
+AliAltroRawStreamFast::~AliAltroRawStreamFast()
+{
+  // Destructor
+}
+
+//_____________________________________________________________________________
+void AliAltroRawStreamFast::SelectRawData(Int_t detId)
+{
+  // Select the raw data for specific
+  // detector id
+  AliDebug(1,Form("Selecting raw data for detector %d",detId));
+  fRawReader->Select(detId);
+}
+
+//_____________________________________________________________________________
+void AliAltroRawStreamFast::SelectRawData(const char *detName)
+{
+  // Select the raw data for specific
+  // detector name
+  AliDebug(1,Form("Selecting raw data for detector %s",detName));
+  fRawReader->Select(detName);
+}
+
+Bool_t AliAltroRawStreamFast::NextDDL()
+{
+  // Read next DDL raw-data payload and
+  // runs the altro decoder over the payload
+
+  UChar_t *dataPtr = NULL;
+  do {
+    if (!fRawReader->ReadNextData(dataPtr)) return kFALSE;
+  } while (fRawReader->GetDataSize() == 0);
+
+  // Temporary solution while Per Thomas is
+  // changing the decoder code
+  dataPtr -= sizeof(AliRawDataHeader);
+  Int_t length = fRawReader->GetDataSize() + sizeof(AliRawDataHeader);
+
+  fDecoder.SetMemory(dataPtr, length);
+  fDecoder.Decode();
+
+  return kTRUE;
+}
+
+Bool_t AliAltroRawStreamFast::NextChannel()
+{
+  // Get the data for the next altro channel
+  do {
+    if (!fDecoder.NextChannel(&fData)) return kFALSE;
+  }  while (fData.GetDataSize() == 0);
+  return kTRUE;
+}
+
+Bool_t AliAltroRawStreamFast::NextBunch()
+{
+  // Get the data for the next altro bunch
+  return fData.NextBunch(&fBunch);
+}
diff --git a/RAW/AliAltroRawStreamFast.h b/RAW/AliAltroRawStreamFast.h
new file mode 100644 (file)
index 0000000..22f8c90
--- /dev/null
@@ -0,0 +1,54 @@
+#ifndef ALIALTRORAWSTREAMFAST_H
+#define ALIALTRORAWSTREAMFAST_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+///////////////////////////////////////////////////////////////////////////////
+///
+/// This is a base class for reading raw data in Altro format.
+/// It makes use of the fast altro decoder written by Per Thomas.
+/// More information can be found in AliAltroDecoder class.
+///
+///////////////////////////////////////////////////////////////////////////////
+
+#include <TObject.h>
+#include <Riostream.h>
+
+#include "AliRawReader.h"
+#include "AliAltroDecoder.h"
+#include "AliAltroData.h"
+#include "AliAltroBunch.h"
+
+class AliAltroRawStreamFast: public TObject {
+  public :
+    AliAltroRawStreamFast(AliRawReader* rawReader);
+    virtual ~AliAltroRawStreamFast();
+
+    void SelectRawData(Int_t detId);                           // Select raw data for specific detector id
+    void SelectRawData(const char *detName);                   // Select raw data for specific detector name
+
+    virtual Bool_t NextDDL();
+    virtual Bool_t NextChannel();
+    virtual Bool_t NextBunch();
+
+    Int_t  GetDDLNumber()    const { return fRawReader->GetDDLID(); }  // Provide current DDL number
+    Int_t  GetHWAddress()    const { return fData.GetHadd(); }  // Provide current hardware address
+    UInt_t GetStartTimeBin() const { return fBunch.GetStartTimeBin(); } // Provide the index if the first time-bin in current bunch
+    UInt_t GetEndTimeBin()   const { return fBunch.GetEndTimeBin(); } // Provide the index if the last time-bin in current bunch
+    const UInt_t* GetSignals()     const { return fBunch.GetData(); } // Provide access to altro data itself
+
+  private :
+
+    AliAltroRawStreamFast& operator = (const AliAltroRawStreamFast& stream);
+    AliAltroRawStreamFast(const AliAltroRawStreamFast& stream);
+
+    AliAltroDecoder  fDecoder;      // decoder for altro payload
+    AliAltroData     fData;         // container for altro payload
+    AliAltroBunch    fBunch;        // container for altro bunches
+
+    AliRawReader*    fRawReader;    // object for reading the raw data
+
+    ClassDef(AliAltroRawStreamFast, 0)  // base class for fast reading of Altro raw data
+};
+
+#endif
index f1eaac4..7175932 100644 (file)
@@ -15,5 +15,9 @@
 #pragma link C++ class AliAltroRawStreamOld+;
 #pragma link C++ class AliCaloRawStream+;
 #pragma link C++ class AliVMERawStream+;
+#pragma link C++ class AliAltroDecoder+;
+#pragma link C++ class AliAltroData+;
+#pragma link C++ class AliAltroBunch+;
+#pragma link C++ class AliAltroRawStreamFast+;
 
 #endif
index c7b6faf..eb90307 100644 (file)
@@ -6,7 +6,8 @@ SRCS:=  AliFilter.cxx \
        AliRawReaderMemory.cxx \
        AliAltroRawStream.cxx \
        AliAltroRawStreamOld.cxx AliCaloRawStream.cxx \
-       AliVMERawStream.cxx
+       AliVMERawStream.cxx \
+       AliAltroDecoder.cxx AliAltroData.cxx AliAltroBunch.cxx AliAltroRawStreamFast.cxx
 
 HDRS:= $(SRCS:.cxx=.h)