[ALICE3] TF3: group pixel columns into readout columns in digitizer (#15907)

* make timing response independent for different pixels (dt from stepping neglected)

* remove useless include and commented line

* first attempt to include column-group read-out in the digitizer

* imporve implementation using a tdc-status array

* Please consider the following formatting changes

* fix type

* fix busy window

* Please consider the following formatting changes

---------

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>

Author: maciacco

Detectors/Upgrades/ALICE3/IOTOF/DataFormatsIOTOF/include/DataFormatsIOTOF/Digit.h

@@ -25,6 +25,19 @@
 
 namespace o2::iotof
 {
+struct DigitKey {
+  ULong64_t high;
+  UInt_t low;
+
+  bool operator<(const DigitKey& other) const
+  {
+    if (high != other.high) {
+      return high < other.high;
+    }
+    return low < other.low;
+  }
+};
+
 class Digit : public o2::itsmft::Digit
 {
  public:
@@ -40,11 +53,14 @@ class Digit : public o2::itsmft::Digit
   ULong64_t getBc() const { return mBc; }
   Int_t getTdc() const { return mTdc; }
 
-  static ULong64_t getOrderingKey(ULong64_t bc, UShort_t row, UShort_t col)
+  static DigitKey getOrderingKey(ULong64_t bc, UInt_t tdc, uint16_t row, uint16_t col)
   {
+    DigitKey key;
     uint32_t orbit = bc / o2::constants::lhc::LHCMaxBunches;
     uint16_t bunch = bc % o2::constants::lhc::LHCMaxBunches;
-    return (static_cast<ULong64_t>(orbit) << 32) | (static_cast<UInt_t>(bunch) << 16) | (static_cast<UInt_t>(row) << 8) | static_cast<UInt_t>(col);
+    key.high = (static_cast<ULong64_t>(orbit) << 32) | (static_cast<UInt_t>(bunch) << 16) | (static_cast<UInt_t>(tdc) & 0xFFFF);
+    key.low = (static_cast<UInt_t>(row) << 16) | (static_cast<UInt_t>(col) & 0xFFFF);
+    return key;
   }
 
  private:

Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Chip.h

@@ -60,7 +60,7 @@ class Chip
   /// @param option unused
   void clear() { mDigits.clear(); }
 
-  std::map<ULong64_t, o2::iotof::LabeledDigit>& getDigits() { return mDigits; }
+  std::map<DigitKey, o2::iotof::LabeledDigit>& getDigits() { return mDigits; }
   bool isEmpty() const { return mDigits.empty(); }
 
   void setChipIndex(Int_t index) { mChipIndex = index; }
@@ -74,19 +74,24 @@ class Chip
   Int_t getNumberOfDigits() const { return mDigits.size(); }
 
   /// reset points container
-  o2::iotof::LabeledDigit* findDigit(ULong64_t key);
+  o2::iotof::LabeledDigit* findDigit(DigitKey key);
+
+  /// Resize the vector of tdc states
+  void resizeTDCStates(int const size) { mTDCStates.resize(size); }
+  std::vector<std::array<double, 2>>& getTDCStates() { return mTDCStates; }
 
   void addDigit(UShort_t row, UShort_t col, Int_t charge, double time, ULong64_t bc, Int_t tdc, o2::MCCompLabel label);
 
  protected:
   Int_t mChipIndex = -1;                                ///< Chip ID
   bool mDisabled = false;                               ///< Flag to indicate if the chip is disabled (e.g. due to dead channels)
-  std::map<ULong64_t, o2::iotof::LabeledDigit> mDigits; ///< Map of fired digits, possibly in multiple frames
+  std::map<DigitKey, o2::iotof::LabeledDigit> mDigits;  ///< Map of fired digits, possibly in multiple frames
+  std::vector<std::array<double, 2>> mTDCStates;        ///< Vector of the last times the TDC pairs went busy
 
   ClassDefNV(Chip, 1);
 };
 
-inline o2::iotof::LabeledDigit* Chip::findDigit(ULong64_t key)
+inline o2::iotof::LabeledDigit* Chip::findDigit(DigitKey key)
 {
   // finds the digit corresponding to global key
   auto digitentry = mDigits.find(key);

Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/DPLDigitizerParam.h

@@ -38,6 +38,9 @@ struct DPLDigitizerParam : public o2::conf::ConfigurableParamHelper<DPLDigitizer
   float energyToNElectrons = 1. / 3.6e-9; // conversion of eloss to Nelectrons
   int responseMatrixSize = 1;             ///< size of the response matrix (odd number)
 
+  int nColsPerGroup = 4;      ///< number of pixel columns grouped into a readout column
+  double tdcBusyTime = 3000.; ///< tdc pair bsuy time (default 3 us)
+
   std::string noiseFilePath{}; ///< optional noise masks file path. FIXME to be removed once switch to CCDBFetcher
 
   // boilerplate stuff + make principal key

Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Chip.cxx

@@ -34,6 +34,6 @@ Chip::Chip(Int_t index)
 //_______________________________________________________________________
 void Chip::addDigit(UShort_t row, UShort_t col, Int_t charge, double time, ULong64_t bc, Int_t tdc, o2::MCCompLabel label)
 {
-  ULong64_t key = Digit::getOrderingKey(bc, row, col);
+  DigitKey key = Digit::getOrderingKey(bc, tdc, row, col);
   mDigits.emplace(std::make_pair(key, LabeledDigit(mChipIndex, row, col, charge, time, bc, tdc, label)));
 }

Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Digitizer.cxx

@@ -41,6 +41,10 @@ void Digitizer::init()
 {
   const int numberOfChips = mGeometry->getSize();
   mChips.resize(numberOfChips);
+
+  const auto& specsConfig = ChipSpecificsParam::Instance();
+  const auto& digitizerParams = o2::iotof::DPLDigitizerParam::Instance();
+  const int nReadOutCols = specsConfig.NCols / digitizerParams.nColsPerGroup + 1;
   for (int i = numberOfChips; i--;) {
     mChips[i].setChipIndex(i);
     /// Noise map to be implemented
@@ -53,9 +57,15 @@ void Digitizer::init()
     ///   mChips[i].disable(mDeadChanMap->isFullChipMasked(i));
     ///   mChips[i].setDeadChanMap(mDeadChanMap);
     /// }
+
+    // initialize the vector of TDC states
+    mChips[i].resizeTDCStates(nReadOutCols);
+    for (auto& tdcStates : mChips[i].getTDCStates()) {
+      tdcStates[0] = -999.f;
+      tdcStates[1] = -999.f;
+    }
   }
 
-  const auto& digitizerParams = o2::iotof::DPLDigitizerParam::Instance();
   if (!digitizerParams.efficiencyFilePath.empty()) {
     loadEfficiencyMap(digitizerParams.efficiencyFilePath);
   }
@@ -404,12 +414,25 @@ void Digitizer::fillOutputContainer()
     }
 
     auto& chipDigits = chip.getDigits();
+    auto& tdcStates = chip.getTDCStates();
+
     for (const auto& [key, digit] : chipDigits) {
 
       if (digit.getCharge() < digitizerParams.chargeThreshold) {
         continue; // skip digits below threshold
       }
 
+      const int colInGroup = digit.getColumn() / digitizerParams.nColsPerGroup;
+      const double digitTime = digit.getTime();
+      if (digitTime - tdcStates[colInGroup][0] < digitizerParams.tdcBusyTime && digitTime - tdcStates[colInGroup][1] < digitizerParams.tdcBusyTime) {
+        // TODO: improve labels treatment if multiple hits cross the same pixel during
+        continue; // both tdc pairs are busy
+      } else if (digitTime - tdcStates[colInGroup][0] > digitizerParams.tdcBusyTime) {
+        tdcStates[colInGroup][0] = digitTime;
+      } else if (digitTime - tdcStates[colInGroup][1] > digitizerParams.tdcBusyTime) {
+        tdcStates[colInGroup][1] = digitTime;
+      }
+
       int digitID = mDigits->size();
       mDigits->emplace_back(digit.getChipIndex(), digit.getRow(), digit.getColumn(), digit.getCharge(), digit.getTime(), digit.getBc(), digit.getTdc());
       if (mMCLabels) {
@@ -438,7 +461,7 @@ void Digitizer::fillOutputContainer()
 void Digitizer::registerDigits(Chip& chip, uint32_t roFrame, double time, int nROF,
                                uint16_t row, uint16_t col, int nElectrons, o2::MCCompLabel& label)
 {
-  (void)nROF;
+  // (void)nROF;
 
   const auto& digitizerParams = o2::iotof::DPLDigitizerParam::Instance();
 
@@ -448,8 +471,11 @@ void Digitizer::registerDigits(Chip& chip, uint32_t roFrame, double time, int nR
 
   double absoluteTime = tdc * digitizerParams.tdcBin + nbc * o2::constants::lhc::LHCBunchSpacingNS;
 
-  auto key = o2::iotof::Digit::getOrderingKey(nbc, row, col);
+  auto key = o2::iotof::Digit::getOrderingKey(nbc, tdc, row, col);
   o2::iotof::LabeledDigit* existingDigit = chip.findDigit(key);
+
+  chip.addDigit(row, col, nElectrons, absoluteTime, nbc, tdc, label);
+
   if (!existingDigit) {
     // No existing digit, create a new one
     chip.addDigit(row, col, nElectrons, absoluteTime, nbc, tdc, label);