Update of HP decoders:
authorivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 15 May 2008 10:02:16 +0000 (10:02 +0000)
committerivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 15 May 2008 10:02:16 +0000 (10:02 +0000)
1) Added GetDDLTracker and GetDDLTrigger methods to AliMUONRawStreamTrackerHP
and AliMUONRawStreamTriggerHP respectively to create the DDL payload objects
on the fly. This was done to improve the compatibility of these classes to their
existing counterparts. These methods should however only be used in some rare cases
where one needs the payload object to modify the data and write it back to another
DDL file. Otherwise the existing interface methods of AliMUONRawStreamTrackerHP and
AliMUONRawStreamTriggerHP are much faster.

2) Modified AliMUONDigitMaker and AliMUONReconstruction to handle the new trigger
DDL decoder also. The fast decoders are now enabled by specifying the USEFASTDECODERS
option in the reconstruction options. To make the digit maker use just the fast tracker
DDL decoder use the USEFASTTRKDECODER option. Similarly for just the trigger decoder
you use the USEFASTTRGDECODER option.

Minor fix:
Fixed some documentation in AliMUONVRawStreamTrigger.h

(Artur)

14 files changed:
MUON/AliMUON.cxx
MUON/AliMUON.h
MUON/AliMUONDigitMaker.cxx
MUON/AliMUONDigitMaker.h
MUON/AliMUONRawStreamTrackerHP.cxx
MUON/AliMUONRawStreamTrackerHP.h
MUON/AliMUONRawStreamTriggerHP.cxx
MUON/AliMUONRawStreamTriggerHP.h
MUON/AliMUONReconstructor.cxx
MUON/AliMUONVRawStreamTracker.h
MUON/AliMUONVRawStreamTrigger.h
MUON/AlirootRun_MUONtest.sh
MUON/Config.C
MUON/READMEraw.txt

index b1ccdefd5fa0fcd7cef2e96cb44586bbf1f86967..a6765b48194c4be02f5d4dd1318eb2362a9d2004 100644 (file)
@@ -620,14 +620,54 @@ Int_t  AliMUON::GetDigitizerWithNoise() const
 }  
 
 //____________________________________________________________________
-void AliMUON::SetFastDecoder(Bool_t useFastDecoder)
+Bool_t AliMUON::UsingFastTrackerDecoder() const
+{
+/// Checks to see if we are using the fast decoder for tracker DDL streams.
+
+  if ( ! fDigitMaker ) {
+    AliError("Digit maker is not instantiated.");
+    return kFALSE;
+  }
+  
+  return fDigitMaker->UsingFastTrackerDecoder();
+}
+
+//____________________________________________________________________
+Bool_t AliMUON::UsingFastTriggerDecoder() const
+{
+/// Checks to see if we are using the fast decoder for trigger DDL streams.
+
+  if ( ! fDigitMaker ) {
+    AliError("Digit maker is not instantiated.");
+    return kFALSE;
+  }
+  
+  return fDigitMaker->UsingFastTriggerDecoder();
+}
+
+//____________________________________________________________________
+void AliMUON::SetFastTrackerDecoder(Bool_t useFastDecoder)
 {
 /// Set fast raw data decoder 
 
   if ( ! fDigitMaker ) {
     AliError("Digit maker is not instantiated.");
     return;
-  }   
+  }
+
+  fDigitMaker->SetFastTrackerDecoder(useFastDecoder);
+}
+
+//____________________________________________________________________
+void AliMUON::SetFastTriggerDecoder(Bool_t useFastDecoder)
+{
+/// Set fast raw data decoder 
+
+  if ( ! fDigitMaker ) {
+    AliError("Digit maker is not instantiated.");
+    return;
+  }
+
+  fDigitMaker->SetFastTriggerDecoder(useFastDecoder);
+}
 
-  fDigitMaker->SetFastDecoder(useFastDecoder);
-}  
index 5bafa39cdbe6ebf0992daaac8ecce9e50617df86..b7047041fa128f9ba148e1c3dbb4ca8dfda73c51 100644 (file)
@@ -125,8 +125,13 @@ class AliMUON : public  AliDetector
                  /// Parametrised tail effect in resolution histogram
     virtual void SetTailEffect(Bool_t isTailEffect) { fIsTailEffect=isTailEffect; }
     
-    // Set fast raw data decoder
-    virtual void SetFastDecoder(Bool_t useFastDecoder); 
+    // Check if using fast decoders.
+    virtual Bool_t UsingFastTrackerDecoder() const;
+    virtual Bool_t UsingFastTriggerDecoder() const;
+    
+    // Set fast raw data decoders
+    virtual void SetFastTrackerDecoder(Bool_t useFastDecoder);
+    virtual void SetFastTriggerDecoder(Bool_t useFastDecoder);
                 
     
     // Getters
index 57b0c016906b0d542a29d54225f6e4a562a0f1e2..bbb88d0f6878b441169ff247f2c65825dbdd0513 100644 (file)
@@ -55,6 +55,7 @@
 #include "AliMUONRawStreamTracker.h"
 #include "AliMUONRawStreamTrackerHP.h"
 #include "AliMUONRawStreamTrigger.h"
+#include "AliMUONRawStreamTriggerHP.h"
 #include "AliMUONRegHeader.h"
 #include "AliMUONTriggerCircuit.h"
 #include "AliMUONVTriggerStore.h"
