[EMCAL-1055] Require FIT trigger in digitization

Triggering of collisons in the DigitsWriteoutBuffer is
based of FT0/FV0 detector trigger inputs. All FIT
triggers are accepted. The self-triggered mode stays
as option for EMCAL-only simulations.

Author: mfasDa

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

@@ -67,7 +67,7 @@ class Digitizer : public TObject
   /// Steer conversion of hits to digits
   void process(const std::vector<LabeledDigit>& labeledDigit);
 
-  void setEventTime(o2::InteractionTimeRecord record);
+  void setEventTime(o2::InteractionTimeRecord record, bool trigger);
   double getTriggerTime() const { return mDigits.getTriggerTime(); }
   double getEventTime() const { return mDigits.getEventTime(); }
   bool isLive(double t) const { return mDigits.isLive(t); }

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

@@ -81,7 +81,7 @@ class DigitsWriteoutBuffer
   unsigned int getBufferSize() const { return mBufferSize; }
 
   /// forward the marker for every 100 ns
-  void forwardMarker(o2::InteractionTimeRecord record);
+  void forwardMarker(o2::InteractionTimeRecord record, bool trigger);
 
   /// Setters for the live time, busy time, pre-trigger time
   void setLiveTime(unsigned int liveTime) { mLiveTime = liveTime; }

Detectors/EMCAL/simulation/src/Digitizer.cxx

@@ -233,10 +233,10 @@ double Digitizer::smearTime(double time, double energy)
 }
 
 //_______________________________________________________________________
