Adding more bins in QA (Alis)
[u/mrichter/AliRoot.git] / HMPID / AliHMPIDRawStream.h
index 9c53fd4..6043002 100644 (file)
 ///////////////////////////////////////////////////////////////////////////////
 
 #include <TObject.h>
-#include <TRandom.h>
+#include <TH1F.h>
+#include <TH2F.h>
+#include <TFile.h>
 #include "AliHMPIDParam.h"
 #include <AliBitPacking.h>
 #include <AliFstream.h>
 #include "AliHMPIDDigit.h"
 #include "AliDAQ.h"
 #include "AliRawDataHeaderSim.h"
+
 class AliRawReader;
 
 class AliHMPIDRawStream: public TObject {
@@ -31,44 +34,59 @@ class AliHMPIDRawStream: public TObject {
 
     virtual void     Reset();
     virtual Bool_t   Next();
-            void     Init();
-    
-           Int_t    Ch( Int_t ddl,Int_t row,Int_t dil,Int_t pad    ) {return AliHMPIDParam::A2C(fPad[ddl][row][dil][pad]); }            //chamber number
-           
-           Int_t GetDDLNumber()  const { return fDDLNumber; }                                                                            // Provide current DDL number
-    inline  Int_t GetCharge(Int_t ddl,Int_t row, Int_t dilogic, Int_t pad);                                                                         // Provide the charge observed in certain row,dilogic,pad channel
-           inline Int_t GetPad(Int_t ddl,Int_t row,Int_t dil,Int_t pad);                                                                        //
-           
-           Int_t   Pc          ( Int_t ddl,Int_t row,Int_t dil,Int_t pad                            ) {return AliHMPIDParam::A2P(fPad[ddl][row][dil][pad]);}                                                 //PC position number
-           Int_t   PadPcX      ( Int_t ddl,Int_t row,Int_t dil,Int_t pad                            ) {return AliHMPIDParam::A2X(fPad[ddl][row][dil][pad]);}                                                 //pad pc x # 0..79
-           Int_t   PadPcY      ( Int_t ddl,Int_t row,Int_t dil,Int_t pad                            ) {return AliHMPIDParam::A2Y(fPad[ddl][row][dil][pad]);}                                                 //pad pc y # 0..47
-   
-           inline  Bool_t SetZeroSup (Bool_t isSup);
-    inline  Bool_t GetZeroSup(); 
-    inline  Int_t GetErrors(Int_t eType);                                                                                          //Get errors and occurance
+            void     InitVars(Int_t n);
+            void     DelVars();
     
+   static  inline Int_t GetPad(Int_t ddl,Int_t row,Int_t dil,Int_t pad);               //get absolute pad number
+   static  inline Int_t GetFee(Int_t ddl,Int_t row);                                   //get the FEE number
+   static  Int_t GetNDDL()     { return kNDDL;}                                        //return the number of max # of DDLs
+   static  Int_t GetNErrors()  { return kSumErr;}                                      //return the number of max # of Error Types
+
+           Int_t   GetNPads()         const { return fNPads;}                         //Get number of pads present in the stream
+            Int_t*  GetPadArray()      const { return fPad;}                           //Get pad array from stream decoded
+            Int_t*  GetChargeArray()   const { return fCharge;}                        //Get the charge of the pads from dedcoded stream 
+            Int_t*  GetnDDLInStream()  const { return fnDDLInStream;}                  //Get the DDL input check array
+            Int_t*  GetnDDLOutStream() const { return fnDDLOutStream;}                 //Get the DDL output check array
+           Int_t   Pc          ( Int_t ddl,Int_t row,Int_t dil,Int_t pad                            ) {return AliHMPIDParam::A2P(GetPad(ddl,row,dil,pad));}                                                 //PC position number
+           Int_t   PadPcX      ( Int_t ddl,Int_t row,Int_t dil,Int_t pad                            ) {return AliHMPIDParam::A2X(GetPad(ddl,row,dil,pad));}                                                 //pad pc x # 0..79
+           Int_t   PadPcY      ( Int_t ddl,Int_t row,Int_t dil,Int_t pad                            ) {return AliHMPIDParam::A2Y(GetPad(ddl,row,dil,pad));}                                                 //pad pc y # 0..47
+
+    static inline const Char_t* GetErrName(Int_t eType);      
+    inline  Bool_t SetZeroSup (Bool_t isSup);
+    inline  Bool_t GetZeroSup()const; 
+    inline  Int_t  GetErrors(Int_t ddl,Int_t eType)const;                                                                                   //Get errors and occurance
+    Int_t  GetDDLNumber() const{ return fDDLNumber;} //return the number of DDL actually being decoded
+    UInt_t GetLDCNumber() const{ return fLDCNumber;} //return the number of LDC actually being decoded
+    UInt_t GetTimeStamp() const{ return fTimeStamp;} //return the time stamp of the event actually being decoded
+
+    void   SetTurbo(Bool_t isTurbo){fTurbo=isTurbo;}     // Enable/Disable Turbo
+    Bool_t GetTurbo(){ return fTurbo;}                   // Enable Turbo
+    Bool_t Turbo();                                      // Read HMPID Raw data without error checks
     Bool_t ReadHMPIDRawData();                           // Read HMPID Raw data
-    Bool_t ReadSegment(UInt_t word32,Int_t &cntSegment); // Read Segment
-    Bool_t ReadRow(UInt_t word32,Int_t &cntRow);         // Read Row
-    Bool_t ReadDilogic(UInt_t word32,Int_t &cntDilogic); // Read Dilogic
+    Bool_t ReadSegment(Int_t &cntSegment);               // Read Segment
+    Bool_t ReadRow(Int_t &cntRow);                       // Read Row
+    Bool_t ReadDilogic(Int_t &cntDilogic);               // Read Dilogic
 
-    Bool_t CheckRow(UInt_t row);                   // Check Row
-    Bool_t CheckDilogic(UInt_t dilogic);           // Check Dilogic
-    Bool_t CheckPad(UInt_t pad);                   // Check pad
-    Bool_t CheckEoE(UInt_t word,Int_t &nDil);       // Check EoE
-    Bool_t CheckRowMarker(UInt_t word);            // Check RowMarker
-    Bool_t CheckSegment(UInt_t word);              // Check Segment
-    void   DumpData(Int_t nw);                     // Dump Data
-    void   StorePosition();                        //
+    Bool_t CheckRow(UInt_t row);                         // Check Row
+    Bool_t CheckDilogic(UInt_t dilogic);                 // Check Dilogic
+    Bool_t CheckPad(UInt_t pad);                         // Check pad
+    Bool_t CheckEoE(Int_t &nDil);                        // Check EoE
+    Bool_t CheckRowMarker();                             // Check RowMarker
+    Bool_t CheckSegment();                               // Check Segment
+    void   DumpData(Int_t nw);                           // Dump Data
+    void   StorePosition();                              //Debug purpose
     
-    inline void    Raw            (UInt_t &w32,Int_t &ddl,Int_t &r,Int_t &d,Int_t &a);                                              //digit->(w32,ddl,r,d,a)
-    inline void    Raw            (Int_t ddl,Int_t r,Int_t d,Int_t a);                                                              //raw->abs pad number
-    inline Bool_t  Raw            (UInt_t  w32,Int_t  ddl,AliRawReader *pRR);                                                       //(w32,ddl)->digit
-    inline void   SetCharge      (Int_t ddl,Int_t row,Int_t dil,Int_t pad,Int_t q);
-    inline void    WriteRaw       (TObjArray *pDigLst                             );                                                      //write as raw stream     
-    inline void   WriteRowMarker  (AliFstream *ddl,UInt_t size);
-    inline void   WriteEoE        (AliFstream *ddl,UInt_t row,UInt_t dil,UInt_t wordCnt);  
-    inline void   WriteSegMarker  (AliFstream *ddl,UInt_t row, Int_t nwInSeg);   
+    Double_t GetDdlDataSize()      { return 4.0*fRawDataSize;} //returns the data size for the DDL which is decoded in Next(); fRawDataSize = Bytes/4  
+    
+//    inline void    Raw            (UInt_t &w32,Int_t &ddl,Int_t &r,Int_t &d,Int_t &a);                                              //digit->(w32,ddl,r,d,a)
+//    inline void    Raw            (Int_t ddl,Int_t r,Int_t d,Int_t a);                                                              //raw->abs pad number
+//    inline Bool_t  Raw            (UInt_t  w32,Int_t  ddl,AliRawReader *pRR);                                                       //(w32,ddl)->digit
+
+    inline void   WriteRaw       (TObjArray *pDigLst                             );                 //write as raw stream     
+    inline void   WriteRowMarker  (AliFstream *ddl,UInt_t size);                                    //write row marker in simulation
+    inline void   WriteEoE        (AliFstream *ddl,UInt_t row,UInt_t dil,UInt_t wordCnt);           //write Enf Of Event word in simulation
+    inline void   WriteSegMarker  (AliFstream *ddl,UInt_t row, Int_t nwInSeg);                      //write Segment Marker word in simulation
+    inline void   Write5FirmwareWords(AliFstream *ddl);                                             //write the firmware control words in simulation
     
 //    inline TClonesArray  ReMap(TClonesArray *pDigIn);
 enum EDirection {kFwd,kBwd};
@@ -78,30 +96,20 @@ enum Ebits {kbit0,kbit1 , kbit2, kbit3, kbit4, kbit5, kbit6, kbit7, kbit8,
                   kbit17,kbit18,kbit19,kbit20,kbit21,kbit22,kbit23,kbit24,
                   kbit25,kbit26,kbit27,kbit28,kbit29,kbit30,kbit31,kbit32};
     
-    enum EHMPIDRawStreamError {
-      kRawDataSizeErr = 1,
-      kRowMarkerErr = 2,
-      kWrongRowErr = 3,
-      kWrongDilogicErr = 4,
-      kWrongPadErr = 5,
-      kEoEFlagErr = 6,
-      kEoESizeErr = 7,
-      kEoEDILOGICErr = 8,
-      kEoERowErr = 9,
-      kBadSegWordErr = 10,
-      kWrongSegErr = 11,
-      kRowMarkerSizeErr = 12,
-      kSumErr=13                                            //This is always the last one, to retreive the number of errors
-    };
-    
-    enum {
+  enum EHMPIDRawStreamError { kRawDataSizeErr   = 0,  kRowMarkerErr     = 1,  kWrongRowErr      = 2,  kWrongDilogicErr  = 3,
+                              kWrongPadErr      = 4,  kEoEFlagErr       = 5,  kEoESizeErr       = 6,  kEoEDILOGICErr    = 7,
+                              kEoERowErr        = 8,  kBadSegWordErr    = 9,  kWrongSegErr      = 10, kRowMarkerSizeErr = 11,
+                              kPedQZero         =12,  kSumErr           = 13  //This is always the last one, to retreive the number of errors
+                            };                        //Always check the updated list of names in the .cxx file for print-out!
+   
+  enum {
       kNRows       = 24,                                    // Number of rows (starting from 1 !)//was25
       kNDILOGICAdd = 10,                                    // Number of DILOGIC addresses in a row (starting from 1 !) //was11
       kNPadAdd     = 48,                                    // Number of pad row
       kNRowsPerSegment = 8,                                 // Number of rows per segment
       kNDDL = 14
     };
-   enum EHMPIDRawError {
+ enum EHMPIDRawError {
     kInvalidRawDataWord = 1
   };
 
@@ -111,21 +119,30 @@ enum Ebits {kbit0,kbit1 , kbit2, kbit3, kbit4, kbit5, kbit6, kbit7, kbit8,
     AliHMPIDRawStream& operator = (const AliHMPIDRawStream& stream);
     AliHMPIDRawStream(const AliHMPIDRawStream& stream);
 
-    UInt_t           GetWord(Int_t n=1,EDirection dir=kFwd);             // Get n-th word
+    Bool_t           GetWord(Int_t n=1,EDirection dir=kFwd);             // Get n-th word
     UInt_t           GetNextWord();                                      // Get next word
-    Int_t            fCharge[kNDDL][kNRows+1][kNDILOGICAdd+1][kNPadAdd]; // Array for charge values for all channels in one DDL
-    Int_t            fPad[kNDDL][kNRows+1][kNDILOGICAdd+1][kNPadAdd];    // Array for abs pad values for all channels in one DDL
-    UInt_t           fRawWord[kNDDL][kNRows+1][kNDILOGICAdd+1][kNPadAdd];// Array of raw words
-    Int_t            fNumOfErr[kSumErr];                                 // Store the numner of errors for a given error type
+    Int_t            fNPads;                                             // counter of pads in one DDL
+    Int_t           *fCharge;                                            // Array for charge values for all channels in one DDL
+    Int_t           *fPad;                                               // Array for abs pad values for all channels in one DDL
     Int_t            fDDLNumber;                                         // index of current DDL number
-    AliRawReader*    fRawReader;                                         // object for reading the raw data
-    UChar_t*         fData;                                              // raw data
-    Int_t            fPosition;                                          // current position in fData
-    Bool_t           fZeroSup;
-
-    ClassDef(AliHMPIDRawStream, 1)                                       // base class for reading HMPID raw digits
+    Int_t           *fnDDLInStream;                                      // if the DDL is in the raw data
+    Int_t           *fnDDLOutStream;                                     // if the DDL is in the raw data
+    UInt_t           fLDCNumber;                                         // index of current LDC number
+    UInt_t           fTimeStamp;                                         // TimeStamp
+    AliRawReader    *fRawReader;                                         // object for reading the raw data
+    UChar_t         *fData;                                              // raw data
+    Int_t          **fNumOfErr;                                          // Store the numner of errors for a given error type and a given DDL
+    Int_t            fPosition;                                          // current word
+    UInt_t           fWord;                                              // current position in fData
+    Bool_t           fZeroSup;                                           // set if zero suppression is applied
+    Int_t           *fPos;                                               // for debug purposes
+    Int_t            fiPos;                                              // counter for debug
+    Bool_t           fTurbo;                                             // kTRUE = Turbo decoding is called. DEFAULT: kFALSE = normal decoding is called
+    Int_t            fRawDataSize;
+    ClassDef(AliHMPIDRawStream, 4)                                       // base class for reading HMPID raw digits
 };
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+    /*
 void AliHMPIDRawStream::Raw(UInt_t &w32,Int_t &ddl,Int_t &r,Int_t &d,Int_t &a)
 {
 // Convert raw stream word to raw word format
@@ -139,14 +156,16 @@ void AliHMPIDRawStream::Raw(UInt_t &w32,Int_t &ddl,Int_t &r,Int_t &d,Int_t &a)
   a=y2a[PadPcY(ddl,r,d,a)%6]+6*(PadPcX(ddl,r,d,a)%8);                                           //ADDRESS 0..47        
   
   w32=0;    
-  AliBitPacking::PackWord((fCharge[ddl][r][d][a]>4095)?4095:(UInt_t)fCharge[ddl][r][d][a],w32, 0,11);       // 0000 0rrr rrdd ddaa aaaa qqqq qqqq qqqq        Qdc               bits (00..11) counts (0..4095)
+  AliBitPacking::PackWord((fCharge[fNPads]>4095)?4095:(UInt_t)fCharge[fNPads],w32, 0,11);       // 0000 0rrr rrdd ddaa aaaa qqqq qqqq qqqq        Qdc               bits (00..11) counts (0..4095)
   //molnarl: Since in simulation the the charge can be > than 4095 but not in real life we need to protect. If fQ>4095 after packing we will get 0 for the charge! 
   assert(0<=a&&a<=47);AliBitPacking::PackWord(        a ,w32,12,17);  // 3322 2222 2222 1111 1111 1000 0000 0000        DILOGIC address   bits (12..17) counts (0..47)
   assert(1<=d&&d<=10);AliBitPacking::PackWord(        d ,w32,18,21);  // 1098 7654 3210 9876 5432 1098 7654 3210        DILOGIC number    bits (18..21) counts (1..10)
   assert(1<=r&&r<=24);AliBitPacking::PackWord(        r ,w32,22,26);  //                                                Row number        bits (22..26) counts (1..24)  
 }
+*/
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-void AliHMPIDRawStream::Raw(Int_t ddl,Int_t r,Int_t d,Int_t a)
+    /*
+Int_t AliHMPIDRawStream::Raw(Int_t ddl,Int_t r,Int_t d,Int_t a)
 {
   //Assign absolute pad ID based on ddl,row,dil,pad
   //Arguments: DDL, row number, dilogic number, dilogic address(pad)
@@ -158,7 +177,7 @@ void AliHMPIDRawStream::Raw(Int_t ddl,Int_t r,Int_t d,Int_t a)
   Int_t tmp=(r-1)/8;              Int_t pc=(ddl%2)? 5-2*tmp:2*tmp; 
                                   Int_t px=(d-1)*8+a/6;
         tmp=(ddl%2)?(24-r):r-1;   Int_t py=6*(tmp%8)+a2y[a%6];
-  fPad[ddl][r][d][a]=AliHMPIDParam::Abs(ch,pc,px,py);
+  return AliHMPIDParam::Abs(ch,pc,px,py);
 }
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 Bool_t AliHMPIDRawStream::Raw(UInt_t w32,Int_t ddl, AliRawReader *pRR)
@@ -180,16 +199,7 @@ Bool_t AliHMPIDRawStream::Raw(UInt_t w32,Int_t ddl, AliRawReader *pRR)
   fCharge[ddl][r][d][a]=q;
   return kTRUE;
 }
-//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-void AliHMPIDRawStream::SetCharge(Int_t ddl,Int_t row,Int_t dil,Int_t pad,Int_t q)
-{ 
-  //Setter for the charger in the raw stream
-  //Arguments: DDL, row number, dilogic number, dilogic address(pad), charge
-  //Returns:   Charge from the raw stream
-     fCharge[ddl][row][dil][pad]=q;
-     //  return fCharge[ddl][row][dil][pad];
-      
-}
+*/
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 Int_t AliHMPIDRawStream::GetPad(Int_t ddl,Int_t row,Int_t dil,Int_t pad)
 {
@@ -197,48 +207,36 @@ Int_t AliHMPIDRawStream::GetPad(Int_t ddl,Int_t row,Int_t dil,Int_t pad)
   // in case the charge from the channels
   // has not been read or invalid arguments
  
-  assert(0<=ddl&&ddl<=13);  
-  assert(1<=row&&row<=24); 
-  assert(1<=dil&&dil<=10);   
-  assert(0<=pad&&pad<=47);  
-  
+  if(ddl<0 || ddl >13 || row<1 || row >25 || dil<1 || dil >10 || pad<0 || pad >47 ) return -1;
   Int_t a2y[6]={3,2,4,1,5,0};     //pady for a given padress (for single DILOGIC chip)
-                                  Int_t ch=ddl/2;
-  Int_t tmp=(row-1)/8;            Int_t pc=(ddl%2)? 5-2*tmp:2*tmp; 
-                                  Int_t px=(dil-1)*8+pad/6;
-        tmp=(ddl%2)?(24-row):row-1;   
-                                  Int_t py=6*(tmp%8)+a2y[pad%6];
-                                  
-  return fPad[ddl][row][dil][pad]=AliHMPIDParam::Abs(ch,pc,px,py);
+  Int_t ch=ddl/2;
+  Int_t tmp=(24-row)/8;
+  Int_t pc=(ddl%2)?5-2*tmp:2*tmp;
+  Int_t px=(kNDILOGICAdd+1 - dil)*8-pad/6-1;  //flip according to Paolo (2-9-2008)
+
+  tmp=(ddl%2)?row-1:(24-row);
+  Int_t py=6*(tmp%8)+a2y[pad%6];
+
+  return AliHMPIDParam::Abs(ch,pc,px,py);
 }//GetPad()
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-Int_t AliHMPIDRawStream::GetCharge(Int_t ddl,Int_t row, Int_t dilogic, Int_t pad)
+Int_t AliHMPIDRawStream::GetFee(Int_t ddl,Int_t row)
 {
-  // The method returns the charge collected
-  // in a particular channel
-  // Return -1 in case the charge from the channels
-  // has not been read or invalid arguments
-  if (ddl < 0 || ddl > kNDDL) {
-    AliError(Form("Wrong DDL index %d!",ddl));
-    return 0;
-  }  
-  if (row < 1 || row > kNRows) {
-    AliError(Form("Wrong row index %d!",row));
-    return 0;
-  }
-
-  if (dilogic < 1 || dilogic > kNDILOGICAdd) {
-    AliError(Form("Wrong DILOGIC address %d!",dilogic));
-    return 0;
-  }
-  
-  if (pad >= kNPadAdd) {
-    AliError(Form("Wrong pad index %d!",pad));
-    return 0;
-  }
-
-  return fCharge[ddl][row][dilogic][pad];
-  
+   // The method returns the FEE number or -1 
+   // in case of invalid argument(s)
+   if(ddl<0 || ddl >13 || row<1 || row >25  ) return -1;
+   Int_t fee=-1, kLeft=0, kRight=0;
+   if(ddl%2==0) {kLeft=1;kRight=0;}
+   if(ddl%2!=0) {kLeft=0;kRight=1;}
+   if((kLeft==1 && row<=24 && row>=21) || (kRight==1 && row<=4  && row>=1)) fee=0;    //calculation of FEE values based on Giacomos pedestal macro
+   if((kLeft==1 && row<=20 && row>=17) || (kRight==1 && row<=8  && row>=5)) fee=1;
+   if((kLeft==1 && row<=16 && row>=13) || (kRight==1 && row<=12 && row>=9)) fee=2;
+   if((kLeft==1 && row<=12 && row>=9)  || (kRight==1 && row<=16 && row>=13))fee=3;
+   if((kLeft==1 && row<=8  && row>=5)  || (kRight==1 && row<=20 && row>=17))fee=4;
+   if((kLeft==1 && row<=4  && row>=1)  || (kRight==1 && row<=24 && row>=21))fee=5;
+   return fee;
 }
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 void AliHMPIDRawStream::WriteRowMarker(AliFstream *ddl,UInt_t size)
@@ -274,16 +272,34 @@ void AliHMPIDRawStream::WriteSegMarker(AliFstream *ddl,UInt_t row, Int_t nwInSeg
   //Arguments: ddl stream and the segment: row 8 -> 0x5800, row 16 -> 5801, row 24 -> 5802 for pedestal
   //Retruns:   nothing
     UInt_t w32=0;
-    Printf("============ Number of words in segment: %d in row: %d ",nwInSeg,row);
+
       //Segment marker: 2736 == ab0
-//      AliBitPacking::PackWord((UInt_t)0   ,w32,27,31);          //zero out the rest of the bits, since they are not needed
+      //AliBitPacking::PackWord((UInt_t)0   ,w32,27,31);          //zero out the rest of the bits, since they are not needed
       AliBitPacking::PackWord((UInt_t)2736   ,w32,20,31);       //ab0 the segment marker word
       AliBitPacking::PackWord((UInt_t)nwInSeg,w32, 8,19);       //number of words in the segment
       AliBitPacking::PackWord((UInt_t)(row/8),w32, 0, 7);       //segment 0,1,2    
       ddl->WriteBuffer((char*)&w32,sizeof(w32)); 
-      Printf("Segment word created is: %x",w32);
+      //Printf("Segment word created is: %x",w32);
 }      
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     
+void AliHMPIDRawStream::Write5FirmwareWords(AliFstream *ddl)
+{
+  //Before each DDL payload 5 words are written: 
+  // 1.) Firmware version,              for sim = 999
+  // 2.) Status and error bits from CD, for sim = 0
+  // 3.) # FEE RESET received         , for sim = 0
+  // 4.) # TTC READY                  , for sim = 0  
+  // 5.) Spare/Reserved               , for sim = 0
+  //Returns:   nothing
+  UInt_t w32=0;
+  AliBitPacking::PackWord((UInt_t)999,w32,0,31); ddl->WriteBuffer((char*)&w32,sizeof(w32));              
+  AliBitPacking::PackWord((UInt_t) 10,w32,0,31); ddl->WriteBuffer((char*)&w32,sizeof(w32));              
+  AliBitPacking::PackWord((UInt_t) 11,w32,0,31); ddl->WriteBuffer((char*)&w32,sizeof(w32));              
+  AliBitPacking::PackWord((UInt_t) 12,w32,0,31); ddl->WriteBuffer((char*)&w32,sizeof(w32));              
+  AliBitPacking::PackWord((UInt_t) 13,w32,0,31); ddl->WriteBuffer((char*)&w32,sizeof(w32));              
+  
+}
+//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     
 Bool_t AliHMPIDRawStream::SetZeroSup (Bool_t isSup)
 {
   //Prevision to turn OFF zero suppression
@@ -293,7 +309,7 @@ Bool_t AliHMPIDRawStream::SetZeroSup (Bool_t isSup)
   return fZeroSup;
 }
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     
-Bool_t AliHMPIDRawStream::GetZeroSup()
+Bool_t AliHMPIDRawStream::GetZeroSup()const
 {
   if(fZeroSup==kTRUE) return kTRUE;
   else                return kFALSE;
@@ -315,7 +331,7 @@ void AliHMPIDRawStream::WriteRaw(TObjArray *pDigAll)
   Int_t  cntRdig=0,cntLdig=0;
   
   UInt_t posLmarker,posRmarker;
-  Int_t digcnt=0;
+  //  Int_t digcnt=0;
 
   Int_t isDigThere[14][25][11][48];
   
@@ -343,13 +359,18 @@ void AliHMPIDRawStream::WriteRaw(TObjArray *pDigAll)
     ddlR->WriteBuffer((char*)&header,sizeof(header));            //will be rewritten later when total size of DDL is known
     
     UInt_t w32=0;                 //32 bits data word 
-    digcnt=0;
+    //    digcnt=0;
+    
+    //added frimware control words
+    Write5FirmwareWords(ddlL);  cntL+=5;
+    Write5FirmwareWords(ddlR);  cntR+=5;
+   
     
     TClonesArray *pDigCh=(TClonesArray *)pDigAll->At(iCh); //list of digits for current chamber 
    
     for(Int_t iDig=0;iDig<pDigCh->GetEntriesFast();iDig++){//digits loop
       AliHMPIDDigit *pDig1=(AliHMPIDDigit*)pDigCh->At(iDig);
-      pDig1->Raw(w32,ddl,r,d,a);
+      pDig1->Raw(w32,ddl,r,d,a);  //??????????
       isDigThere[ddl][r][d][a]=iDig;
     }  
     
@@ -366,8 +387,7 @@ void AliHMPIDRawStream::WriteRaw(TObjArray *pDigAll)
              AliHMPIDDigit *pDig=(AliHMPIDDigit*)pDigCh->At(isDigThere[iddl][row][dil][pad]);             
              pDig->Raw(w32,ddl,r,d,a);  
              if(pDig->Q() < 0 ) continue;                                                 //We can turn of the zero sup for pedestal simulation
-              //Printf("::::::::::::::: ddl from Digit : %d",ddl);
-             if(ddl%2){                                                                               //write raw digit selecting on DDL
+                if(ddl%2){                                                                               //write raw digit selecting on DDL
                ddlL->WriteBuffer((char*)&w32,sizeof(w32));   cntL++; cntLpad++; cntLrow++;  cntLdig++; cntwInLseg++;//Printf(" WL: %x isDig: %d",w32,isDigThere[iddl][row][dil][pad]);
               }else{
                ddlR->WriteBuffer((char*)&w32,sizeof(w32));   cntR++; cntRpad++; cntRrow++;   cntRdig++;cntwInRseg++;//Printf(" WR: %x isDig: %d",w32,isDigThere[iddl][row][dil][pad]);
@@ -393,17 +413,31 @@ void AliHMPIDRawStream::WriteRaw(TObjArray *pDigAll)
   }//chambers loop
 }//WriteRaw()
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-Int_t AliHMPIDRawStream::GetErrors(Int_t eType)
+Int_t AliHMPIDRawStream::GetErrors(Int_t ddl,Int_t eType)const
 {
 // Return the number of errors for a given error tye during raw data reading
 // Arguments: errorType
-//   Returns: error or -999 if error Type does not exist
+// Returns: error or -999 if error Type does not exist
   
-  if(eType < 1 || eType> kSumErr-1 ) return -999;
-  else 
-    return fNumOfErr[eType];
-        
-
+  if(eType < 0 || eType> kSumErr ||  ddl < 0 || ddl > kNDDL-1 ) return -999;
+  else return fNumOfErr[ddl][eType];
 } //GetErrors()     
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+const Char_t* AliHMPIDRawStream::GetErrName(Int_t eType)
+{
+  // Return the name of the error for a given error tye during raw data reading
+  // Arguments: errorType
+  // Returns: error or -999 if error Type does not exist
+  const Char_t *eName[]={ "kRawDataSizeErr",  "kRowMarkerErr" , "kWrongRowErr" , "kWrongDilogicErr",
+                    "kWrongPadErr"   ,  "kEoEFlagErr"   , "kEoESizeErr"  , "kEoEDILOGICErr",
+                    "kEoERowErr"     ,  "kBadSegWordErr", "kWrongSegErr" , "kRowMarkerSizeErr",
+                    "kPedQZero"      ,  "kSumErr"        };                       
+  const Char_t *eNoErr="NotDefinedErrorType";
+  if(eType<0 || eType>kSumErr) return eNoErr;
+  else                         return eName[eType];
+}//GetErrName()
+//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+    
+    
+    
 #endif