Adaptation to Run2 format (Jussi Viinikainen)
authorpolicheh <Boris.Polishchuk@cern.ch>
Fri, 19 Sep 2014 11:38:51 +0000 (15:38 +0400)
committerpolicheh <Boris.Polishchuk@cern.ch>
Fri, 19 Sep 2014 11:38:51 +0000 (15:38 +0400)
PHOS/AliPHOSTRURawReader.cxx
PHOS/AliPHOSTRURawReader.h
PHOS/AliPHOSTriggerRawDigiProducer.cxx

index 01c7ac9..86eb787 100644 (file)
 
 /* $Id$ */
 
-/* 
+/*
  * Class for reading TRU data from a bunch from a raw datastream.
  * Author: Henrik Qvigstad <henrik.qvigstad@cern.ch>
+ * Author: Jussi Viinikainen <jussi.viinikainen@cern.ch> (adaptation to Run2 format)
  */
 
 #include "AliPHOSTRURawReader.h"
 
 #include "AliCaloRawStreamV3.h"
-#include <bitset> // std::bitset
 
 ClassImp(AliPHOSTRURawReader)
 
 
 //________________________________________________________________
 AliPHOSTRURawReader::AliPHOSTRURawReader()
-  : TObject(),
-    fSignals(),
-    fFlags(),
-    fActive(false),
-    fHasSignal(false),
-    fActiveTime(),
-    fHasSignalTime()
-
+: TObject(),
+fSignals(),
+fFlags(),
+fFlags2x2(),
+fActive(false),
+fHasSignal(false),
+fActiveTime(),
+fHasSignalTime(),
+fUse4x4Flags(false)
 {
   // default constructor
   
   // fSignals Initialization:
-  for(Int_t row = 0; row < kN2x2XPrTRURow; ++row) {
-    for(Int_t branch = 0; branch < kN2x2ZPrBranch; ++branch) {
-      for(Int_t timeBin = 0; timeBin < kNTimeBins; ++timeBin) {
-       fSignals[row][branch][timeBin] = kDefaultSignalValue;
+  for(Int_t row = 0; row < fgkN2x2XPrTRURow; ++row) {
+    for(Int_t branch = 0; branch < fgkN2x2ZPrBranch; ++branch) {
+      for(Int_t timeBin = 0; timeBin < fgkNTimeBins; ++timeBin) {
+        fSignals[row][branch][timeBin] = fgkDefaultSignalValue;
+        fFlags2x2[row][branch][timeBin] = kFALSE;
       }
     }
   }
-      
+  
   // fFlags Initialization
-  for(Int_t row = 0; row < kN4x4XPrTRURow; ++row){
-    for(Int_t branch = 0; branch < kN4x4ZPrBranch; ++branch){
-      for(Int_t timeBin = 0; timeBin < kNTimeBins; ++timeBin){
-       fFlags[row][branch][timeBin] = kFALSE;
+  for(Int_t row = 0; row < fgkN4x4XPrTRURow; ++row){
+    for(Int_t branch = 0; branch < fgkN4x4ZPrBranch; ++branch){
+      for(Int_t timeBin = 0; timeBin < fgkNTimeBins; ++timeBin){
+        fFlags[row][branch][timeBin] = kFALSE;
       }
     }
   }
   
   // fActiveTime Initialization
-  for(Int_t timeBin = 0; timeBin < kNTimeBins; ++timeBin){
+  for(Int_t timeBin = 0; timeBin < fgkNTimeBins; ++timeBin){
     fActiveTime[timeBin] = kFALSE;
     fHasSignalTime[timeBin] = kFALSE;
   }
@@ -76,60 +78,112 @@ AliPHOSTRURawReader::~AliPHOSTRURawReader()
 //________________________________________________________________
 void AliPHOSTRURawReader::ReadFromStream(AliCaloRawStreamV3* rawStream)
 {
- // reads the trigger signal amplitudes and trigger flags from the rawStream
+  // reads the trigger signal amplitudes and trigger flags from the rawStream
   
   const UShort_t * const signal = rawStream->GetSignals(); // stream of 10-bit words, buffered as 16-bit words
-  const Int_t signalLength = rawStream->GetBunchLength();
-  const Int_t timeBin = rawStream->GetHWAddress() & 0x7f; // , i.e. & '01111111', strips the first 7 bits ([0:6]) and interprits it as a int
-
-  // TODO: this may need to be an error
-  if(signalLength != 16 && signalLength != 16+112)
-    Warning("ReadFromStream", " signalLength: !16 && !16+112, reader logic may not be valid.");
+  const Int_t signalLength = rawStream->GetBunchLength();  // The length of the signal in time steps
+  const Int_t channelIndex = rawStream->GetColumn();  // For some reason the index of the readout channel is given by GetColumn function
   
-
-  fActive = kTRUE;
-  fActiveTime[timeBin] = kTRUE;
-
-  /* There are 91 4x4 Sliding Window signal sum trigger flags.
-   * We read the trigger location information from first 12 10-bit words of the signal
-   * (these are buffered to 12 16-bit words in the rawstream object)
-   * , but only 10 of the 10-bit words are used for trigger location within the TRU.
-   * The flags are found in word_2[0] to word_11[9].
-   * We read the information as following. */
-
-  for(Int_t wIdx = 2; wIdx < 12; ++wIdx) { // words
-    const std::bitset<10> word(signal[wIdx]); // @param word represent a 10-bit word
-    for(Int_t bIdx = 0; bIdx < 10; ++bIdx) { // bits
-      //const Int_t index = 119 - (wIdx*10 + (9-bi)); // index used in TRU documentation,
-      const Int_t index = (110 - wIdx*10) + bIdx; // equivalent
-       if( index < 91 ) { // we are only interrested in these words/bits
-         const Int_t xIdx = index % 7; // x index in TRU internal 2x2 coordinate system
-         const Int_t zIdx = index / 7; // z index in TRU internal 2x2 coordinate system
-         // fFlags[xIdx][zIdx][time] = (signal[wIdx] & (0x01 * 2**i)) != 1;
-         fFlags[xIdx][zIdx][timeBin] = (bool) word[bIdx];
-       }
-    } // end bit loop
-  }// end word loop
-
-
-
-  /* The 2x2 trigger signal sum may follow.
-   * If so, it is found in the following 112 10-bit words
-   * (, 16-bit words in buffer.)
-   * We read the signal as following.
+  fActive = kTRUE; // Set the TRU active
+  
+  /* Channels in TRU:
+   *
+   * There are 112 readout channels and 12 channels reserved for production flags
+   * The channels are indexed as follows:
+   *
+   *  Channels 0-111: channel data readout
+   *  Channels 112-123: production flags
    */
-
-  if( 16+112 == signalLength) {
+  
+  Int_t timeBin = rawStream->GetStartTimeBin(); // Find the time bin of the first time step
+  
+  if(channelIndex < fgkNReadoutChannels){  // Channel data
+    
+    /* Channel data:
+     *
+     * The channel data is read one channel at a time
+     * The x and z indices corresponding to the channel are calculated from the channel index
+     */
+    
     fHasSignal = kTRUE;
-    fHasSignalTime[timeBin] = kTRUE;
-    for (Int_t idx = 0; idx < 112; idx++)
-      {
-       const Int_t xIdx = 7 - idx % 8;  // x index in TRU
-       const Int_t zIdx = 13 - idx / 8; // z index in TRU
-       const Int_t wIdx = idx + 16;     // word index in signal array
-       fSignals[xIdx][zIdx][timeBin] = signal[wIdx];
+    const Int_t xBin = 7 - channelIndex % 8;  // x index in TRU internal 2x2 coordinate system
+    const Int_t zBin = 13 - channelIndex / 8; // z index in TRU internal 2x2 coordinate system
+    
+    // Loop over all the time steps in the signal
+    for(Int_t i = 0; i < signalLength; i++){
+      fSignals[xBin][zBin][timeBin] = signal[i];
+      fActiveTime[timeBin] = kTRUE;
+      fHasSignalTime[timeBin] = kTRUE;
+      timeBin--; // The time bins come in reverse order from raw data
+    }
+  } else { // Production flags
+
+    /* Production flags:
+     *
+     * Production flags are supplied in channels 112 - 123
+     * Each of the channels is 10 bit wide
+     * The bits inside the channel (indexing starting from the first bit of channel 112) is as follows:
+     *
+     *  Bits 0-111: Trigger flags for corresponding channel index
+     *              If using 4x4 algorithm, only 91 first bits are used of these
+     *  Bit 112: Marker for 4x4 algorithm (1 active, 0 not active)
+     *  Bit 113: Marker for 2x2 algorithm (1 active, 0 not active)
+     *  Bit 114: Global L0 OR of all patches in the TRU
+     */
+    
+    Int_t channel, xBin, zBin;
+    for(Int_t i = 0; i < signalLength; i++){
+      fActiveTime[timeBin] = kTRUE;
+      
+      // If bit 112 is 1, we are considering 4x4 algorithm
+      if(channelIndex == fgkFinalProductionChannel){
+        if( (signal[i] & ( 1 << 2 )) > 0 ){ // Check the bit number 112
+          fUse4x4Flags = kTRUE;
+        }
       }
-  }
+      
+      // Assign the bits in the words to corresponding channels
+      for(Int_t bitIndex = 0; bitIndex < fgkWordLength; bitIndex++){
+        
+        /* Find the correct channel number assuming that
+         * channelIndex 112 = bits 0-9 corresponding trigger flags in channels 0-9
+         * channelIndex 113 = bits 10-19 corresponding trigger flags in channels 10-19
+         * and so on
+         */
+        channel = (channelIndex - fgkNReadoutChannels) * fgkWordLength + bitIndex;
+        
+        /*
+         * Note: flags corresponding to 2x2 sums and 4x4 sums need to be filled
+         *       in different loops since the internal xz coordinates are different
+         *       for 2x2 case and 4x4 case. We do not know which data we are filling
+         *       at the time we do the filling. This information comes only in the 
+          *      channel 123 in bit 112.
+         */
+        
+        if(channel < fgkNReadoutChannels){ // Fill histogram for 2x2 trigger flags
+          xBin = 7 - channel % 8;  // x index in TRU internal 2x2 coordinate system
+          zBin = 13 - channel / 8; // z index in TRU internal 2x2 coordinate system
+          
+          // check if the bit bitIndex is 1
+          if( (signal[i] & ( 1 << bitIndex )) > 0 ){
+            fFlags2x2[xBin][zBin][timeBin] = kTRUE;
+          }
+        }
+        
+        if(channel < fgkN4x4TriggerFlags){ // Fill histogram for 4x4 trigger flags
+          xBin = 6 - channel % 7;  // x index in TRU internal 4x4 coordinate system
+          zBin = 12 - channel / 7; // z index in TRU internal 4x4 coordinate system
+          
+          // check if the bit bitIndex is 1
+          if( (signal[i] & ( 1 << bitIndex )) > 0 ){
+            fFlags[xBin][zBin][timeBin] = kTRUE;
+          }
+        }
+      } // Bits in one word
+      timeBin--; // The time bins come in reverse order from raw data
+    } // Length of signal
+  } // Production flags
+  
 }
 
 
@@ -140,24 +194,34 @@ void AliPHOSTRURawReader::Reset()
   
   if( ! fActive )
     return;
-
-  for(Int_t timeBin = 0; timeBin < kNTimeBins; ++timeBin) { // loop timeBins
+  
+  for(Int_t timeBin = 0; timeBin < fgkNTimeBins; ++timeBin) { // loop timeBins
     if( fActiveTime[timeBin] ) {
-      for(Int_t xIdx = 0; xIdx < kN2x2XPrTRURow; ++xIdx) { // loop 2x2
-       for(Int_t zIdx = 0; zIdx < kN2x2ZPrBranch; ++zIdx) {
-         fSignals[xIdx][zIdx][timeBin] = kDefaultSignalValue;
-       } // zIdx
+      for(Int_t xIdx = 0; xIdx < fgkN2x2XPrTRURow; ++xIdx) { // loop 2x2
+        for(Int_t zIdx = 0; zIdx < fgkN2x2ZPrBranch; ++zIdx) {
+          fSignals[xIdx][zIdx][timeBin] = fgkDefaultSignalValue;
+          fFlags2x2[xIdx][zIdx][timeBin] = kFALSE;
+        } // zIdx
       } // xIdx
-      for(Int_t xIdx = 0; xIdx < kN4x4XPrTRURow; ++xIdx) { // loop 4x4
-       for(Int_t zIdx = 0; zIdx < kN4x4ZPrBranch; ++zIdx) {
-         fFlags[xIdx][zIdx][timeBin] = false;
-       } // zIdx
+      for(Int_t xIdx = 0; xIdx < fgkN4x4XPrTRURow; ++xIdx) { // loop 4x4
+        for(Int_t zIdx = 0; zIdx < fgkN4x4ZPrBranch; ++zIdx) {
+          fFlags[xIdx][zIdx][timeBin] = false;
+        } // zIdx
       } // xIdx
     }// end if fActiveTime
     fActiveTime[timeBin] = false;
     fHasSignalTime[timeBin] = false;
   } // timeBin
-
+  
   fActive = false;
   fHasSignal = false;
 }
+
+//___________________________________________________________________
+Bool_t AliPHOSTRURawReader::GetTriggerFlag(Int_t xIdx, Int_t zIdx, Int_t timeBin) const {
+  // Getter for trigger flags
+  if(fUse4x4Flags){
+    return fFlags[xIdx][zIdx][timeBin];
+  }
+  return fFlags2x2[xIdx][zIdx][timeBin];
+}
index d6aa4c1..10e3f63 100644 (file)
@@ -12,6 +12,7 @@ class AliCaloRawStreamV3;
 /* 
  * Class for reading TRU data from a bunch from a raw datastream.
  * Author: Henrik Qvigstad <henrik.qvigstad@cern.ch>
+ * Author: Jussi Viinikainen <jussi.viinikainen@cern.ch> (adaptation to Run2 format)
  */
 class AliPHOSTRURawReader : public TObject
 {
@@ -20,39 +21,44 @@ class AliPHOSTRURawReader : public TObject
   virtual ~AliPHOSTRURawReader();
 
   Short_t GetTriggerSignal(Int_t xIdx, Int_t zIdx, Int_t timeBin) const {return fSignals[xIdx][zIdx][timeBin];}
-  Bool_t GetTriggerFlag(Int_t xIdx, Int_t zIdx, Int_t timeBin) const {return fFlags[xIdx][zIdx][timeBin];}
-  bool IsActive() {return fActive;}
-  bool IsActive(Int_t timeBin) {return fActiveTime[timeBin];}
-  bool HasSignal() {return fHasSignal;}
-  bool HasSignal(Int_t timeBin) {return fHasSignalTime[timeBin];}
+  Bool_t GetTriggerFlag(Int_t xIdx, Int_t zIdx, Int_t timeBin) const;
+  bool IsActive() const {return fActive;}
+  bool IsActive(Int_t timeBin) const {return fActiveTime[timeBin];}
+  bool HasSignal() const {return fHasSignal;}
+  bool HasSignal(Int_t timeBin) const {return fHasSignalTime[timeBin];}
   
-  void ReadFromStream(AliCaloRawStreamV3* );
+  void ReadFromStream(AliCaloRawStreamV3* rawStream);
   void Reset();
-
+  
+  static Int_t GetDefaultSignalValue() { return fgkDefaultSignalValue; };
+  
  private:
   AliPHOSTRURawReader(const AliPHOSTRURawReader &); // not implemented
   AliPHOSTRURawReader& operator= (const AliPHOSTRURawReader &); // not implemented
   
- public:
-  const static Int_t kDefaultSignalValue = 512; // Default/Ideal TRU amplitude pedestal
-  
- private:  
   // constants
-  const static Int_t kNTimeBins = 128; // Number of timeBins
-  const static Int_t kN2x2XPrTRURow = 8; // (=64/2/4) Number of 2x2 pr. row
-  const static Int_t kN2x2ZPrBranch = 14; // (=56/2/2) Number of 2x2 pr. branch
-  const static Int_t kN4x4XPrTRURow = 7; // (=64/2/4 -1) Number of 4x4 pr. row
-  const static Int_t kN4x4ZPrBranch = 13; // (=56/2/2) -1 Number of 4x4 pr. branch
+  static const Int_t fgkDefaultSignalValue = 512; // Default/Ideal TRU amplitude pedestal
+  static const Int_t fgkNReadoutChannels = 112;  // number of readout channels in tru
+  static const Int_t fgkN4x4TriggerFlags = 91;  // number of possible 4x4 area in PHOS
+  static const Int_t fgkFinalProductionChannel = 123; // The last channel of production bits, contains markesr to choose between 2x2 and 4x4 algorithm
+  static const Int_t fgkWordLength = 10; // Length of one data word in raw data
+  static const Int_t fgkNTimeBins = 128; // Number of timeBins
+  static const Int_t fgkN2x2XPrTRURow = 8; // (=64/2/4) Number of 2x2 pr. row
+  static const Int_t fgkN2x2ZPrBranch = 14; // (=56/2/2) Number of 2x2 pr. branch
+  static const Int_t fgkN4x4XPrTRURow = 7; // (=64/2/4 -1) Number of 4x4 pr. row
+  static const Int_t fgkN4x4ZPrBranch = 13; // (=56/2/2) -1 Number of 4x4 pr. branch
   
-  Short_t fSignals[kN2x2XPrTRURow][kN2x2ZPrBranch][kNTimeBins]; // 2x2 Trigger Signal Sum, [x][z][t]
-  Bool_t  fFlags[kN4x4XPrTRURow][kN4x4ZPrBranch][kNTimeBins]; // 4x4 Trigger Flag, [x][z][t]
+  Short_t fSignals[fgkN2x2XPrTRURow][fgkN2x2ZPrBranch][fgkNTimeBins]; // 2x2 Trigger Signal Sum, [x][z][t]
+  Bool_t  fFlags[fgkN4x4XPrTRURow][fgkN4x4ZPrBranch][fgkNTimeBins]; // 4x4 Trigger Flag, [x][z][t]
+  Bool_t  fFlags2x2[fgkN2x2XPrTRURow][fgkN2x2ZPrBranch][fgkNTimeBins]; // 2x2 Trigger Flag, [x][z][t]
   
   Bool_t fActive; // Active
   Bool_t fHasSignal; // Has Signal
-  Bool_t fActiveTime[kNTimeBins]; // Active [t]
-  Bool_t fHasSignalTime[kNTimeBins]; // Has Signal [t]
+  Bool_t fActiveTime[fgkNTimeBins]; // Active [t]
+  Bool_t fHasSignalTime[fgkNTimeBins]; // Has Signal [t]
+  Bool_t fUse4x4Flags; // True is the 4x4 analysis bit (bit number 112) is 1, otherwise false
   
-  ClassDef(AliPHOSTRURawReader, 1)
+  ClassDef(AliPHOSTRURawReader, 2)
 };
 
 #endif // ALIPHOSTRURAWREADER_H
index 2c7ed9c..8f2e8ce 100644 (file)
@@ -146,7 +146,7 @@ int AliPHOSTriggerRawDigiProducer::Get2x2Signal(AliPHOSTriggerRawReader* reader,
     if( parameters )
       return signal - parameters->GetTRUPedestal(mod, TRURow, branch, TRUX, TRUZ);
     else
-      return signal - AliPHOSTRURawReader::kDefaultSignalValue;
+      return signal - AliPHOSTRURawReader::GetDefaultSignalValue();
   }
   else
     return 0;