@@ -77,12 +78,15 @@ ClassImp(AliMUONDigitMaker) // Class implementation in ROOT context
 /// \endcond
 
 //__________________________________________________________________________
-AliMUONDigitMaker::AliMUONDigitMaker(Bool_t enableErrorLogger, Bool_t useFastDecoder)
-  : TObject(),
+AliMUONDigitMaker::AliMUONDigitMaker(
+      Bool_t enableErrorLogger,
+      Bool_t useFastTrackerDecoder, Bool_t useFastTriggerDecoder
+  ) :
+    TObject(),
     fScalerEvent(kFALSE),
     fMakeTriggerDigits(kFALSE),
     fRawStreamTracker(NULL),
-    fRawStreamTrigger(new AliMUONRawStreamTrigger()),    
+    fRawStreamTrigger(NULL),
     fDigitStore(0x0),
     fTriggerStore(0x0),
   fLogger(new AliMUONLogger(10000))
@@ -91,7 +95,8 @@ AliMUONDigitMaker::AliMUONDigitMaker(Bool_t enableErrorLogger, Bool_t useFastDec
 
   AliDebug(1,"");
   
-  CreateRawStreamTracker(useFastDecoder);
+  CreateRawStreamTracker(useFastTrackerDecoder);
+  CreateRawStreamTrigger(useFastTriggerDecoder);
 
   // Standard Constructor
   if (enableErrorLogger) {
@@ -121,12 +126,26 @@ void AliMUONDigitMaker::CreateRawStreamTracker(Bool_t useFastDecoder)
 
   if (useFastDecoder)
   {
-    AliInfo("Using fast decoder.");
+    AliInfo("Using fast tracker decoder.");
     fRawStreamTracker = new AliMUONRawStreamTrackerHP();
   }
   else
     fRawStreamTracker = new AliMUONRawStreamTracker();
-}    
+}
+
+//__________________________________________________________________________
+void AliMUONDigitMaker::CreateRawStreamTrigger(Bool_t useFastDecoder)
+{
+/// Create raw stream trigger according to the passed option
+
+  if (useFastDecoder)
+  {
+    AliInfo("Using fast trigger decoder.");
+    fRawStreamTrigger = new AliMUONRawStreamTriggerHP();
+  }
+  else
+    fRawStreamTrigger = new AliMUONRawStreamTrigger();
+}
 
 //____________________________________________________________________
 void
@@ -292,6 +311,8 @@ AliMUONDigitMaker::ReadTriggerDDL(AliRawReader* rawReader)
   Int_t loCircuit;
 
   AliCodeTimerAuto("");
+  
+  if (UsingFastTriggerDecoder()) return ReadTriggerDDLFast(rawReader);
 
   fRawStreamTrigger->SetReader(rawReader);
 
@@ -372,6 +393,114 @@ AliMUONDigitMaker::ReadTriggerDDL(AliRawReader* rawReader)
   return kOK;
 }
 
