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 b1ccdef..a6765b4 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 5bafa39..b704704 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 57b0c01..bbb88d0 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);
 
@@ -373,6 +394,114 @@ AliMUONDigitMaker::ReadTriggerDDL(AliRawReader* rawReader)
 }
 
 //____________________________________________________________________
+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,
                                        AliMUONVDigitStore& digitStore) const
@@ -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 7b1aa7f..a90c87d 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 4893733..bf90495 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 341cfb7..3e16a87 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 f2c0b9c..1e4df43 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 8f03cad..b8bf625 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 36294ed..b3225cb 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 24b4a1e..62e343a 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 31c0976..1d9c713 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 64c7648..ec96204 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 217f1d2..ac062ee 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 11d750b..ed5aa5c 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.