-void Digitizer::setEventTime(o2::InteractionTimeRecord record)
+void Digitizer::setEventTime(o2::InteractionTimeRecord record, bool trigger)
 {
 
-  mDigits.forwardMarker(record);
+  mDigits.forwardMarker(record, trigger);
 
   mPhase = mSimParam->doSimulateL1Phase() ? mDigits.getPhase() : 0;
 

Detectors/EMCAL/simulation/src/DigitsVectorStream.cxx

@@ -125,7 +125,7 @@ void DigitsVectorStream::fill(std::deque<o2::emcal::DigitTimebin>& digitlist, o2
   mTriggerRecords.emplace_back(record, o2::trigger::PhT, mStartIndex, numberOfNewDigits);
   mStartIndex = mDigits.size();
 
-  LOG(info) << "Have " << mStartIndex << " digits ";
+  LOG(info) << "Trigger Orbit " << record.orbit << ", BC " << record.bc << ": have " << numberOfNewDigits << " digits (" << mStartIndex << " total)";
 }
 
 //_______________________________________________________________________

Detectors/EMCAL/simulation/src/DigitsWriteoutBuffer.cxx

@@ -19,6 +19,7 @@
 #include "EMCALSimulation/DigitsWriteoutBuffer.h"
 #include "CommonDataFormat/InteractionRecord.h"
 #include "TMath.h"
+#include <fairlogger/Logger.h>
 
 using namespace o2::emcal;
 
@@ -80,7 +81,7 @@ void DigitsWriteoutBuffer::addDigits(unsigned int towerID, std::vector<LabeledDi
 // is removed and pushed at the end of the past dequeue. At the same time a new entry in
 // the future dequeue is pushed at the end, and - in case the past dequeue reached 15 entries
 // the first entry of the past dequeue is removed.
-void DigitsWriteoutBuffer::forwardMarker(o2::InteractionTimeRecord record)
+void DigitsWriteoutBuffer::forwardMarker(o2::InteractionTimeRecord record, bool trigger)
 {
 
   unsigned long eventTime = record.getTimeNS();
@@ -124,7 +125,8 @@ void DigitsWriteoutBuffer::forwardMarker(o2::InteractionTimeRecord record)
 
   // If we have a trigger, all the time bins in the future buffer will be set to record mode
   // the last time bin will the end of the readout window since it will be mTriggerTime + 1500 ns
-  if ((eventTime - mTriggerTime) >= (mLiveTime + mBusyTime) || mFirstEvent) {
+  if (trigger && ((eventTime - mTriggerTime) >= (mLiveTime + mBusyTime) || mFirstEvent)) {
+    LOG(debug) << "Trigger received and accepted";
     mTriggerTime = eventTime;
     mTimedDigitsFuture.front().mTriggerColl = true;
     mTimedDigitsFuture.front().mInterRecord = record;
@@ -142,8 +144,8 @@ void DigitsWriteoutBuffer::forwardMarker(o2::InteractionTimeRecord record)
   }
 
   // If we have a pre-trigger collision, all the time bins in the future buffer will be set to record mode
-  if ((eventTime - mTriggerTime) >= (mLiveTime + mBusyTime - mPreTriggerTime)) {
-    std::cout << "Pre-trigger collision\n";
+  if ((eventTime - mTriggerTime) >= (mLiveTime + mBusyTime - mPreTriggerTime) || mFirstEvent) {
+    LOG(debug) << "Pre-trigger collision";
     long timeStamp = (eventTime / 100) * 100; /// This is to make the event time multiple of 100s
     for (auto& iNode : mTimedDigitsFuture) {
       long diff = (timeStamp - eventTime);

Detectors/EMCAL/workflow/CMakeLists.txt

@@ -25,8 +25,20 @@ o2_add_library(EMCALWorkflow
         src/CellRecalibratorSpec.cxx
         src/EntropyDecoderSpec.cxx
         src/StandaloneAODProducerSpec.cxx
-        PUBLIC_LINK_LIBRARIES O2::Framework O2::DataFormatsCTP O2::DataFormatsEMCAL O2::EMCALSimulation O2::Steer
-        O2::DPLUtils O2::EMCALBase O2::EMCALCalib O2::EMCALCalibration O2::EMCALReconstruction O2::Algorithm O2::MathUtils)
+        PUBLIC_LINK_LIBRARIES O2::Framework
+        O2::DataFormatsCTP
+        O2::DataFormatsEMCAL
+        O2::DataFormatsFT0
+        O2::DataFormatsFV0
+        O2::EMCALSimulation
+        O2::Steer
+        O2::DPLUtils
+        O2::EMCALBase
+        O2::EMCALCalib
+        O2::EMCALCalibration
+        O2::EMCALReconstruction
+        O2::Algorithm
+        O2::MathUtils)
 
 o2_add_executable(reco-workflow
         COMPONENT_NAME emcal

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

@@ -28,6 +28,12 @@ class TChain;
 
 namespace o2
 {
+
+namespace ctp
+{
+class CTPConfiguration;
+}
+
 namespace emcal
 {
 class CalibLoader;
@@ -45,7 +51,7 @@ class DigitizerSpec final : public o2::base::BaseDPLDigitizer, public o2::framew
  public:
   using o2::base::BaseDPLDigitizer::init;
   /// \brief Constructor
-  DigitizerSpec(std::shared_ptr<CalibLoader> calibloader) : o2::base::BaseDPLDigitizer(o2::base::InitServices::GEOM), o2::framework::Task(), mCalibHandler(calibloader) {}
+  DigitizerSpec(std::shared_ptr<CalibLoader> calibloader, bool requireCTPInput) : o2::base::BaseDPLDigitizer(o2::base::InitServices::GEOM), o2::framework::Task(), mRequireCTPInput(requireCTPInput), mCalibHandler(calibloader) {}
 
   /// \brief Destructor
   ~DigitizerSpec() final = default;
@@ -71,16 +77,18 @@ class DigitizerSpec final : public o2::base::BaseDPLDigitizer, public o2::framew
   Bool_t mFinished = false;                   ///< Flag for digitization finished
   bool mIsConfigured = false;                 ///< Initialization status of the digitizer
   bool mRunSDitizer = false;                  ///< Run SDigitization
+  bool mRequireCTPInput = false;              ///< Require CTP min. bias input
   Digitizer mDigitizer;                       ///< Digitizer object
   o2::emcal::SDigitizer mSumDigitizer;        ///< Summed digitizer
   std::shared_ptr<CalibLoader> mCalibHandler; ///< Handler of calibration objects
   std::vector<Hit> mHits;                     ///< Vector with input hits
   std::vector<TChain*> mSimChains;
+  o2::ctp::CTPConfiguration* mCTPConfig; ///< CTP configuration
 };
 
 /// \brief Create new digitizer spec
 /// \return Digitizer spec
-o2::framework::DataProcessorSpec getEMCALDigitizerSpec(int channel, bool mctruth = true, bool useccdb = true);
+o2::framework::DataProcessorSpec getEMCALDigitizerSpec(int channel, bool requireCTPInput, bool mctruth = true, bool useccdb = true);
 
 } // namespace emcal
 } // end namespace o2

Detectors/EMCAL/workflow/src/EMCALDigitizerSpec.cxx

@@ -27,8 +27,11 @@
 #include "CommonDataFormat/EvIndex.h"
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "DataFormatsParameters/GRPObject.h"
+#include "DataFormatsCTP/Configuration.h"
 #include "DataFormatsCTP/Digits.h"
 #include "DataFormatsEMCAL/TriggerRecord.h"
+#include "DataFormatsFT0/Digit.h"
+#include "DataFormatsFV0/Digit.h"
 
 using namespace o2::framework;
 using SubSpecificationType = o2::framework::DataAllocator::SubSpecificationType;
@@ -91,6 +94,77 @@ void DigitizerSpec::run(framework::ProcessingContext& ctx)
   TStopwatch timer;
   timer.Start();
 
+  // Load FIT triggers if not running in self-triggered mode
+  std::vector<o2::InteractionRecord> mbtriggers;
+  if (mRequireCTPInput) {
+    // Hopefully at some point we can replace it by CTP input digits
+    // In case of CTP digits react only to trigger inputs activated in trigger configuration
+    // For the moment react to FIT vertex, cent and semicent triggers
+    ctx.inputs().get<o2::ctp::CTPConfiguration*>("ctpconfig");
+    std::vector<uint64_t> inputmasks;
+    for (const auto& trg : mCTPConfig->getCTPClasses()) {
+      if (trg.cluster->maskCluster[o2::detectors::DetID::EMC]) {
+        // Class triggering EMCAL cluster
+        LOG(debug) << "Found trigger class for EMCAL cluster: " << trg.name << " with input mask " << std::bitset<64>(trg.descriptor->getInputsMask());
+        inputmasks.emplace_back(trg.descriptor->getInputsMask());
+      }
+    }
+    unsigned long ft0mask = 0, fv0mask = 0;
+    std::map<std::string, uint64_t> detInputName2Mask =
+      {{"MVBA", 1}, {"MVOR", 2}, {"MVNC", 4}, {"MVCH", 8}, {"MVIR", 0x10}, {"MT0A", 1}, {"MT0C", 2}, {"MTSC", 4}, {"MTCE", 8}, {"MTVX", 0x10}};
+    // Translation 2022: EMCAL cluster received CTP input masks, need to track it to FIT trigger masks
+    std::map<std::string, std::pair<o2::detectors::DetID, std::string>> ctpInput2DetInput = {
+      {"0VBA", {o2::detectors::DetID::FV0, "MVBA"}}, {"0VOR", {o2::detectors::DetID::FV0, "MVOR"}}, {"0VNC", {o2::detectors::DetID::FV0, "MVNC"}}, {"0VCH", {o2::detectors::DetID::FV0, "MVCH"}}, {"0VIR", {o2::detectors::DetID::FV0, "MVIR"}}, {"0T0A", {o2::detectors::DetID::FT0, "MT0A"}}, {"0T0C", {o2::detectors::DetID::FT0, "MT0C"}}, {"0TSC", {o2::detectors::DetID::FT0, "MTSC"}}, {"0TCE", {o2::detectors::DetID::FT0, "MTCE"}}, {"0TVX", {o2::detectors::DetID::FT0, "MTVX"}}};
+    for (const auto& [det, ctpinputs] : mCTPConfig->getDet2InputMap()) {
+      if (!(det == o2::detectors::DetID::FT0 || det == o2::detectors::DetID::FV0 || det == o2::detectors::DetID::CTP)) {
+        continue;
+      }
+      for (const auto& input : ctpinputs) {
+        LOG(debug) << "CTP det input: " << input.name << " with mask " << std::bitset<64>(input.inputMask);
+        bool isSelected = false;
+        for (auto testmask : inputmasks) {
+          if (testmask & input.inputMask) {
+            isSelected = true;
+          }
+        }
+        if (isSelected) {
+          std::string usedInputName = input.name;
+          o2::detectors::DetID usedDetID = det;
+          if (det == o2::detectors::DetID::CTP) {
+            auto found = ctpInput2DetInput.find(input.name);
+            if (found != ctpInput2DetInput.end()) {
+              usedInputName = found->second.second;
+              usedDetID = found->second.first;
+              LOG(debug) << "Decoded " << input.name << " -> " << usedInputName;
+            }
+          }
+          auto maskFound = detInputName2Mask.find(usedInputName);
+          if (maskFound != detInputName2Mask.end()) {
+            if (usedDetID == o2::detectors::DetID::FT0) {
+              ft0mask |= maskFound->second;
+            } else {
+              fv0mask |= maskFound->second;
+            }
+          }
+        }
+      }
+    }
+    LOG(debug) << "FTO mask: " << std::bitset<64>(ft0mask);
+    LOG(debug) << "FVO mask: " << std::bitset<64>(fv0mask);
+    for (const auto& trg : ctx.inputs().get<gsl::span<o2::ft0::DetTrigInput>>("ft0inputs")) {
+      if (trg.mInputs.to_ulong() & ft0mask) {
+        mbtriggers.emplace_back(trg.mIntRecord);
+      }
+    }
+    for (const auto& trg : ctx.inputs().get<gsl::span<o2::fv0::DetTrigInput>>("fv0inputs")) {
+      if (trg.mInputs.to_ulong() & fv0mask) {
+        if (std::find(mbtriggers.begin(), mbtriggers.end(), trg.mIntRecord) == mbtriggers.end()) {
+          mbtriggers.emplace_back(trg.mIntRecord);
+        }
+      }
+    }
+  }
+
   LOG(info) << " CALLING EMCAL DIGITIZATION ";
   o2::dataformats::MCTruthContainer<o2::emcal::MCLabel> labelAccum;
 
@@ -99,8 +173,13 @@ void DigitizerSpec::run(framework::ProcessingContext& ctx)
   // loop over all composite collisions given from context
   // (aka loop over all the interaction records)
   for (int collID = 0; collID < timesview.size(); ++collID) {
+    bool trigger = true; // Default: Self-triggered mode - all collisions treated as trigger
+    if (mRequireCTPInput) {
+      // check if we have a trigger input from CTP
+      trigger = (std::find(mbtriggers.begin(), mbtriggers.end(), timesview[collID]) != mbtriggers.end());
+    }
 
-    mDigitizer.setEventTime(timesview[collID]);
+    mDigitizer.setEventTime(timesview[collID], trigger);
 
     if (!mDigitizer.isLive()) {
       continue;
@@ -180,9 +259,13 @@ void DigitizerSpec::finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, vo
   if (mCalibHandler->finalizeCCDB(matcher, obj)) {
     return;
   }
+  if (matcher == o2::framework::ConcreteDataMatcher("CTP", "CTPCONFIG", 0)) {
+    std::cout << "Loading CTP configuration" << std::endl;
+    mCTPConfig = reinterpret_cast<o2::ctp::CTPConfiguration*>(obj);
+  }
 }
 
-o2::framework::DataProcessorSpec getEMCALDigitizerSpec(int channel, bool mctruth, bool useccdb)
+o2::framework::DataProcessorSpec getEMCALDigitizerSpec(int channel, bool requireCTPInput, bool mctruth, bool useccdb)
 {
   // create the full data processor spec using
   //  a name identifier
@@ -206,12 +289,17 @@ o2::framework::DataProcessorSpec getEMCALDigitizerSpec(int channel, bool mctruth
     calibloader->enableSimParams(true);
     calibloader->defineInputSpecs(inputs);
   }
+  if (requireCTPInput) {
+    inputs.emplace_back("ft0inputs", "FT0", "TRIGGERINPUT", 0, Lifetime::Timeframe);
+    inputs.emplace_back("fv0inputs", "FV0", "TRIGGERINPUT", 0, Lifetime::Timeframe);
+    inputs.emplace_back("ctpconfig", "CTP", "CTPCONFIG", 0, Lifetime::Condition, ccdbParamSpec("CTP/Config/Config", true));
+  }
 
   return DataProcessorSpec{
     "EMCALDigitizer", // Inputs{InputSpec{"collisioncontext", "SIM", "COLLISIONCONTEXT", static_cast<SubSpecificationType>(channel), Lifetime::Timeframe}, InputSpec{"EMC_SimParam", o2::header::gDataOriginEMC, "SIMPARAM", 0, Lifetime::Condition, ccdbParamSpec("EMC/Config/SimParam")}},
     inputs,
     outputs,
-    AlgorithmSpec{o2::framework::adaptFromTask<DigitizerSpec>(calibloader)},
+    AlgorithmSpec{o2::framework::adaptFromTask<DigitizerSpec>(calibloader, requireCTPInput)},
     Options{
       {"pileup", VariantType::Int, 1, {"whether to run in continuous time mode"}},
       {"debug-stream", VariantType::Bool, false, {"Enable debug streaming"}}}

Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx

@@ -198,6 +198,9 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option to use/not use CCDB for EMCAL
   workflowOptions.push_back(ConfigParamSpec{"no-use-ccdb-emc", o2::framework::VariantType::Bool, false, {"Disable access to ccdb EMCAL simulation objects"}});
 
+  // option to require/not require CTP MB inputs in EMCAL
+  workflowOptions.push_back(ConfigParamSpec{"no-require-ctpinputs-emc", o2::framework::VariantType::Bool, false, {"Disable requirement of CTP min. bias inputs in EMCAL simulation"}});
+
   // option to use or not use the Trap Simulator after digitisation (debate of digitization or reconstruction is for others)
   workflowOptions.push_back(ConfigParamSpec{"disable-trd-trapsim", VariantType::Bool, false, {"disable the trap simulation of the TRD"}});
   workflowOptions.push_back(ConfigParamSpec{"trd-digit-downscaling", VariantType::Int, 1, {"only keep TRD digits for every n-th trigger"}});
@@ -653,9 +656,10 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   // the EMCal part
   if (isEnabled(o2::detectors::DetID::EMC)) {
     auto useCCDB = !configcontext.options().get<bool>("no-use-ccdb-emc");
+    bool requireCTPInputs = !configcontext.options().get<bool>("no-require-ctpinputs-emc");
     detList.emplace_back(o2::detectors::DetID::EMC);
     // connect the EMCal digitization
-    digitizerSpecs.emplace_back(o2::emcal::getEMCALDigitizerSpec(fanoutsize++, mctruth, useCCDB));
+    digitizerSpecs.emplace_back(o2::emcal::getEMCALDigitizerSpec(fanoutsize++, requireCTPInputs, mctruth, useCCDB));
     // connect the EMCal digit writer
     writerSpecs.emplace_back(o2::emcal::getEMCALDigitWriterSpec(mctruth));
   }