+//____________________________________________________________________
+Int_t
+AliMUONDigitMaker::ReadTriggerDDLFast(AliRawReader* rawReader)
+{
+  /// reading tracker DDL like ReadTriggerDDL but with fast decoder interface.
+  /// filling the fTriggerStore container, which must not be null
+
+  const AliMUONRawStreamTriggerHP::AliHeader*          darcHeader  = 0x0;
+  const AliMUONRawStreamTriggerHP::AliRegionalHeader*  regHeader   = 0x0;
+  const AliMUONRawStreamTriggerHP::AliLocalStruct*     localStruct = 0x0;
+
+  Int_t loCircuit;
+
+  fRawStreamTrigger->SetReader(rawReader);
+  AliMUONRawStreamTriggerHP* rawStreamTrigger =
+    dynamic_cast<AliMUONRawStreamTriggerHP*>(fRawStreamTrigger);
+
+  while (fRawStreamTrigger->NextDDL())
+  {
+    darcHeader = rawStreamTrigger->GetHeaders();
+    
+    // fill global trigger information
+    if (fTriggerStore) 
+    {
+      if (darcHeader->GetGlobalFlag()) 
+      {
+          AliMUONGlobalTrigger globalTrigger;
+          globalTrigger.SetFromGlobalResponse(darcHeader->GetGlobalOutput());
+          fTriggerStore->SetGlobal(globalTrigger);
+      }
+    }
+    
+    Int_t nReg = rawStreamTrigger->GetRegionalHeaderCount();
+    
+    for(Int_t iReg = 0; iReg < nReg ;iReg++)
+    {   //reg loop
+      
+
+      // crate info  
+      AliMpTriggerCrate* crate = AliMpDDLStore::Instance()->
+                                GetTriggerCrate(fRawStreamTrigger->GetDDL(), iReg);
+      
+      if (!crate) 
+        fLogger->Log(Form("Missing crate number %d in DDL %d\n", iReg, fRawStreamTrigger->GetDDL()));
+     
+      
+      regHeader =  rawStreamTrigger->GetRegionalHeader(iReg);
+      
+      Int_t nLocal = regHeader->GetLocalStructCount();
+      for(Int_t iLocal = 0; iLocal < nLocal; iLocal++) 
+      {
+        
+        localStruct = regHeader->GetLocalStruct(iLocal);
+        
+        // if card exist
+        if (localStruct) {
+          
+         loCircuit = crate->GetLocalBoardId(localStruct->GetId());
+
+         if ( !loCircuit ) continue; // empty slot
+
+         AliMpLocalBoard* localBoard = AliMpDDLStore::Instance()->GetLocalBoard(loCircuit, false);
+
+         // skip copy cards
+         if( !localBoard->IsNotified()) 
+            continue;
+          
+          if (fTriggerStore)
+          {
+            // fill local trigger
+            AliMUONLocalTrigger localTrigger;
+            localTrigger.SetLoCircuit(loCircuit);
+            localTrigger.SetLoStripX((Int_t)localStruct->GetXPos());
+            localTrigger.SetLoStripY((Int_t)localStruct->GetYPos());
+            localTrigger.SetLoDev((Int_t)localStruct->GetXDev());
+            localTrigger.SetLoSdev((Int_t)localStruct->GetSXDev());
+            localTrigger.SetLoTrigY((Int_t)localStruct->GetTrigY());
+            localTrigger.SetLoLpt(localStruct->GetLpt());
+            localTrigger.SetLoHpt(localStruct->GetHpt());
+            localTrigger.SetX1Pattern(localStruct->GetX1());
+            localTrigger.SetX2Pattern(localStruct->GetX2());
+            localTrigger.SetX3Pattern(localStruct->GetX3());
+            localTrigger.SetX4Pattern(localStruct->GetX4());
+            localTrigger.SetY1Pattern(localStruct->GetY1());
+            localTrigger.SetY2Pattern(localStruct->GetY2());
+            localTrigger.SetY3Pattern(localStruct->GetY3());
+            localTrigger.SetY4Pattern(localStruct->GetY4());
+            fTriggerStore->Add(localTrigger);
+          }
+          
+          if ( fMakeTriggerDigits )
+          {
+            //FIXEME should find something better than a TArray
+            TArrayS xyPattern[2];
+            
+           localStruct->GetXPattern(xyPattern[0]);
+           localStruct->GetYPattern(xyPattern[1]);
+            
+            TriggerDigits(loCircuit, xyPattern, *fDigitStore);
+          }
+        } // if triggerY
+      } // iLocal
+    } // iReg
+  } // NextDDL
+  
+  return kOK;
+}
+
 //____________________________________________________________________
 Int_t AliMUONDigitMaker::TriggerDigits(Int_t nBoard, 
                                        TArrayS* xyPattern,
@@ -447,16 +576,41 @@ Int_t AliMUONDigitMaker::TriggerDigits(Int_t nBoard,
   } // ichamber
   
   return kTRUE;
-} 
+}
 
 //____________________________________________________________________
-void  AliMUONDigitMaker::SetFastDecoder(Bool_t useFastDecoder)
+Bool_t AliMUONDigitMaker::UsingFastTrackerDecoder() const
+{
+/// Returns kTRUE if the digit maker is using the high performance decoder for
+/// tracker DDL stream decoding.
+
+  return (fRawStreamTracker->IsA() == AliMUONRawStreamTrackerHP::Class());
+}
+
+//____________________________________________________________________
+Bool_t AliMUONDigitMaker::UsingFastTriggerDecoder() const
+{
+/// Returns kTRUE if the digit maker is using the high performance decoder for
+/// trigger DDL stream decoding.
+
+  return (fRawStreamTrigger->IsA() == AliMUONRawStreamTriggerHP::Class());
+}
+
+//____________________________________________________________________
+void  AliMUONDigitMaker::SetFastTrackerDecoder(Bool_t useFastDecoder)
 {
 /// Set fast raw data decoder
 
   delete fRawStreamTracker;
   CreateRawStreamTracker(useFastDecoder);
-}  
-  
-    
+}
+
+//____________________________________________________________________
+void  AliMUONDigitMaker::SetFastTriggerDecoder(Bool_t useFastDecoder)
+{
+/// Set fast raw data decoder
+
+  delete fRawStreamTrigger;
+  CreateRawStreamTrigger(useFastDecoder);
+}
 
index 7b1aa7f2698d0d8317a684027576fd767f1bfacf..a90c87d4da446df83f0332b32c59458fe7bea449 100644 (file)
@@ -19,7 +19,7 @@ class AliRawReader;
 class AliMUONLocalStruct;
 
 class AliMUONVRawStreamTracker;
-class AliMUONRawStreamTrigger;
+class AliMUONVRawStreamTrigger;
 
 class AliMUONVDigitStore;
 class AliMUONVTriggerStore;
