Fixing bug in setting scaler events for trigger
authormartinez <martinez@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 16 Jun 2006 08:58:12 +0000 (08:58 +0000)
committermartinez <martinez@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 16 Jun 2006 08:58:12 +0000 (08:58 +0000)
Update rawdata format for tracker (Christian)

14 files changed:
MUON/AliMUON.cxx
MUON/AliMUONBlockHeader.cxx
MUON/AliMUONBlockHeader.h
MUON/AliMUONBusStruct.cxx
MUON/AliMUONBusStruct.h
MUON/AliMUONDigitMaker.cxx
MUON/AliMUONDigitMaker.h
MUON/AliMUONDspHeader.cxx
MUON/AliMUONDspHeader.h
MUON/AliMUONPayloadTracker.cxx
MUON/AliMUONPayloadTracker.h
MUON/AliMUONRawStreamTracker.cxx
MUON/AliMUONRawWriter.cxx
MUON/AliMUONRawWriter.h

index e2d65a5..22b1cfb 100644 (file)
@@ -555,7 +555,7 @@ void AliMUON::Digits2Raw()
     fRawWriter = new AliMUONRawWriter(fMUONData);
     if (fTriggerScalerEvent == kTRUE) 
     {
-      fRawWriter->SetScalerEvent();
+      fRawWriter->SetScalersNumbers();
     }
   }
   
index 011af30..8c1a2d8 100644 (file)
 ClassImp(AliMUONBlockHeader)
 /// \endcond
 
-const Int_t AliMUONBlockHeader::fgkHeaderLength = 7;
-
+const Int_t  AliMUONBlockHeader::fgkHeaderLength = 8;
+const UInt_t AliMUONBlockHeader::fgkDefaultDataKey = 0xFC0000FC;
 //___________________________________________
 AliMUONBlockHeader::AliMUONBlockHeader()
   :  TObject(),
+     fDataKey(0),
      fTotalLength(0),
      fLength(0),
      fDspId(0),
