Merge b5b3522 into sapling-pr-archive-ktf

Author: ktf

Detectors/CTP/simulation/src/Digitizer.cxx

@@ -43,6 +43,7 @@ std::vector<CTPDigit> Digitizer::process(const gsl::span<o2::ctp::CTPInputDigit>
   std::vector<CTPDigit> digits;
   for (auto const& hits : predigits) {
     std::bitset<CTP_NINPUTS> inpmaskcoll = 0;
+    auto currentIR = hits.first;
     for (auto const inp : hits.second) {
       switch (inp->detector) {
         case o2::detectors::DetID::FT0: {
@@ -81,17 +82,17 @@ std::vector<CTPDigit> Digitizer::process(const gsl::span<o2::ctp::CTPInputDigit>
             std::bitset<CTP_NINPUTS> emcMBaccept;
             emcMBaccept.set(CTP_NINPUTS - 1, 1);
             inpmaskcoll |= emcMBaccept;
-          } else {
+          } // else { // needs to be done always, remove else
             for (auto const& ctpinp : det2ctpinp[o2::detectors::DetID::EMC]) {
               uint64_t mask = inpmaskdebug & detInputName2Mask[ctpinp.name];
               // uint64_t mask = (inp->inputsMask).to_ullong() & detInputName2Mask[ctpinp.name];
               if (mask) {
                 inpmaskcoll |= std::bitset<CTP_NINPUTS>(ctpinp.inputMask);
               }
             }
-          }
-          LOG(info) << "EMC input mask:" << inpmaskcoll;
-          break;
+            // }
+            // LOG(info) << "EMC input mask:" << inpmaskcoll << " with IR = " << currentIR.bc << ", orbit = " << currentIR.orbit;
+            break;
         }
         case o2::detectors::DetID::PHS: {
           for (auto const& ctpinp : det2ctpinp[o2::detectors::DetID::PHS]) {
@@ -132,7 +133,8 @@ std::vector<CTPDigit> Digitizer::process(const gsl::span<o2::ctp::CTPInputDigit>
       data.CTPInputMask = inpmaskcoll;
       data.CTPClassMask = classmask;
       digits.emplace_back(data);
-      LOG(info) << "Trigger-Event " << data.intRecord.bc << " " << data.intRecord.orbit << " Input mask:" << inpmaskcoll;
+      LOG(info) << "Trigger-Event " << data.intRecord.bc << " " << data.intRecord.orbit << " Input mask:" << inpmaskcoll << " with IR = " << data.intRecord.bc << ", orbit = " << data.intRecord.orbit;
+      // LOG(info) << "Trigger-Event " << data.intRecord.bc << " " << data.intRecord.orbit << " Class mask:" << data.CTPClassMask << " with IR = " << data.intRecord.bc << ", orbit = " << data.intRecord.orbit;
     }
   }
   return std::move(digits);
@@ -160,12 +162,12 @@ void Digitizer::calculateClassMask(const std::bitset<CTP_NINPUTS> ctpinpmask, st
             classmask |= tcl.classMask;
             LOG(info) << "adding MBA:" << tcl.name;
           }
-        } else {
+        } // else {
           // EMCAL rare triggers - physical trigger input
           // class identification can be handled like in the case of the other
           // classes as EMCAL trigger input is required
           classmask |= tcl.classMask;
-        }
+          // }
       }
     } else {
       if ((ctpinpmask.to_ullong() & tcl.descriptor->getInputsMask()) == tcl.descriptor->getInputsMask()) {

Detectors/EMCAL/simulation/CMakeLists.txt

@@ -13,7 +13,7 @@ o2_add_library(EMCALSimulation
                SOURCES src/Detector.cxx src/Digitizer.cxx src/DigitizerTRU.cxx src/SDigitizer.cxx
                        src/DigitsWriteoutBuffer.cxx src/DigitsWriteoutBufferTRU.cxx src/LZEROElectronics.cxx src/TRUElectronics.cxx src/DigitsVectorStream.cxx src/SpaceFrame.cxx src/SimParam.cxx
                        src/LabeledDigit.cxx src/RawWriter.cxx
-               PUBLIC_LINK_LIBRARIES ROOT::TreePlayer O2::EMCALBase O2::DetectorsBase O2::SimConfig O2::SimulationDataFormat O2::Headers O2::DetectorsRaw O2::EMCALReconstruction O2::DataFormatsCTP)
+               PUBLIC_LINK_LIBRARIES ROOT::TreePlayer O2::EMCALBase O2::DetectorsBase O2::SimConfig O2::SimulationDataFormat O2::Headers O2::DetectorsRaw O2::EMCALReconstruction O2::EMCALCalib O2::DataFormatsCTP)
 
 o2_target_root_dictionary(EMCALSimulation
                           HEADERS include/EMCALSimulation/Detector.h

Detectors/EMCAL/simulation/include/EMCALSimulation/DigitizerTRU.h

@@ -31,6 +31,7 @@
 #include "SimulationDataFormat/MCTruthContainer.h"
 #include "DataFormatsEMCAL/TriggerRecord.h"
 #include "CommonUtils/TreeStreamRedirector.h"
+#include "EMCALCalib/FeeDCS.h"
 
 namespace o2
 {
@@ -40,6 +41,7 @@ class TreeStreamRedirector;
 }
 namespace emcal
 {
+class FeeDCS;
 
 /// \class DigitizerTRU
 /// \brief EMCAL DigitizerTRU, digitizes with the help of a temporary description based upon a pol9*Heavyside
@@ -79,6 +81,13 @@ class DigitizerTRU
   /// Sets geometry for trigger mapping
   void setGeometry(o2::emcal::Geometry* gm) { mGeometry = gm; }
 
+  /// Sets FEE DCS for the masking of the fastOrs
+  void setFEE(o2::emcal::FeeDCS* fees) { mFeeDCS = fees; }
+
+  /// Sets the masked fastOrs from the CCDB in the LZERO
+  void setMaskedFastOrsInLZERO();
+  void printMaskedFastOrsInLZERO();
+
   void setWindowStartTime(int time) { mTimeWindowStart = time; }
   void setDebugStreaming(bool doStreaming) { mEnableDebugStreaming = doStreaming; }
 
@@ -101,12 +110,20 @@ class DigitizerTRU
   /// Getter for debug mode
   bool isDebugMode() { return mEnableDebugStreaming; }
 
+  /// Getter for triggers
+  const std::vector<EMCALTriggerInputs>& getTriggerInputs() { return LZERO.getTriggerInputs(); }
+
   /// Getter for patches
   std::vector<TRUElectronics> getPatchesVector() { return patchesFromAllTRUs; }
 
   /// raw pointers used here to allow interface with TF1
   static double rawResponseFunction(double* x, double* par);
 
+  /// Utility functions obtained from QC for EMC
+  int GetTRUIndexFromSTUIndex(Int_t id, Int_t detector);
+  int GetChannelForMaskRun2(int mask, int bitnumber, bool onethirdsm);
+  std::vector<int> GetAbsFastORIndexFromMask();
+
  private:
   short mEventTimeOffset = 0;        ///< event time difference from trigger time (in number of bins)
   bool mSmearEnergy = true;          ///< do time and energy smearing
@@ -134,6 +151,7 @@ class DigitizerTRU
   std::unique_ptr<o2::utils::TreeStreamRedirector> mDebugStream = nullptr;
   // std::unique_ptr<o2::utils::TreeStreamRedirector> mDebugStreamPatch = nullptr;
   bool mEnableDebugStreaming = false;
+  o2::emcal::FeeDCS* mFeeDCS; ///< EMCAL FEE DCS
 
   ClassDefNV(DigitizerTRU, 1);
 };

Detectors/EMCAL/simulation/include/EMCALSimulation/LZEROElectronics.h

@@ -39,6 +39,8 @@ namespace emcal
 /// \param mLastTimesumAllFastOrs Vector of tuples with TRU ID, FastOrID with STU indexing, and their last Timesums
 struct EMCALTriggerInputs {
   o2::InteractionRecord mInterRecord;                               ///< Last known interaction record
+  int mTriggeredTRU;                                                ///< Trigger TRU
+  std::vector<int> mTriggeredPatches;                               ///< Trigger patches, in local STU indexing
   std::vector<std::tuple<int, int, double>> mLastTimesumAllFastOrs; ///< TRU ID, FastOrID with STU indexing, and its last Timesum
 };
 
@@ -76,6 +78,10 @@ class LZEROElectronics
   /// Sets geometry for trigger mapping
   void setGeometry(o2::emcal::Geometry* gm) { mGeometry = gm; }
 
+  /// Sets the masked fastOrs from the CCDB in the LZERO
+  void setMaskedFastOrs(std::vector<int> const& maskedfastors) { mMaskedFastOrs = maskedfastors; }
+  void printMaskedFastOrs();
+
   /// Set Threshold for LZERO algorithm
   /// \param threshold LZERO algorithm threshold
   void setThreshold(double threshold) { mThreshold = threshold; }
@@ -104,7 +110,7 @@ class LZEROElectronics
 
   /// Getter for the pattern of peaks found by the LZERO algorithm
   /// \param p TRUElectronics object
-  const std::vector<int>& getFiredPatches(TRUElectronics& p) const
+  const std::vector<int>& getFiredPatches(TRUElectronics const& p) const
   {
     return p.mFiredPatches;
   }
@@ -131,6 +137,7 @@ class LZEROElectronics
   // const SimParam* mSimParam = nullptr;                 ///< SimParam object
   std::vector<EMCALTriggerInputs> mTriggers;           ///< Triggers to be sent out
   std::vector<EMCALTriggerInputsPatch> mTriggersPatch; ///< Triggers to be sent out
+  std::vector<int> mMaskedFastOrs;                     ///< Masked fastOrs from CCDB
   bool mSimulateNoiseDigits = true;                    ///< simulate noise digits
   // TriggerMappingV2* mTriggerMap = nullptr;             ///< Trigger map to properly assign an absolute FastOr to TRU FastOr
   Geometry* mGeometry = nullptr; ///< EMCAL geometry

Detectors/EMCAL/simulation/src/DigitizerTRU.cxx

@@ -12,6 +12,7 @@
 #include "EMCALSimulation/DigitizerTRU.h"
 #include "EMCALSimulation/SimParam.h"
 #include "EMCALSimulation/DigitsWriteoutBuffer.h"
+#include "EMCALCalib/FeeDCS.h"
 #include "DataFormatsEMCAL/Digit.h"
 #include "EMCALBase/Hit.h"
 #include "MathUtils/Cartesian.h"
@@ -436,4 +437,78 @@ void DigitizerTRU::finish()
   if (isDebugMode() == true) {
     endDebugStream();
   }
-}
+}
+//______________________________________________________________________
+int DigitizerTRU::GetTRUIndexFromSTUIndex(Int_t id, Int_t detector)
+{
+  Int_t kEMCAL = 0;
+  Int_t kDCAL = 1;
+
+  if ((id > 31 && detector == kEMCAL) || (id > 13 && detector == kDCAL) || id < 0) {
+    return -1; // Error Condition
+  }
+
+  if (detector == kEMCAL) {
+    return id;
+  } else if (detector == kDCAL) {
+    return 32 + ((int)(id / 4) * 6) + ((id % 4 < 2) ? (id % 4) : (id % 4 + 2));
+  }
+  return -1;
+}
+//______________________________________________________________________
+int DigitizerTRU::GetChannelForMaskRun2(int mask, int bitnumber, bool onethirdsm)
+{
+  if (onethirdsm) {
+    return mask * 16 + bitnumber;
+  }
+  const int kChannelMap[6][16] = {{8, 9, 10, 11, 20, 21, 22, 23, 32, 33, 34, 35, 44, 45, 46, 47},    // Channels in mask0
+                                  {56, 57, 58, 59, 68, 69, 70, 71, 80, 81, 82, 83, 92, 93, 94, 95},  // Channels in mask1
+                                  {4, 5, 6, 7, 16, 17, 18, 19, 28, 29, 30, 31, 40, 41, 42, 43},      // Channels in mask2
+                                  {52, 53, 54, 55, 64, 65, 66, 67, 76, 77, 78, 79, 88, 89, 90, 91},  // Channels in mask3
+                                  {0, 1, 2, 3, 12, 13, 14, 15, 24, 25, 26, 27, 36, 37, 38, 39},      // Channels in mask4
+                                  {48, 49, 50, 51, 60, 61, 62, 63, 72, 73, 74, 75, 84, 85, 86, 87}}; // Channels in mask5
+  return kChannelMap[mask][bitnumber];
+}
+//______________________________________________________________________
+std::vector<int> DigitizerTRU::GetAbsFastORIndexFromMask()
+{
+  TriggerMappingV2 mTriggerMap(mGeometry);
+  std::vector<int> maskedfastors;
+  int itru = 0;
+  for (Int_t i = 0; i < 46; i++) {
+    int localtru = itru % 32, detector = itru >= 32 ? 1 : 0,
+        globaltru = GetTRUIndexFromSTUIndex(localtru, detector);
+    bool onethirdsm = ((globaltru >= 30 && globaltru < 32) || (globaltru >= 50 && globaltru < 52));
+    for (int ipos = 0; ipos < 6; ipos++) {
+      auto regmask = mFeeDCS->getTRUDCS(i).getMaskReg(ipos);
+      std::bitset<16> bitsregmask(regmask);
+      for (int ibit = 0; ibit < 16; ibit++) {
+        if (bitsregmask.test(ibit)) {
+          auto channel = GetChannelForMaskRun2(ipos, ibit, onethirdsm);
+          int absfastor = mTriggerMap.getAbsFastORIndexFromIndexInTRU(globaltru, channel);
+          maskedfastors.push_back(absfastor);
+        }
+      }
+    }
+    itru++;
+  }
+  return maskedfastors;
+}
+//______________________________________________________________________
+void DigitizerTRU::setMaskedFastOrsInLZERO()
+{
+  auto maskedFastOrs = GetAbsFastORIndexFromMask();
+  LOG(info) << "======================================";
+  LOG(info) << "== PRINT MASK COMPUTED IN DIGITIZER ==";
+  int counter = 0;
+  for (auto fastOr : maskedFastOrs) {
+    LOG(info) << "fastOr masked (number, ID) = (" << counter << ", " << fastOr;
+    counter += 1;
+  }
+  LZERO.setMaskedFastOrs(maskedFastOrs);
+}
+//______________________________________________________________________
+void DigitizerTRU::printMaskedFastOrsInLZERO()
+{
+  LZERO.printMaskedFastOrs();
+}