@@ -29,7 +29,10 @@ class AliMUONLogger;
 class AliMUONDigitMaker : public TObject 
 {
  public:
-  AliMUONDigitMaker(Bool_t enableErrorLogger = kTRUE, Bool_t useFastDecoder = kFALSE); // Constructor
+  AliMUONDigitMaker(
+         Bool_t enableErrorLogger = kTRUE,
+         Bool_t useFastTrackerDecoder = kFALSE, Bool_t useFastTriggerDecoder = kFALSE
+     ); // Constructor
   virtual ~AliMUONDigitMaker(void); // Destructor
     
   /// Code to indicate readout errors
@@ -47,6 +50,7 @@ class AliMUONDigitMaker : public TObject
 
   Int_t  ReadTrackerDDL(AliRawReader* rawReader);
   Int_t  ReadTriggerDDL(AliRawReader* rawReader);
+  Int_t  ReadTriggerDDLFast(AliRawReader* rawReader);
   
   Int_t TriggerDigits(Int_t nBoard, TArrayS* xyPattern, 
                       AliMUONVDigitStore& digitStore) const;
@@ -57,7 +61,10 @@ class AliMUONDigitMaker : public TObject
         /// Set flag whether or not we should generate digits for the trigger
   void  SetMakeTriggerDigits(Bool_t flag = kFALSE) { fMakeTriggerDigits = flag; }
 
-  void  SetFastDecoder(Bool_t useFastDecoder); 
+  Bool_t UsingFastTrackerDecoder() const;
+  Bool_t UsingFastTriggerDecoder() const;
+  void  SetFastTrackerDecoder(Bool_t useFastDecoder);
+  void  SetFastTriggerDecoder(Bool_t useFastDecoder);
 
   void Print(Option_t* opt="") const;
 
@@ -70,12 +77,13 @@ private:
 
 private:
   void CreateRawStreamTracker(Bool_t useFastDecoder);
+  void CreateRawStreamTrigger(Bool_t useFastDecoder);
 
   Bool_t fScalerEvent;       //!< flag to generates scaler event
   Bool_t fMakeTriggerDigits; //!< whether or not we should generate digits for the trigger
   
   AliMUONVRawStreamTracker* fRawStreamTracker; //!< pointer of raw stream for tracker
-  AliMUONRawStreamTrigger* fRawStreamTrigger;  //!< pointer of raw stream for trigger
+  AliMUONVRawStreamTrigger* fRawStreamTrigger;  //!< pointer of raw stream for trigger
 
   AliMUONVDigitStore* fDigitStore; //!< not owner
   AliMUONVTriggerStore* fTriggerStore; //!< not owner
index 48937336a69d242e0a799dd4d76df3ef75fe7599..bf9049548456912bbadcdcc032998a34b3bd3f3f 100644 (file)
 //-----------------------------------------------------------------------------
 
 #include "AliMUONRawStreamTrackerHP.h"
+#include "AliMUONDspHeader.h"
+#include "AliMUONBlockHeader.h"
+#include "AliMUONBusStruct.h"
+#include "AliMUONDDLTracker.h"
 #include "AliRawReader.h"
 #include "AliLog.h"
 #include <cassert>
@@ -69,7 +73,8 @@ AliMUONRawStreamTrackerHP::AliMUONRawStreamTrackerHP() :
        fCurrentData(NULL),
        fEndOfData(NULL),
        fHadError(kFALSE),
-       fDone(kFALSE)
+       fDone(kFALSE),
+       fDDLObject(NULL)
 {
        ///
        /// Default constructor.
@@ -100,7 +105,8 @@ AliMUONRawStreamTrackerHP::AliMUONRawStreamTrackerHP(AliRawReader* rawReader) :
        fCurrentData(NULL),
        fEndOfData(NULL),
        fHadError(kFALSE),
-       fDone(kFALSE)
+       fDone(kFALSE),
+       fDDLObject(NULL)
 {
        ///
        /// Constructor with AliRawReader as argument.
@@ -131,6 +137,10 @@ AliMUONRawStreamTrackerHP::~AliMUONRawStreamTrackerHP()
        {
                delete [] fBuffer;
        }
+       if (fDDLObject != NULL)
+       {
+               delete fDDLObject;
+       }
 }
 
 
@@ -155,6 +165,14 @@ Bool_t AliMUONRawStreamTrackerHP::NextDDL()
 
        assert( GetReader() != NULL );
        
+       // The temporary object if generated in GetDDLTracker, is now stale,
+       // so delete it.
+       if (fDDLObject != NULL)
+       {
+               delete fDDLObject;
+               fDDLObject = NULL;
+       }
+       
        // Better to reset these pointers.
        fCurrentBusPatch = NULL;
        fCurrentData = NULL;
@@ -309,6 +327,62 @@ retry:
 }
 
 
+AliMUONDDLTracker* AliMUONRawStreamTrackerHP::GetDDLTracker() const
+{
+       /// Construct and return a pointer to the DDL payload object.
+       /// \return Pointer to internally constructed AliMUONDDLTracker object.
+       ///         The object is owned by this class and should not be deleted
+       ///         by the caller.
+       ///
+       /// \note This method should not be used just to gain access to the DDL
+       /// payload, unless there is a good reason to have the AliMUONDDLTracker
+       /// object. For example, if you want to modify the data and then save it
+       /// to another DDL stream. Otherwise it can be an order of magnitude
+       /// faster to access the DDL headers and data with the GetBlockHeader,
+       /// GetDspHeader and GetBusPatch methods for example.
+       /// Refer to the MUONRawStreamTracker.C macro to see how to use the fast
+       /// decoder interface optimally.
+       
+       if (fDDLObject != NULL) return fDDLObject;
+       
+       fDDLObject = new AliMUONDDLTracker;
+       for (Int_t iBlock = 0; iBlock < (Int_t)GetBlockCount(); iBlock++)
+       {
+               AliMUONBlockHeader blockHeader;
+               AliMUONDspHeader dspHeader;
+               AliMUONBusStruct busPatch;
+               
+               const AliBlockHeader* bh = GetBlockHeader(iBlock);
+               // Copy block header and add it to the DDL object.
+               memcpy(blockHeader.GetHeader(), bh->GetHeader(), sizeof(AliMUONBlockHeaderStruct));
+               fDDLObject->AddBlkHeader(blockHeader);
+               
+               for (Int_t iDsp = 0; iDsp < (Int_t)bh->GetDspCount(); iDsp++)
+               {
+                       const AliDspHeader* dh = bh->GetDspHeader(iDsp);
+                       // Copy DSP header and add it to the DDL object.
+                       memcpy(dspHeader.GetHeader(), dh->GetHeader(), sizeof(AliMUONDSPHeaderStruct));
+                       fDDLObject->AddDspHeader(dspHeader, iBlock);
+                       
+                       const AliBusPatch* bp = dh->GetFirstBusPatch();
+                       while (bp != NULL)
+                       {
+                               // Copy bus patch header, data and add everything into DDL object.
+                               memcpy(busPatch.GetHeader(), bp->GetHeader(), sizeof(AliMUONBusPatchHeaderStruct));
+                               busPatch.SetAlloc(bp->GetLength());
+                               memcpy(busPatch.GetData(), bp->GetData(), bp->GetDataCount()*sizeof(UInt_t));
+                               busPatch.SetBlockId(iBlock);
+                               busPatch.SetDspId(iDsp);
+                               fDDLObject->AddBusPatch(busPatch, iBlock, iDsp);
+                               bp = bp->Next();
+                       }
+               }
+       }
+       
+       return fDDLObject;
+}
+
+
 void AliMUONRawStreamTrackerHP::SetMaxBlock(Int_t blk)
 {
        /// Set maximum number of blocks per DDL allowed.
index 341cfb7b0395b98c70092efeb7559b5aa0ef5960..3e16a87a2f8cd65bcd64825f8a8913d7a17474e8 100644 (file)
@@ -17,6 +17,9 @@
 #include "AliMUONVRawStreamTracker.h"
 #include "AliMUONTrackerDDLDecoder.h"
 
+class AliMUONDDLTracker;
+
+
 class AliMUONRawStreamTrackerHP : public AliMUONVRawStreamTracker
 {
 public:
@@ -52,6 +55,9 @@ public:
                                UShort_t& manuId, UChar_t& manuChannel,
                                UShort_t& adc);
        
+       /// Construct and return a pointer to the DDL payload object.
+       virtual AliMUONDDLTracker* GetDDLTracker() const;
+       
        /// Returns the next batch of decoded channel data.
        const AliBusPatch* Next();
        
@@ -619,6 +625,7 @@ private:
        const UInt_t* fEndOfData;  //!< The last data word in the current bus patch.
        Bool_t fHadError;   //!< Flag indicating if there was a decoding error or not.
        Bool_t fDone;       //!< Flag indicating if the iteration is done or not.
+       mutable AliMUONDDLTracker* fDDLObject; //!< Temporary DDL object used by GetDDLTracker() for caching.
 
        ClassDef(AliMUONRawStreamTrackerHP, 0) // High performance decoder for reading MUON raw digits from tracking chamber DDL data.
 };
index f2c0b9c19df31aab8005fe4b9f22f9817fad0ffb..1e4df43d542aef8d20e310101529d946a0941bac 100644 (file)
 /// \author Artur Szostak <artursz@iafrica.com>
 
 #include "AliMUONRawStreamTriggerHP.h"
+#include "AliMUONDarcHeader.h"
+#include "AliMUONRegHeader.h"
+#include "AliMUONLocalStruct.h"
+#include "AliMUONDDLTrigger.h"
 #include "AliRawReader.h"
 #include "AliLog.h"
 #include <cassert>
@@ -64,7 +68,8 @@ AliMUONRawStreamTriggerHP::AliMUONRawStreamTriggerHP() :
        fBuffer(new UChar_t[8192]),
        fCurrentLocalStruct(NULL),
        fHadError(kFALSE),
-       fDone(kFALSE)
+       fDone(kFALSE),
+       fDDLObject(NULL)
 {
        ///
        /// Default constructor.
@@ -89,7 +94,8 @@ AliMUONRawStreamTriggerHP::AliMUONRawStreamTriggerHP(AliRawReader* rawReader) :
        fBuffer(new UChar_t[8192]),
        fCurrentLocalStruct(NULL),
        fHadError(kFALSE),
-       fDone(kFALSE)
+       fDone(kFALSE),
+       fDDLObject(NULL)
 {
        ///
        /// Constructor with AliRawReader as argument.
@@ -116,6 +122,10 @@ AliMUONRawStreamTriggerHP::~AliMUONRawStreamTriggerHP()
        {
                delete [] fBuffer;
        }
+       if (fDDLObject != NULL)
+       {
+               delete fDDLObject;
+       }
 }
 
 
@@ -141,6 +151,14 @@ Bool_t AliMUONRawStreamTriggerHP::NextDDL()
 
        assert( GetReader() != NULL );
        
+       // The temporary object if generated in GetDDLTracker, is now stale,
+       // so delete it.
+       if (fDDLObject != NULL)
+       {
+               delete fDDLObject;
+               fDDLObject = NULL;
+       }
+       
        fCurrentLocalStruct = NULL;
        
        while (fDDL < GetMaxDDL())
@@ -258,6 +276,73 @@ Bool_t AliMUONRawStreamTriggerHP::Next(
 }
 
 
+AliMUONDDLTrigger* AliMUONRawStreamTriggerHP::GetDDLTrigger() const
+{
+       /// Construct and return a pointer to the DDL payload object.
+       /// \return Pointer to internally constructed AliMUONDDLTrigger object.
+       ///         The object is owned by this class and should not be deleted
+       ///         by the caller.
+       ///
+       /// \note This method should not be used just to gain access to the DDL
+       /// payload, unless there is a good reason to have the AliMUONDDLTrigger
+       /// object. For example, if you want to modify the data and then save it
+       /// to another DDL stream. Otherwise it can be an order of magnitude
+       /// faster to access the DDL headers and data with the GetHeaders,
+       /// GetRegionalHeader and GetLocalStruct methods for example.
+       /// Refer to the MUONRawStreamTrigger.C macro to see how to use the fast
+       /// decoder interface optimally.
+       
+       if (fDDLObject != NULL) return fDDLObject;
+       
+       fDDLObject = new AliMUONDDLTrigger;
+       
+       // Copy over all DARC, global headers and scalars.
+       AliMUONDarcHeader* darcHeader = fDDLObject->GetDarcHeader();
+       const AliHeader* hdr = GetHeaders();
+       UInt_t word = hdr->GetDarcHeader();
+       memcpy(darcHeader->GetHeader(), &word, sizeof(word));
+       if (hdr->GetDarcScalars() != NULL)
+       {
+               memcpy(darcHeader->GetDarcScalers(), hdr->GetDarcScalars(), sizeof(AliMUONDarcScalarsStruct));
+       }
+       memcpy(darcHeader->GetGlobalInput(), hdr->GetGlobalHeader(), sizeof(AliMUONGlobalHeaderStruct));
+       if (hdr->GetGlobalScalars() != NULL)
+       {
+               memcpy(darcHeader->GetGlobalScalers(), hdr->GetGlobalScalars(), sizeof(AliMUONGlobalScalarsStruct));
+       }
+       
+       for (Int_t iReg = 0; iReg < (Int_t)GetRegionalHeaderCount(); iReg++)
+       {
+               AliMUONRegHeader regHeader;
+               AliMUONLocalStruct localStruct;
+               
+               const AliRegionalHeader* rh = GetRegionalHeader(iReg);
+               // Copy local structure and scalars and add everything into DDL object.
+               memcpy(regHeader.GetHeader(), rh->GetHeader(), sizeof(AliMUONRegionalHeaderStruct));
+               if (rh->GetScalars() != NULL)
+               {
+                       memcpy(regHeader.GetScalers(), rh->GetScalars(), sizeof(AliMUONRegionalScalarsStruct));
+               }
+               fDDLObject->AddRegHeader(regHeader);
+               
+               const AliLocalStruct* ls = rh->GetFirstLocalStruct();
+               while (ls != NULL)
+               {
+                       // Copy local structure and scalars and add everything into DDL object.
+                       memcpy(localStruct.GetData(), ls->GetData(), sizeof(AliMUONLocalInfoStruct));
+                       if (ls->GetScalars() != NULL)
+                       {
+                               memcpy(localStruct.GetScalers(), ls->GetScalars(), sizeof(AliMUONLocalScalarsStruct));
+                       }
+                       fDDLObject->AddLocStruct(localStruct, iReg);
+                       ls = ls->Next();
+               }
+       }
+       
+       return fDDLObject;
+}
+
+
 void AliMUONRawStreamTriggerHP::SetMaxRegAllowed(Int_t reg)
 {
        /// Set the maximum allowed number of regional cards in the DDL.
index 8f03cad7cb078ba638d8cdf15aa23e791ace1c50..b8bf625ad70071d487fad35a5bb794a0128465cb 100644 (file)
@@ -19,6 +19,8 @@
 #include "AliMUONTriggerDDLDecoder.h"
 #include "TArrayS.h"
 
+class AliMUONDDLTrigger;
+
 
 class AliMUONRawStreamTriggerHP : public AliMUONVRawStreamTrigger
 {
@@ -48,6 +50,9 @@ public:
                            UChar_t& xPos, Bool_t& triggerY, Bool_t& triggerX,
                            TArrayS& xPattern, TArrayS& yPattern);
        
+       /// Construct and return a pointer to the DDL payload object.
+       virtual AliMUONDDLTrigger* GetDDLTrigger() const;
+       
        /// Returns the next local trigger structure.
        const AliLocalStruct* Next();
        
@@ -711,6 +716,7 @@ private:
        const AliLocalStruct* fCurrentLocalStruct;  //!< The current local trigger structure being handled by Next().
        Bool_t fHadError;   //!< Flag indicating if there was a decoding error or not.
        Bool_t fDone;       //!< Flag indicating if the iteration is done or not.
+       mutable AliMUONDDLTrigger* fDDLObject; //!< Temporary DDL object used by GetDDLTrigger() for caching.
        
        static const Int_t  fgkMaxDDL;     //!< Maximum number of DDLs
        
index 36294ed48f7def74883f5995ced18bbb10c7a93c..b3225cb3a93f06c69f0667ad1283a5183d87422b 100644 (file)
 ///
 /// TRIGGERDISABLE : disable the treatment of MUON trigger
 ///
-/// USEFASTDECODER : makes the digit maker class use the high performance decoder
+/// USEFASTTRKDECODER : makes the digit maker class use the high performance decoder
 ///                  AliMUONTrackerDDLDecoder instead of AliMUONPayloadTracker.
 ///
+/// USEFASTTRGDECODER : makes the digit maker class use the high performance decoder
+///                  AliMUONTriggerDDLDecoder instead of AliMUONPayloadTrigger.
+///
+/// USEFASTDECODERS : makes the digit maker class use the high performance decoders
+///                  AliMUONTrackerDDLDecoder and AliMUONTriggerDDLDecoder.
+///
 /// \author Laurent Aphecetche, Subatech
 //-----------------------------------------------------------------------------
 
@@ -277,12 +283,24 @@ AliMUONReconstructor::CreateDigitMaker() const
 
   TString option = GetOption();
   Bool_t enableErrorLogging = kTRUE;
-  Bool_t useFastDecoder = kFALSE;
-  if (option.Contains("USEFASTDECODER"))
+  Bool_t useFastTrackerDecoder = kFALSE;
+  Bool_t useFastTriggerDecoder = kFALSE;
+  if (option.Contains("USEFASTTRKDECODER"))
+  {
+    useFastTrackerDecoder = kTRUE;
+  }
+  if (option.Contains("USEFASTTRGDECODER"))
+  {
+    useFastTriggerDecoder = kTRUE;
+  }
+  if (option.Contains("USEFASTDECODERS"))
   {
-    useFastDecoder = kTRUE;
+    useFastTrackerDecoder = kTRUE;
+    useFastTriggerDecoder = kTRUE;
   }
-  fDigitMaker = new AliMUONDigitMaker(enableErrorLogging, useFastDecoder);
+  fDigitMaker = new AliMUONDigitMaker(
+      enableErrorLogging, useFastTrackerDecoder, useFastTriggerDecoder
+    );
   option.ToUpper();
   if ( option.Contains("SAVEDIGITS" ))
     {
index 24b4a1e1d9b024296bd77731dcbabf820e300070..62e343a80eed426e21b02777d64ac99e9ddea366 100644 (file)
@@ -15,6 +15,8 @@
 
 #include "AliMUONRawStream.h"
 
+class AliMUONDDLTracker;
+
 class AliMUONVRawStreamTracker : public AliMUONRawStream
 {
 public:
@@ -33,6 +35,9 @@ public:
                                UShort_t& manuId, UChar_t& manuChannel,
                                UShort_t& adc) = 0;
        
+       /// Return pointer to DDL payload object.
+       virtual AliMUONDDLTracker* GetDDLTracker() const = 0;
+       
        /// Return maximum number of DDLs
        static Int_t GetMaxDDL() { return fgkMaxDDL; };
        
index 31c0976bc181a6ededcfd7c618ff507aaf8b22fe..1d9c7131b75462ce669ed4450c41fcb5a8c20cdd 100644 (file)
@@ -19,6 +19,7 @@
 
 class TArrayS;
 class AliRawReader;
+class AliMUONDDLTrigger;
 
 class AliMUONVRawStreamTrigger : public AliMUONRawStream
 {
@@ -33,6 +34,9 @@ public:
                            UChar_t& xPos, Bool_t& triggerY, Bool_t& triggerX,
                            TArrayS& xPattern, TArrayS& yPattern) = 0;
        
+       /// Return pointer to DDL payload object.
+       virtual AliMUONDDLTrigger* GetDDLTrigger() const = 0;
+       
        /// Return maximum number of DDLs
        virtual Int_t GetMaxDDL() const = 0;
        /// Return maximum number of regional cards in DATE file
@@ -40,6 +44,7 @@ public:
        /// Return maximum number of local cards in DATE file
        virtual Int_t GetMaxLoc() const = 0;
        
+       /// Should set the maximum number of local cards expected in the DDL stream.
        virtual void SetMaxLoc(Int_t loc) = 0;
        
        /// Return number of DDL
index 64c76489488be65d7b4635b27b810e90ce4e25d8..ec962046c073eb6cbdcac29542cc3d67af7655c6 100755 (executable)
@@ -8,6 +8,7 @@ RECONSTRUCTION=1 # will perform reconstruction
 CHECKS=1 # will perform checks
 NEVENTS=100 # will simulate 100 events
 
+#RECOPTIONS="SAVEDIGITS USEFASTDECODERS" # reconstruction options with fast decoders
 RECOPTIONS="SAVEDIGITS" # default reconstruction options
 SIMCONFIG="$ALICE_ROOT/MUON/Config.C" # default simulation configuration file
 OUTDIR=""
index 217f1d2130051e6f77606ccf2b1dd3285ad838c8..ac062eeb18e0984068a10758bce78db55195e047 100644 (file)
@@ -211,7 +211,8 @@ void Config(char directory[100]="", char option[6]="param", const char* digitsto
   //MUON->SetDigitizerWithNoise(kFALSE);
 
   // Use fast raw data decoder
-  // MUON->SetFastDecoder(kTRUE);  
+  //MUON->SetFastTrackerDecoder(kTRUE);  
+  //MUON->SetFastTriggerDecoder(kTRUE);  
   
   //
   // If SetAlign, the detection elements transformations
index 11d750bee358eca138cda70b3dab1742d80db74a..ed5aa5c4b1b99d08d79c89850faa73b5de93ba05 100644 (file)
@@ -74,11 +74,41 @@ For trigger raw data, local response output
 .includepath $ALICE_ROOT/MUON
 .includepath $ALICE_ROOT/RAW
 .L $ALICE_ROOT/MUON/MUONRawStreamTrigger.C+ 
-MUONRawStreamTriggerSimple(maxEvent, firstDDL, lastDDL, rawFileName)
+MUONRawStreamTriggerSimple(maxEvent, rawFileName)
 </pre>
 
+Similarly there is a high performance decoder available for the trigger DDLs,
+which can be run as follows for full output:
+<pre>
+.includepath $ALICE_ROOT/STEER
+.includepath $ALICE_ROOT/MUON
+.includepath $ALICE_ROOT/RAW
+.L $ALICE_ROOT/MUON/MUONRawStreamTrigger.C+
+MUONRawStreamTriggerHPExpert(maxEvent, firstDDL, lastDDL, rawFileName)
+</pre>
 
-Default wise the macro read all DDL files from the current directory for 1000 events.
+And just for local response output like so:
+<pre>
+.includepath $ALICE_ROOT/STEER
+.includepath $ALICE_ROOT/MUON
+.includepath $ALICE_ROOT/RAW
+.L $ALICE_ROOT/MUON/MUONRawStreamTrigger.C+
+MUONRawStreamTriggerHPSimple(maxEvent, rawFileName)
+</pre>
+
+The MUONRawStreamTrigger.C macro also provides other alternative implementations
+for fetching the decoded data from the trigger high performance decoder's interface.
+These generate the same output, but show how to write code to fetch the data in
+various ways from the interface. Developers should consult the macro as an example
+of how to use the interface. The alternate methods are called:
+<pre>
+MUONRawStreamTriggerHPExpert2()
+MUONRawStreamTriggerHPExpert3()
+MUONRawStreamTriggerHPSimple2()
+</pre>
+
+
+Default wise the macros read all DDL files from the current directory for 1000 events.
 For root file rawFileName must end with .root. For DDL files you have to specified the directory 
 where the raw0...n subdirectories are located:
 <pre>
@@ -87,15 +117,23 @@ MUONRawStreamTracker(..)(maxEvent, firstDDL, lastDDL, "$YOUR_WORKING_DIRECTORY/"
 
 \section raw_s2 Timing of the raw data decoders
 
-The macro MUONTimeRawStreamTracker.C can used to check the timing (speed) performance 
-of the existing offline decoder for the tracker DDLs (AliMUONRawStreamTracker) and also 
-for the new high performance decoder (AliMUONRawStreamTrackerHP). It can be invoked 
-as follows:
+The macro MUONTimeRawStreamTracker.C and MUONTimeRawStreamTrigger.C can used to
+check the timing (speed) performance of the existing offline decoders compared to
+the new high performance decoders.
+For the tracker DDLs the MUONTimeRawStreamTracker.C macro compares the timing of
+AliMUONRawStreamTracker against the high performance AliMUONRawStreamTrackerHP
+decoder.
+Similarly the MUONTimeRawStreamTrigger.C macro compares the timing of the
+existing AliMUONRawStreamTrigger decoder against the high performance
+AliMUONRawStreamTrackerHP decoder.
+The macros can be invoked as follows:
 
 <pre>
  $ aliroot
 .L $ALICE_ROOT/MUON/MUONTimeRawStreamTracker.C+
  MUONTimeRawStreamTracker(filename, maxEvent);
+.L $ALICE_ROOT/MUON/MUONTimeRawStreamTrigger.C+
+ MUONTimeRawStreamTrigger(filename, maxEvent);
 </pre>
 
 where \em filename is the name of a file containing the raw data, or alternatively
@@ -105,13 +143,13 @@ data. The \em maxEvent value is the maximum event to process (default set to
 [0 .. maxEvent-1].
 
 
-\section raw_s3 Special flags for high performance tracker DDL decoder.
+\section raw_s3 Special flags for high performance tracker and trigger DDL decoders.
 
 There are three flags that are available through the AliMUONRawStreamTrackerHP
 interface, which effect the decoding of raw data in special ways.
-\li TryRecover
-\li AutoDetectTrailer
-\li CheckForTrailer
+\li TryRecover (default = false)
+\li AutoDetectTrailer (default = true)
+\li CheckForTrailer  (default = true)
 
 The TryRecover flag is used to enable special logic in the decoder that tries
 to recover from a partially corrupt raw data structure header, or a corrupt/missing
@@ -155,6 +193,22 @@ Bool_t value = decoder.TryRecover();
 Similarly, the other flags are manipulated with corresponding methods having
 the same name as the flag.
 
+The trigger DDL decoder AliMUONRawStreamTriggerHP has the following flag available:
+\li TryRecover (default = false)
+
+For the AliMUONRawStreamTriggerHP decoder the TryRecover flag can be set in the
+same way as for AliMUONRawStreamTrackerHP, with a call to the TryRecover() method.
+For trigger DDLs this option will enable logic, which attempts to find the next
+correct header / structure marker key in the DDL stream, whenever such a marker
+has been found corrupt or missing. Decoding then continues from the new location
+found or stops if no good key was found. The default setting is to disable this
+logic, since it is only useful to try recover corrupted data.
+
+\note Raw data containing software scalars (Start-of-Data events for example)
+from the trigger detector taken during the Feb-March 2008 cosmics run is corrupt,
+but can be successfully decoded by enabling this TryRecover flag for the
+trigger DDL decoder.
+
 
 This chapter is defined in the READMEraw.txt file.