-     fPadding(0x0DEADDEAD)
+     fL0Trigger(0),
+     fMiniEventId(0),
+     fEventId1(0),
+     fEventId2(0)
 {
   //
   // ctor
   //
-  for (Int_t i = 0; i < 4; i++)
-    fTriggerWord[i] = 0;
 
   fDspHeaderArray = new TClonesArray("AliMUONDspHeader", 5);
 
@@ -67,13 +69,15 @@ AliMUONBlockHeader::AliMUONBlockHeader(const AliMUONBlockHeader& event)
   //
   // copy ctor
   //
+
+  fDataKey     = event.fDataKey;
   fTotalLength = event.fTotalLength;
   fLength      = event.fLength;
   fDspId       = event.fDspId;
-  fPadding     = event.fPadding;
-
-  for (Int_t i = 0; i < 4; i++)
-    fTriggerWord[i] = event.fTriggerWord[i];
+  fL0Trigger   = event.fL0Trigger;
+  fMiniEventId = event.fMiniEventId;
+  fEventId1    = event.fEventId1;
+  fEventId2    = event.fEventId2;
 
   fDspHeaderArray = new TClonesArray("AliMUONDspHeader", 5);
   for (Int_t index = 0; index < (event.fDspHeaderArray)->GetEntriesFast(); index++) {
@@ -95,12 +99,11 @@ AliMUONBlockHeader::operator=(const AliMUONBlockHeader &event)
   fTotalLength = event.fTotalLength;
   fLength      = event.fLength;
   fDspId       = event.fDspId;
-  fPadding     = event.fPadding;
-
-  //copy ctor
-  for (Int_t i = 0; i < 4; i++)
-    fTriggerWord[i] = event.fTriggerWord[i];
-
+  fL0Trigger   = event.fL0Trigger;
+  fMiniEventId = event.fMiniEventId;
+  fEventId1    = event.fEventId1;
+  fEventId2    = event.fEventId2;
 
   fDspHeaderArray = new TClonesArray("AliMUONDspHeader", 5);
   for (Int_t index = 0; index < (event.fDspHeaderArray)->GetEntriesFast(); index++) {
index edf2438..4507843 100644 (file)
@@ -7,7 +7,7 @@
 
 /// \ingroup raw
 /// \class AliMUONBlockHeader
-/// \brief MUON block header for tracker event
+/// \brief MUON block (Crocus CRT)  header for tracker event
 ///
 /// \author Christian Finck
 
@@ -26,19 +26,28 @@ public:
    virtual ~AliMUONBlockHeader();
 
    // Block header
+   Int_t   GetDataKey()        const {return fDataKey;}
    Int_t   GetTotalLength()    const {return fTotalLength;}
    Int_t   GetLength()         const {return fLength;}
    Int_t   GetDspId()          const {return fDspId;}
-   Int_t   GetTriggerWord(Int_t n) const {return fTriggerWord[n];}
-   Int_t   GetPadding()        const {return fPadding;}
+   Int_t   GetL0Trigger()      const {return fL0Trigger;}
+   Int_t   GetMiniEventId()    const {return fMiniEventId;}
+   Int_t   GetEventId1()       const {return fEventId1;}
+   Int_t   GetEventId2()       const {return fEventId2;}
+
    Int_t   GetHeaderLength()   const {return fgkHeaderLength;}
+   UInt_t  GetDefaultDataKey() const {return fgkDefaultDataKey;}
 
+   void    SetDataKey(Int_t d)     {fDataKey = d;}
    void    SetTotalLength(Int_t l) {fTotalLength = l;}
    void    SetLength(Int_t l)      {fLength = l;}
    void    SetDspId(Int_t d)       {fDspId = d;}  
-   void    SetTriggerWord(Int_t w, Int_t n) {fTriggerWord[n] = w;}
+   void    SetL0Trigger(Int_t l)   {fL0Trigger = l;}
+   void    SetMiniEventId(Int_t e) {fMiniEventId = e;}
+   void    SetEventId1(Int_t e)    {fEventId1 = e;}
+   void    SetEventId2(Int_t e)    {fEventId2 = e;}
 
-   Int_t* GetHeader() {return &fTotalLength;}
+   Int_t* GetHeader() {return &fDataKey;}
 
    void   AddDspHeader(const AliMUONDspHeader& dspHeader);
 
@@ -58,16 +67,21 @@ public:
  private:
 
    // block header
+   Int_t     fDataKey;        ///< Data key word for CRT header 
    Int_t     fTotalLength;    ///< total length of block structure (w/o padding word)
    Int_t     fLength;         ///< length of raw data
    Int_t     fDspId;          ///< Dsp id
-   Int_t     fTriggerWord[4]; ///< counter trigger word
-   Int_t     fPadding;        ///< padding dummy word for 64 bits transfer
+   Int_t     fL0Trigger;      ///< L0 trigger word
+   Int_t     fMiniEventId;    ///< Bunch Crossing for mini-event id (see TDR chapter 8)
+   Int_t     fEventId1;       ///< Event Id in bunch crossing
+   Int_t     fEventId2;       ///< Event Id in orbit number
+
+
+   static const Int_t fgkHeaderLength;   ///< header length in word
+   static const UInt_t fgkDefaultDataKey; ///< default data key word for CRT header 
 
-   static const Int_t fgkHeaderLength; ///< header length in word
    TClonesArray*  fDspHeaderArray;  ///< array of block header
 
-   ClassDef(AliMUONBlockHeader,1)  // MUON block header for Tracker event
+   ClassDef(AliMUONBlockHeader,2)  // MUON block header for Tracker event
 };
 #endif
index 2794c1e..ac712e6 100644 (file)
 ClassImp(AliMUONBusStruct)
 /// \endcond
 
-const Int_t AliMUONBusStruct::fgkHeaderLength = 4;
+const Int_t  AliMUONBusStruct::fgkHeaderLength = 4;
+const UInt_t AliMUONBusStruct::fgkDefaultDataKey = 0xB000000B;
 
 //___________________________________________
 AliMUONBusStruct::AliMUONBusStruct()
   :  TObject(),
+     fDataKey(0),
      fTotalLength(0),
      fLength(0),
      fBusPatchId(0),
-     fTriggerWord(0),
      fBufSize(1024),
      fDspId(0),
      fBlkId(0)
@@ -106,10 +107,10 @@ AliMUONBusStruct(const AliMUONBusStruct& event): TObject(event)
   //
   // copy ctor
   //
+  fDataKey     = event.fDataKey;
   fTotalLength = event.fTotalLength;
   fLength      = event.fLength;
   fBusPatchId  = event.fBusPatchId;
-  fTriggerWord = event.fTriggerWord;
   fBufSize     = event.fBufSize;
 
   fBlkId = event.fBlkId;
@@ -127,10 +128,10 @@ AliMUONBusStruct::operator=(const AliMUONBusStruct& event)
   // assignment operator
   //
   if (this == &event) return *this;
+  fDataKey     = event.fDataKey;
   fTotalLength = event.fTotalLength;
   fLength      = event.fLength;
   fBusPatchId  = event.fBusPatchId;
-  fTriggerWord = event.fTriggerWord;
   fBufSize     = event.fBufSize;
 
   fBlkId = event.fBlkId;
index a81e5b5..74462f1 100644 (file)
@@ -21,26 +21,36 @@ public:
    AliMUONBusStruct(const AliMUONBusStruct& rhs);
    AliMUONBusStruct& operator=(const AliMUONBusStruct& rhs);
 
+   // header
+   Int_t   GetDataKey()     const {return fDataKey;}
    Int_t   GetTotalLength() const {return fTotalLength;}
    Int_t   GetLength()      const {return fLength;}
-   Int_t   GetBufSize()     const {return fBufSize;}
    Int_t   GetBusPatchId()  const {return fBusPatchId;}
-   Int_t   GetTriggerWord() const {return fTriggerWord;}
+
+   Int_t   GetHeaderLength()   const {return fgkHeaderLength;}
+   UInt_t  GetDefaultDataKey() const {return fgkDefaultDataKey;}
+
+   Int_t*  GetHeader() {return &fDataKey;}
+
+   // data
+   Int_t   GetBufSize()     const {return fBufSize;}
    UInt_t* GetData()        const {return fData;}
    Int_t   GetBlockId()     const {return fBlkId;}
    Int_t   GetDspId()       const {return fDspId;}
 
-
    Char_t   GetParity(Int_t n) const;
    UShort_t GetManuId(Int_t n) const;
    Char_t   GetChannelId(Int_t n) const;
    UShort_t GetCharge(Int_t n) const; 
    UInt_t   GetData(Int_t n) const;
 
+   // header setter
+   void    SetDataKey(Int_t d)     {fDataKey = d;}
    void    SetTotalLength(Int_t l) {fTotalLength = l;}
    void    SetLength(Int_t l)      {fLength = l;}
-   void    SetBusPatchId(Int_t b)  {fBusPatchId = b;}  
-   void    SetTriggerWord(Int_t w) {fTriggerWord = w;}
+   void    SetBusPatchId(Int_t b)  {fBusPatchId = b;} 
+   // data 
    void    SetData(UInt_t d, Int_t n)  {fData[n] = d;}
    void    SetBlockId(Int_t b)     {fBlkId = b;}  
    void    SetDspId(Int_t d)       {fDspId = d;}  
@@ -48,31 +58,29 @@ public:
    void    AddData(UInt_t d);
    void    SetAlloc(Int_t size);
 
+   // TClonesArray
    Bool_t  IsSortable() const {return kTRUE;}
    Int_t   Compare(const TObject *obj) const;
    void    Clear(Option_t* opt);
 
-   Int_t   GetHeaderLength() const {return fgkHeaderLength;}
-
-   Int_t*  GetBusPatchHeader() {return &fTotalLength;}
-
  private:
+   Int_t     fDataKey;       ///< Data key word for bus patch header 
    Int_t     fTotalLength;   ///< total length of buspatch structure
    Int_t     fLength;        ///< length of raw data
    Int_t     fBusPatchId;    ///< bus patch id
-   Int_t     fTriggerWord ;  ///< counter trigger word
 
-   static const Int_t fgkHeaderLength;   ///< header length in word
+   static const Int_t  fgkHeaderLength;   ///< header length in word
+   static const UInt_t fgkDefaultDataKey; ///< default data key word for Bus Patch Header 
 
    UInt_t*   fData;          ///< data 
 
    Int_t     fBufSize;       ///< initial size for data array
 
-   Int_t     fDspId;             ///< Dsp number for monitoring
-   Int_t     fBlkId;             ///< block numer for monitoring
+   Int_t     fDspId;         ///< Dsp number for monitoring
+   Int_t     fBlkId;         ///< block numer for monitoring
 
    void ResizeData(Int_t size = 0);
 
-   ClassDef(AliMUONBusStruct,1)  // MUON DDL Tracker
+   ClassDef(AliMUONBusStruct,2)  // MUON DDL Tracker
 };
 #endif
index 3a2e9eb..d9b65eb 100644 (file)
@@ -44,6 +44,7 @@
 #include "AliLog.h"
 #include "AliRun.h"
 
+#include "AliMpBusPatch.h"
 #include "AliMUON.h"
 #include "AliMUONDigitMaker.h"
 #include "AliMUONDigit.h"
@@ -268,8 +269,10 @@ Int_t AliMUONDigitMaker::ReadTrackerDDL(AliRawReader* rawReader)
 
            // Get Back the hits at pads
            Int_t error = GetMapping(buspatchId,manuId,channelId,fDigit); 
-           if (error) continue;
-
+           if (error) {
+             printf("Mapping Error\n");
+             continue;
+           }
            // debugging 
            if (AliLog::GetGlobalDebugLevel() == 3) {
              Int_t padX  = fDigit->PadX();
index 84e1d96..354825d 100644 (file)
@@ -14,7 +14,6 @@
 #include <TObject.h>
 #include "TStopwatch.h"
 
-
 class AliMpBusPatch;
 class AliMUONData;
 class AliMUONDigit;
index 27b23ca..115db8f 100644 (file)
 ClassImp(AliMUONDspHeader)
 /// \endcond
   
-  const Int_t AliMUONDspHeader::fgkHeaderLength = 8;
+  const Int_t  AliMUONDspHeader::fgkHeaderLength = 10;
+  const UInt_t AliMUONDspHeader::fgkDefaultDataKey = 0xF000000F;
+  const UInt_t AliMUONDspHeader::fgkDefaultPaddingWord = 0xBEEFFACE;
 
 //___________________________________________
 AliMUONDspHeader::AliMUONDspHeader()
   :  TObject(),
+     fDataKey(0),
      fTotalLength(0),
      fLength(0),
      fDspId(0),
-     fEventWord(0)
+     fBlkL1ATrigger(0),
+     fMiniEventId(0),
+     fL1ATrigger(0),
+     fL1RTrigger(0),
+     fPaddingWord(0),
+     fErrorWord(0)
 {
   //
   //ctor
   //
-  for (Int_t i = 0; i < 4; i++)
-    fTriggerWord[i] = 0;
 
   fBusPatchArray  = new TClonesArray("AliMUONBusStruct",5);
 
@@ -67,14 +73,15 @@ AliMUONDspHeader::AliMUONDspHeader(const AliMUONDspHeader& event)
   // 
   // copy constructor
   //
-  fTotalLength = event.fTotalLength;
-  fLength      = event.fLength;
-  fDspId       = event.fDspId;
-  fEventWord   = event.fEventWord;
-
-  //ctor
-  for (Int_t i = 0; i < 4; i++)
-    fTriggerWord[i] = event.fTriggerWord[i];
+  fTotalLength   = event.fTotalLength;
+  fLength        = event.fLength;
+  fDspId         = event.fDspId;
+  fBlkL1ATrigger = event.fBlkL1ATrigger;
+  fMiniEventId   = event.fMiniEventId;
+  fL1ATrigger    = event.fL1ATrigger;
+  fL1RTrigger    = event.fL1RTrigger;
+  fPaddingWord   = event.fPaddingWord;
+  fErrorWord     = event.fErrorWord;
 
   fBusPatchArray = new TClonesArray("AliMUONBusStruct", 5);
   for (Int_t index = 0; index < (event.fBusPatchArray)->GetEntriesFast(); index++) {
@@ -96,11 +103,13 @@ AliMUONDspHeader& AliMUONDspHeader::operator=(const AliMUONDspHeader& event)
   fTotalLength = event.fTotalLength;
   fLength      = event.fLength;
   fDspId       = event.fDspId;
-  fEventWord   = event.fEventWord;
+  fBlkL1ATrigger = event.fBlkL1ATrigger;
+  fMiniEventId   = event.fMiniEventId;
+  fL1ATrigger    = event.fL1ATrigger;
+  fL1RTrigger    = event.fL1RTrigger;
+  fPaddingWord   = event.fPaddingWord;
+  fErrorWord     = event.fErrorWord;
 
-  //ctor
-  for (Int_t i = 0; i < 4; i++)
-    fTriggerWord[i] = event.fTriggerWord[i];
 
   fBusPatchArray = new TClonesArray("AliMUONBusStruct", 5);
   for (Int_t index = 0; index < (event.fBusPatchArray)->GetEntriesFast(); index++) {
index 76a68fc..25e20bf 100644 (file)
@@ -26,20 +26,33 @@ public:
    virtual ~AliMUONDspHeader();
 
    // DSP header
+   Int_t   GetDataKey()        const {return fDataKey;}
    Int_t   GetTotalLength()    const {return fTotalLength;}
    Int_t   GetLength()         const {return fLength;}
    Int_t   GetDspId()          const {return fDspId;}
-   Int_t   GetTriggerWord(Int_t n) const {return fTriggerWord[n];}
-   Int_t   GetEventWord()      const {return fEventWord;}
-   Int_t   GetHeaderLength()   const {return fgkHeaderLength;}
-
-   void    SetTotalLength(Int_t l) {fTotalLength = l;}
-   void    SetLength(Int_t l)      {fLength = l;}
-   void    SetDspId(Int_t d)       {fDspId = d;}  
-   void    SetTriggerWord(Int_t w, Int_t n) {fTriggerWord[n] = w;}
-   void    SetEventWord(Int_t w)   {fEventWord = w;}
+   Int_t   GetBlkL1ATrigger()  const {return fBlkL1ATrigger;}
+   Int_t   GetMiniEventId()    const {return fMiniEventId;}
+   Int_t   GetL1ATrigger()     const {return fL1ATrigger;}
+   Int_t   GetL1RTrigger()     const {return fL1RTrigger;}
+   UInt_t  GetPaddingWord()    const {return fPaddingWord;}
+   Int_t   GetErrorWord()      const {return fErrorWord;}
 
-   Int_t*  GetHeader() {return &fTotalLength;}
+   Int_t   GetHeaderLength()   const {return fgkHeaderLength;}
+   UInt_t  GetDefaultDataKey() const {return fgkDefaultDataKey;}
+   UInt_t  GetDefaultPaddingWord() const {return fgkDefaultPaddingWord;}
+
+   void    SetDataKey(Int_t d)        {fDataKey = d;}
+   void    SetTotalLength(Int_t l)    {fTotalLength = l;}
+   void    SetLength(Int_t l)         {fLength = l;}
+   void    SetDspId(Int_t d)          {fDspId = d;}  
+   void    SetBlkL1ATrigger(Int_t l1) {fBlkL1ATrigger = l1;}
+   void    SetMiniEventId(Int_t id)   {fMiniEventId = id;}
+   void    SetL1ATrigger(Int_t l1a)   {fL1ATrigger = l1a;}
+   void    SetL1RTrigger(Int_t l1r)   {fL1RTrigger = l1r;}
+   void    SetPaddingWord(UInt_t w)   {fPaddingWord = w;}
+   void    SetErrorWord(Int_t w)      {fErrorWord = w;}
+
+   Int_t*  GetHeader() {return &fDataKey;}
 
    void    AddBusPatch(const AliMUONBusStruct& busPatch);
 
@@ -59,15 +72,23 @@ public:
  private:
 
    // Dsp header
+   Int_t     fDataKey;          ///< Data key word for FRT header 
    Int_t     fTotalLength;      ///< total length of block structure
    Int_t     fLength;           ///< length of raw data
-   Int_t     fDspId;            ///< Dsp id ??
-   Int_t     fTriggerWord[4];   ///< counter trigger word ?
-   Int_t     fEventWord;        ///< nb word odd = 1, even = 0
-   static const Int_t fgkHeaderLength; ///< header length
+   Int_t     fDspId;            ///< Dsp id
+   Int_t     fBlkL1ATrigger;    ///< L1 accept in Block Structure (CRT)
+   Int_t     fMiniEventId;      ///< Mini Event Id in bunch crossing 
+   Int_t     fL1ATrigger;       ///< Number of L1 accept in DSP Structure (FRT)
+   Int_t     fL1RTrigger;       ///< Number of L1 reject in DSP Structure (FRT)
+   Int_t     fPaddingWord;      ///< padding dummy word for 64 bits transfer
+   Int_t     fErrorWord;        ///< Error word
+
+   static const Int_t  fgkHeaderLength; ///< header length
+   static const UInt_t fgkDefaultDataKey; ///< default data key word for FRT header 
+   static const UInt_t fgkDefaultPaddingWord; ///< default padding word value 
 
-    TClonesArray* fBusPatchArray;   ///< array of buspatch structure
+   TClonesArray* fBusPatchArray;   ///< array of buspatch structure
 
-   ClassDef(AliMUONDspHeader,1)  // MUON Dsp header for Tracker event
+   ClassDef(AliMUONDspHeader,2)  // MUON Dsp header for Tracker event
 };
 #endif
index 23dca5b..caae37d 100644 (file)
@@ -44,11 +44,8 @@ AliMUONPayloadTracker::AliMUONPayloadTracker()
     fMaxBus(5)
 {
   //
-  // create an object to read MUON raw digits
-  // Default ctor for monitoring purposes
+  // create an object to decode MUON payload
   //
-  fBusPatchManager = new AliMpBusPatch();
-  fBusPatchManager->ReadBusPatchFile();
 
   fDDLTracker      = new AliMUONDDLTracker();
   fBusStruct       = new AliMUONBusStruct();
@@ -84,7 +81,6 @@ AliMUONPayloadTracker::~AliMUONPayloadTracker()
   //
   // clean up
   //
-  delete fBusPatchManager;
   delete fDDLTracker;
   delete fBusStruct;
   delete fBlockHeader;
@@ -92,11 +88,14 @@ AliMUONPayloadTracker::~AliMUONPayloadTracker()
 }
 
 //______________________________________________________
-Bool_t AliMUONPayloadTracker::Decode(UInt_t* buffer, Int_t ddl)
+Bool_t AliMUONPayloadTracker::Decode(UInt_t* buffer, Int_t totalDDLSize)
 {
-  // reading tracker DDL
-  // store buspatch info into Array
-  // store only non-empty structures (buspatch info with datalength !=0)
+
+  // Each DDL is made with 2 Blocks each of which consists of 5 DSP's at most 
+  // and each of DSP has at most 5 buspatches.
+  // The different structures, Block (CRT), DSP (FRT) and Buspatch,
+  // are identified by a key word 0xFC0000FC, 0xF000000F and 0xB000000B respectively.
+  // (fBusPatchManager no more needed !)
 
 
   //Read Header Size of DDL,Block,DSP and BusPatch
@@ -104,126 +103,115 @@ Bool_t AliMUONPayloadTracker::Decode(UInt_t* buffer, Int_t ddl)
   static Int_t kDspHeaderSize      = fDspHeader->GetHeaderLength();
   static Int_t kBusPatchHeaderSize = fBusStruct->GetHeaderLength();
 
-  //  Int_t totalDDLSize;
+  // size structures
   Int_t totalBlockSize;
   Int_t totalDspSize;
   Int_t totalBusPatchSize;
   Int_t dataSize; 
+  Int_t bufSize;
 
+  // indexes
+  Int_t indexBlk;
+  Int_t indexDsp;
+  Int_t indexBusPatch;
+  Int_t index = 0;
+  Int_t iBlock = 0;
 
-  Int_t iBusPerDSP[5]; // number of bus patches per DSP
-  Int_t iDspMax;       // number max of DSP per block
-
-  // minimum data size (only header's)
-  //  Int_t blankDDLSize;
-  Int_t blankBlockSize;
-  Int_t blankDspSize; 
-
-  AliDebug(3, Form("DDL Number %d\n", ddl ));
-
-  // getting DSP info
-  fBusPatchManager->GetDspInfo(ddl/2, iDspMax, iBusPerDSP);
-
-  // Each DDL is made with 2 Blocks each of which consists of 5 DSP's at most 
-  // and each of DSP has at most 5 buspatches.
-  // This information is used to calculate the size of headers (Block and DSP) 
-  // which has empty data.
-
-  //  blankDDLSize   = 2*kBlockHeaderSize + 2*iDspMax*kDspHeaderSize;
-  blankBlockSize = kBlockHeaderSize + iDspMax*kDspHeaderSize;
-  // totalDDLSize   = sizeof(buffer)/4;
-
-  for (Int_t i = 0; i < iDspMax; i++) {
-    //  blankDDLSize   += 2*iBusPerDSP[i]*kBusPatchHeaderSize;
-    blankBlockSize +=   iBusPerDSP[i]*kBusPatchHeaderSize;
-  }
-
-  // Compare the DDL header with an empty DDL header size to read the file
-  //  if(totalDDLSize > blankDDLSize) {  //should not happen in real life    
-    // indexes
-    Int_t indexDsp;
-    Int_t indexBusPatch;
-    Int_t index = 0;
-
-    for(Int_t iBlock = 0; iBlock < 2 ;iBlock++){  // loop over 2 blocks
-
-      // copy within padding words
-      memcpy(fBlockHeader->GetHeader(),&buffer[index], (kBlockHeaderSize+1)*4);
+  // CROCUS CRT
+  while (buffer[index] == fBlockHeader->GetDefaultDataKey()) {
 
-      totalBlockSize = fBlockHeader->GetTotalLength();
+    if (iBlock > fMaxBlock) break;
+     
+    // copy within padding words
+    memcpy(fBlockHeader->GetHeader(),&buffer[index], (kBlockHeaderSize)*4);
 
-      fDDLTracker->AddBlkHeader(*fBlockHeader);
+    totalBlockSize = fBlockHeader->GetTotalLength();
 
-      if (fBlockHeader->GetPadding() == 0xDEAD) // skipping padding word
-       index++;
+    indexBlk = index;
+    index += kBlockHeaderSize;
 
-      if(totalBlockSize > blankBlockSize) {        // compare block header
-       index += kBlockHeaderSize;
+    // copy in TClonesArray
+    fDDLTracker->AddBlkHeader(*fBlockHeader);
 
-       for(Int_t iDsp = 0; iDsp < iDspMax ;iDsp++){   //DSP loop
+    // Crocus FRT
+    Int_t iDsp = 0;
+    while (buffer[index] == fDspHeader->GetDefaultDataKey()) {
 
-         if (iDsp > fMaxDsp) break;
-         
-         memcpy(fDspHeader->GetHeader(),&buffer[index], kDspHeaderSize*4);
+      if (iDsp > fMaxDsp) break; // if ever...
+               
+      memcpy(fDspHeader->GetHeader(),&buffer[index], kDspHeaderSize*4);
 
-         totalDspSize = fDspHeader->GetTotalLength();
-         indexDsp = index;
+      totalDspSize = fDspHeader->GetTotalLength();
+      indexDsp = index;
+      index += kDspHeaderSize;
 
-         blankDspSize =  kDspHeaderSize + iBusPerDSP[iDsp]*kBusPatchHeaderSize; // no data just header
+      if (fDspHeader->GetPaddingWord() != fDspHeader->GetDefaultPaddingWord()) {
+       // copy the field of Padding word into ErrorWord field
+       fDspHeader->SetErrorWord(fDspHeader->GetPaddingWord());
+       index--;
+      }
 
-         fDDLTracker->AddDspHeader(*fDspHeader, iBlock);
+      // copy in TClonesArray
+      fDDLTracker->AddDspHeader(*fDspHeader, iBlock);
 
-         if(totalDspSize > blankDspSize) {       // Compare DSP Header
-           index += kDspHeaderSize;
-               
-           for(Int_t iBusPatch = 0; iBusPatch < iBusPerDSP[iDsp]; iBusPatch++) {  
-
-             if (iBusPatch > fMaxBus) break; 
+      // buspatch structure
+      Int_t iBusPatch = 0;
+      while (buffer[index] == fBusStruct->GetDefaultDataKey()) {
 
-             //copy buffer into header structure
-             memcpy(fBusStruct->GetBusPatchHeader(), &buffer[index], kBusPatchHeaderSize*4);
+       if (iBusPatch > fMaxBus) break; // if ever
+       
+       //copy buffer into header structure
+       memcpy(fBusStruct->GetHeader(), &buffer[index], kBusPatchHeaderSize*4);
 
-             totalBusPatchSize = fBusStruct->GetTotalLength();
-             indexBusPatch     = index;
+       totalBusPatchSize = fBusStruct->GetTotalLength();
+       indexBusPatch     = index;
                
-             //Check Buspatch header, not empty events
-             if(totalBusPatchSize > kBusPatchHeaderSize) {    
-
-               index   += kBusPatchHeaderSize;
-               dataSize = fBusStruct->GetLength();
-               Int_t bufSize = fBusStruct->GetBufSize();
-
-               if(dataSize > 0) { // check data present
-                 if (dataSize > bufSize) fBusStruct->SetAlloc(dataSize);
-
-                 //copy buffer into data structure
-                 memcpy(fBusStruct->GetData(), &buffer[index], dataSize*4);
-                 fBusStruct->SetBlockId(iBlock); // could be usefull in future applications ?
-                 fBusStruct->SetDspId(iDsp);
-                 fDDLTracker->AddBusPatch(*fBusStruct, iBlock, iDsp);
-
-               } // dataSize test
-
-             } // testing buspatch
-
-             index = indexBusPatch + totalBusPatchSize;
-
-           }  //buspatch loop
+       //Check Buspatch header, not empty events
+       if(totalBusPatchSize > kBusPatchHeaderSize) {    
+
+         index   += kBusPatchHeaderSize;
+         dataSize = fBusStruct->GetLength();
+         bufSize  = fBusStruct->GetBufSize();
+
+         if(dataSize > 0) { // check data present
+           if (dataSize > bufSize) // check buffer size
+             fBusStruct->SetAlloc(dataSize);
+        
+           //copy buffer into data structure
+           memcpy(fBusStruct->GetData(), &buffer[index], dataSize*4);
+           fBusStruct->SetBlockId(iBlock); // could be usefull in future applications ?
+           fBusStruct->SetDspId(iDsp);
+
+           // copy in TClonesArray
+           fDDLTracker->AddBusPatch(*fBusStruct, iBlock, iDsp);
+
+         } // dataSize test
+
+       } // testing buspatch
+
+       index = indexBusPatch + totalBusPatchSize;
+       if (index >= totalDDLSize) {// check the end of DDL
+         index = totalDDLSize - 1; // point to the last element of buffer
+         break;
+       }
+       iBusPatch++;
+      }  // buspatch loop
                
-         }  // dsp test
-
-         index = indexDsp + totalDspSize;
-             
-       }  // dsp loop
-
-      }   //block test
-
-      index = totalBlockSize;
-
-    }  //block loop
-
-    //  } //loop checking the header size of DDL
+      index = indexDsp + totalDspSize;
+      if (index >= totalDDLSize) {
+       index = totalDDLSize - 1;
+       break;
+      }
+      iDsp++;
+    }  // dsp loop
+
+    index = indexBlk + totalBlockSize;
+    if (index >= totalDDLSize) {
+      index = totalDDLSize - 1;
+      break;
+    }
+    iBlock++;
+  }  // block loop
 
   return kTRUE;
 }
index 9d45e81..f58ee6d 100644 (file)
@@ -19,7 +19,6 @@
 
 #include <TObject.h>
 #include <TClonesArray.h>
-#include "AliMpBusPatch.h"
 
 class AliMUONDDLTracker;
 class AliMUONBusStruct;
@@ -33,7 +32,6 @@ class AliMUONPayloadTracker: public TObject {
     AliMUONPayloadTracker& operator = (const AliMUONPayloadTracker& stream);
     virtual ~AliMUONPayloadTracker();
 
-
     Int_t GetMaxBlock() const {return fMaxBlock;}
     Int_t GetMaxDsp()   const {return fMaxDsp;}
     Int_t GetMaxBus()   const {return fMaxBus;}
@@ -47,7 +45,7 @@ class AliMUONPayloadTracker: public TObject {
 
     void ResetDDL();
 
-    Bool_t Decode(UInt_t* buffer, Int_t ddl);
+    Bool_t Decode(UInt_t* buffer, Int_t datasize);
 
     AliMUONBusStruct*       GetBusPatchInfo() const {return fBusStruct;}
     AliMUONDDLTracker*      GetDDLTracker()   const {return fDDLTracker;}
@@ -64,9 +62,6 @@ class AliMUONPayloadTracker: public TObject {
     Int_t fMaxDsp;        ///< maximum number of Dsp per block in DATE file
     Int_t fMaxBus;        ///< maximum number of Buspatch per Dsp in DATE file
 
-
-    AliMpBusPatch* fBusPatchManager; //!< buspatch versus DE's & DDL
-
     AliMUONDDLTracker*      fDDLTracker;      //!< pointer for buspatch structure
     AliMUONBusStruct*       fBusStruct;       //!< pointer for local structure
     AliMUONBlockHeader*     fBlockHeader;     //!< pointer for block structure 
index 327c886..09a9d24 100644 (file)
@@ -203,7 +203,7 @@ Bool_t AliMUONRawStreamTracker::NextDDL()
 
   fRawReader->ReadNext((UChar_t*)buffer, totalDataWord); 
 
-  fPayload->Decode(buffer, fDDL);
+  fPayload->Decode(buffer, totalDataWord/4);
 
   delete[] buffer;
 
index 96870ca..d0d7413 100644 (file)
@@ -91,20 +91,31 @@ AliMUONRawWriter::AliMUONRawWriter(AliMUONData* data)
   fBusArray = new TClonesArray("AliMUONBusStruct",1000);
   fBusArray->SetOwner(kTRUE);
 
-  // ddl pointer
+  // ddl tracker pointers
   fBlockHeader     = new AliMUONBlockHeader();
   fDspHeader       = new AliMUONDspHeader();
   fBusStruct       = new AliMUONBusStruct();
 
+  // setting data key to default value (only for writting)
+  fBlockHeader->SetDataKey(fBlockHeader->GetDefaultDataKey());
+  fDspHeader->SetDataKey(fDspHeader->GetDefaultDataKey());
+  fBusStruct->SetDataKey(fBusStruct->GetDefaultDataKey());
+
+  // set default paddind word (only for writting)
+  fDspHeader->SetPaddingWord(fDspHeader->GetDefaultPaddingWord());
+
+  // ddl trigger pointers
   fDarcHeader      = new AliMUONDarcHeader();
   fRegHeader       = new AliMUONRegHeader();
   fLocalStruct     = new AliMUONLocalStruct();
 
+  // bus patch & Seg managers
   fBusPatchManager = new AliMpBusPatch();
   fBusPatchManager->ReadBusPatchFile();
 
   fSegFactory = new AliMpSegFactory();
 
+  // timers
   fTrackerTimer.Start(kTRUE); fTrackerTimer.Stop();
   fTriggerTimer.Start(kTRUE); fTriggerTimer.Stop();
   fMappingTimer.Start(kTRUE); fMappingTimer.Stop();
@@ -289,6 +300,11 @@ Int_t AliMUONRawWriter::WriteTrackerDDL(Int_t iCh)
   Int_t busPatchId = 0;
   UInt_t word;
 
+
+  // Dsp length
+  Int_t totalDspLength;
+  Int_t dspLength;
+
   // block length
   Int_t totalBlkLength;
   Int_t blkLength; 
@@ -385,7 +401,6 @@ Int_t AliMUONRawWriter::WriteTrackerDDL(Int_t iCh)
     busPatchId = temp->GetBusPatchId();
 
     // add bus patch header, length and total length managed by subevent class
-    temp->SetTriggerWord(0xdeadbeef);
     for (Int_t j = 0; j < nbInBus[busPatchId]-1; j++) {
       AliMUONBusStruct* temp1 =  (AliMUONBusStruct*)fBusArray->At(++i);
       temp->AddData(temp1->GetData(0));
@@ -425,7 +440,8 @@ Int_t AliMUONRawWriter::WriteTrackerDDL(Int_t iCh)
   iBusPatch = iBus0AtCh - 1; // starting point for each chamber
 
   // nEntries = fBusArray->GetEntriesFast();
-  AliMUONBusStruct* temp = 0x0;
+
+  AliMUONBusStruct* busStructPtr = 0x0;
 
   // open DDL file, on per 1/2 chamber
   for (Int_t iDDL = 0; iDDL < 2; iDDL++) {
@@ -433,7 +449,7 @@ Int_t AliMUONRawWriter::WriteTrackerDDL(Int_t iCh)
     totalDDLLength = 0;
 
     // filling buffer
-    buffer = new Int_t [(2048+24)*50]; // 24 words in average for one buspatch and 2048 manu info at most
+    buffer = new Int_t [(2048+24)*50]; // 24 words at most for one buspatch and 2048 manu info at most
 
     indexBlk = 0;
     indexDsp = 0;
@@ -470,66 +486,65 @@ Int_t AliMUONRawWriter::WriteTrackerDDL(Int_t iCh)
 
          nEntries = fBusArray->GetEntriesFast();
          busPatchId = -1;
+
          for (Int_t iEntries = 0; iEntries < nEntries; iEntries++) { // method "bourrique"...
-           temp = (AliMUONBusStruct*)fBusArray->At(iEntries);
-           busPatchId = temp->GetBusPatchId();
+           busStructPtr = (AliMUONBusStruct*)fBusArray->At(iEntries);
+           busPatchId = busStructPtr->GetBusPatchId();
            if (busPatchId == iBusPatch) break;
            busPatchId = -1;
-           AliDebug(3,Form("busPatchId %d", temp->GetBusPatchId()));
+           AliDebug(3,Form("busPatchId %d", busStructPtr->GetBusPatchId()));
          } 
         
          // check if buspatchid has digit
          if (busPatchId != -1) {
-           // add bus patch structure
-           length = temp->GetHeaderLength();
-           memcpy(&buffer[index],temp->GetBusPatchHeader(),length*4);
+           // add bus patch structure header
+           length = busStructPtr->GetHeaderLength();
+           memcpy(&buffer[index],busStructPtr->GetHeader(),length*4);
            index += length;
-           for (Int_t j = 0; j < temp->GetLength(); j++) {
-             buffer[index++] =  temp->GetData(j);
-             AliDebug(3,Form("busPatchId %d, manuId %d channelId %d\n", temp->GetBusPatchId(), 
-                             temp->GetManuId(j), temp->GetChannelId(j) ));
+
+           // add bus patch data
+           for (Int_t j = 0; j < busStructPtr->GetLength(); j++) {
+             buffer[index++] =  busStructPtr->GetData(j);
+             AliDebug(3,Form("busPatchId %d, manuId %d channelId %d\n", 
+                             busStructPtr->GetBusPatchId(), 
+                             busStructPtr->GetManuId(j), busStructPtr->GetChannelId(j) ));
            }
            //        fBusArray->RemoveAt(iEntries);
            //        fBusArray->Compress();
          } else {
            // writting anyhow buspatch structure (empty ones)
-           buffer[index++] = 4; // total length
+           buffer[index++] = busStructPtr->GetDefaultDataKey(); // fill it also for empty data size
+           buffer[index++] = busStructPtr->GetHeaderLength(); // header length
            buffer[index++] = 0; // raw data length
            buffer[index++] = iBusPatch; // bus patch
-           buffer[index++] = 0xdeadbeef; // trigger word
          }
        } // bus patch
 
-       buffer[indexDsp]   = index - indexDsp; // dsp total length
-       buffer[indexDsp+1] = index - indexDsp - fDspHeader->GetHeaderLength();
-       if ((index - indexDsp) % 2 == 0) // event word
-         buffer[indexDsp+7] = 0;
-       else
-         buffer[indexDsp+7] = 1;
-
+       totalDspLength     = index - indexDsp;
+       dspLength          = totalDspLength - fDspHeader->GetHeaderLength();
+
+       buffer[indexDsp+1] = totalDspLength; // dsp total length
+       buffer[indexDsp+2] = dspLength; // data length  
+
+       // remove padding word if necessary cos already in Dsp header length
+       // if total length is even, remove already placed padding word, else let it as it is.
+       if ((totalDspLength % 2) == 1) { 
+         buffer[indexDsp+1] -= 1;
+         buffer[indexDsp+2] -= 1;
+         index--;
+         Int_t indexCopy = indexDsp + fDspHeader->GetHeaderLength() - 2;
+         memcpy(&buffer[indexCopy], &buffer[indexCopy+1], 
+                (totalDspLength - fDspHeader->GetHeaderLength() + 2)*4);
+       }
+          
       } // dsp
 
       totalBlkLength  = index - indexBlk;
       blkLength       = totalBlkLength - fBlockHeader->GetHeaderLength();
       totalDDLLength += totalBlkLength;
 
-      buffer[indexBlk]   = totalBlkLength; // total block length
-      buffer[indexBlk+1] = blkLength;
-
-      if ((totalBlkLength % 2) == 1) { //add padding word for 64bits transfert
-       buffer[indexBlk]   +=  1; // correct length for padding word
-       buffer[indexBlk+1] +=  1;
-       totalDDLLength++;
-       index++;
-
-       Int_t indexCopy = indexBlk + fBlockHeader->GetHeaderLength();
-       Int_t *buf      = new Int_t [blkLength];
-
-       memcpy(&buf[0], &buffer[indexCopy], blkLength*4);// copy in tmp buffer
-       memcpy(&buffer[indexCopy+1], &buf[0], blkLength*4); // re-copy buffer one elt shifted 
-       delete [] buf;
-       buffer[indexCopy] = 0xDEAD; // mark padding word
-      } // padding condition
+      buffer[indexBlk+1] = totalBlkLength; // total block length
+      buffer[indexBlk+2] = blkLength;
 
     } // block
     
@@ -848,3 +863,16 @@ Int_t AliMUONRawWriter::WriteTriggerDDL()
   
   return kTRUE;
 }
+//____________________________________________________________________
+void AliMUONRawWriter::SetScalersNumbers()
+{
+  // set numbers for scaler events for trigger headers
+  // since this is provided by the experiment
+  // put dummy numbers to check the monitoring
+
+  fDarcHeader->SetScalersNumbers();
+  fRegHeader->SetScalersNumbers();
+  fLocalStruct->SetScalersNumbers();
+  fScalerEvent = kTRUE;
+}
index 4dda3ab..46293f9 100644 (file)
@@ -37,8 +37,8 @@ class AliMUONRawWriter : public TObject
   // write raw data
   Int_t Digits2Raw();
 
-  void  SetScalerEvent() {fScalerEvent = kTRUE;}
-  
+  void SetScalersNumbers();
+
 protected:
   AliMUONRawWriter();                  // Default constructor
   AliMUONRawWriter (const AliMUONRawWriter& rhs); // copy constructor