Detectors/EMCAL/simulation/src/DigitsWriteoutBufferTRU.cxx

@@ -56,6 +56,7 @@ void DigitsWriteoutBufferTRU::fillOutputContainer(bool isEndOfTimeFrame, Interac
     //   LZERO.updatePatchesADC(patches);
     //   LZERO.peakFinderOnAllPatches(patches);
     // }
+    LOG(debug) << "DIG TRU fillOutputContainer in DigitsWriteoutBufferTRU: LOW IR";
 
     mCurrentInteractionRecord = nextInteractionRecord;
     clear();
@@ -94,6 +95,8 @@ void DigitsWriteoutBufferTRU::fillOutputContainer(bool isEndOfTimeFrame, Interac
       }
     }
     reserve(15);
+
+    LOG(debug) << "DIG TRU fillOutputContainer in DigitsWriteoutBufferTRU: HIGH IR";
   }
 }
 //________________________________________________________

Detectors/EMCAL/simulation/src/LZEROElectronics.cxx

@@ -113,13 +113,11 @@ void LZEROElectronics::fill(const std::deque<o2::emcal::DigitTimebinTRU>& digitl
     // At the end of the loop run the peak finder
     // Ship to LONEElectronics in case a peak is found
     // Entire logic limited to timebin by timebin -> effectively implementing time scan
-
     counterDigitTimeBin++;
 
     for (auto& [fastor, digitsList] : *digitsTimeBin.mDigitMap) {
       // Digit loop
       // The peak finding algorithm is run after getting out of the loop!
-
       if (digitsList.size() == 0) {
         continue;
       }
@@ -154,7 +152,10 @@ void LZEROElectronics::fill(const std::deque<o2::emcal::DigitTimebinTRU>& digitl
       auto whichFastOr = std::get<1>(mTriggerMap.convertFastORIndexTRUtoSTU(whichTRU, whichFastOrTRU));
       auto& patchTRU = patchesFromAllTRUs[whichTRU];
       auto& fastOrPatchTRU = patchTRU.mFastOrs[whichFastOr];
-      fastOrPatchTRU.updateADC(summedDigit.getAmplitudeADC());
+      // fastOrPatchTRU.updateADC(summedDigit.getAmplitudeADC());
+      if (std::find(mMaskedFastOrs.begin(), mMaskedFastOrs.end(), fastor) != mMaskedFastOrs.end()) {
+        fastOrPatchTRU.updateADC(summedDigit.getAmplitudeADC());
+      }
 
       digIndex++;
     }
@@ -172,13 +173,21 @@ void LZEROElectronics::fill(const std::deque<o2::emcal::DigitTimebinTRU>& digitl
     // It accounts for the difference in times between L0a, L0b, and then there will be a L1 and L1b delay
     // There is 1BC uncertainty on the trigger readout due to steps in the interaction between CTP and detector simulations
     bool foundPeak = false;
+    int counterWhichTRU = 0;
+    int triggeredTRU = -1;
+    std::vector<int> triggeredPatches;
     for (auto& patches : patchesFromAllTRUs) {
       updatePatchesADC(patches);
       bool foundPeakCurrentTRU = peakFinderOnAllPatches(patches);
       auto firedPatches = getFiredPatches(patches);
+      if (foundPeakCurrentTRU == true && foundPeak == false) {
+        triggeredTRU = counterWhichTRU;
+        triggeredPatches = firedPatches;
+      }
       if (foundPeakCurrentTRU) {
         foundPeak = true;
       }
+      counterWhichTRU += 1;
     }
 
     if (foundPeak == true) {
@@ -187,6 +196,8 @@ void LZEROElectronics::fill(const std::deque<o2::emcal::DigitTimebinTRU>& digitl
     EMCALTriggerInputs TriggerInputsForL1;
     if (foundPeak) {
       TriggerInputsForL1.mInterRecord = record;
+      TriggerInputsForL1.mTriggeredTRU = triggeredTRU;
+      TriggerInputsForL1.mTriggeredPatches = triggeredPatches;
       int whichTRU = 0;
       for (auto& patches : patchesFromAllTRUs) {
         int whichFastOr = 0;
@@ -228,3 +239,14 @@ void LZEROElectronics::fill(const std::deque<o2::emcal::DigitTimebinTRU>& digitl
     }
   }
 }
+//________________________________________________________
+void LZEROElectronics::printMaskedFastOrs()
+{
+  LOG(info) << "===============================";
+  LOG(info) << "== PRINT MASK SAVED IN LZERO ==";
+  int counter = 0;
+  for (auto fastOr : mMaskedFastOrs) {
+    LOG(info) << "fastOr masked (number, ID) = (" << counter << ", " << fastOr;
+    counter += 1;
+  }
+}

Detectors/EMCAL/workflow/include/EMCALWorkflow/EMCALDigitizerSpec.h

@@ -23,6 +23,7 @@
 #include "EMCALSimulation/SDigitizer.h"
 #include "SimulationDataFormat/MCTruthContainer.h"
 #include <DetectorsBase/BaseDPLDigitizer.h>
+#include "EMCALSimulation/DigitizerTRU.h"
 
 class TChain;
 
@@ -90,6 +91,10 @@ class DigitizerSpec final : public o2::base::BaseDPLDigitizer, public o2::framew
   std::vector<TChain*> mSimChains;
   o2::ctp::CTPConfiguration* mCTPConfig; ///< CTP configuration
   o2::steer::MCKinematicsReader* mcReader; ///< reader to access MC collision information
+
+  DigitizerTRU mDigitizerTRU;             ///< Digitizer object TRU
+  o2::emcal::SDigitizer mSumDigitizerTRU; ///< Summed digitizer TRU
+  bool mRunDigitizerTRU = true;           ///< Run Digitizer TRU?
 };
 
 /// \brief Create new digitizer spec