ITSMFT: staggered digitization

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

Author: f3sch

DataFormats/Detectors/ITSMFT/common/src/ROFRecord.cxx

@@ -9,20 +9,22 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-#include "DataFormatsITSMFT/ROFRecord.h"
 #include <iostream>
-#include "fmt/format.h"
+#include <format>
+
+#include "DataFormatsITSMFT/ROFRecord.h"
+#include "Framework/Logger.h"
 
 using namespace o2::itsmft;
 
 std::string ROFRecord::asString() const
 {
-  return fmt::format("ROF: {} | {} entries starting from {}", mROFrame, getNEntries(), getFirstEntry());
+  return std::format("ROF: {} | {} entries starting from {} | IR: {}", mROFrame, getNEntries(), getFirstEntry(), mBCData.asString());
 }
 
 void ROFRecord::print() const
 {
-  std::cout << this << "\n\t" << mBCData << std::endl;
+  LOG(info) << asString();
 }
 
 std::ostream& operator<<(std::ostream& stream, ROFRecord const& rec)
@@ -33,12 +35,12 @@ std::ostream& operator<<(std::ostream& stream, ROFRecord const& rec)
 
 std::string MC2ROFRecord::asString() const
 {
-  return fmt::format("MCEventID: {} ROFs: {}-{} Entry in ROFRecords: {}", eventRecordID, minROF, maxROF, rofRecordID);
+  return std::format("MCEventID: {} ROFs: {}-{} Entry in ROFRecords: {}", eventRecordID, minROF, maxROF, rofRecordID);
 }
 
 void MC2ROFRecord::print() const
 {
-  std::cout << this << std::endl;
+  LOG(info) << asString();
 }
 
 std::ostream& operator<<(std::ostream& stream, MC2ROFRecord const& rec)

Detectors/ITSMFT/ITS/base/include/ITSBase/GeometryTGeo.h

@@ -176,7 +176,7 @@ class GeometryTGeo : public o2::itsmft::GeometryTGeo
   bool getChipId(int index, int& lay, int& hba, int& sta, int& ssta, int& mod, int& chip) const;
 
   /// Get chip layer, from 0
-  int getLayer(int index) const;
+  int getLayer(int index) const final;
 
   /// Get chip half barrel, from 0
   int getHalfBarrel(int index) const;
@@ -216,7 +216,7 @@ class GeometryTGeo : public o2::itsmft::GeometryTGeo
     return getSymbolicName(getChipIndex(lay, hba, sta, det));
   }
 
-  /// Get the transformation matrix for a given chip (NOT A SENSOR!!!) 'index' by quering the TGeoManager
+  /// Get the transformation matrix for a given chip (NOT A SENSOR!!!) 'index' by querying the TGeoManager
   TGeoHMatrix* getMatrix(int index) const { return o2::base::GeometryManager::getMatrix(getDetID(), index); }
   TGeoHMatrix* getMatrix(int lay, int hba, int sta, int sens) const { return getMatrix(getChipIndex(lay, hba, sta, sens)); }
   bool getOriginalMatrix(int index, TGeoHMatrix& m) const
@@ -336,7 +336,7 @@ class GeometryTGeo : public o2::itsmft::GeometryTGeo
   TString getMatrixPath(int index) const;
 
   /// Get the transformation matrix of the SENSOR (not necessary the same as the chip)
-  /// for a given chip 'index' by quering the TGeoManager
+  /// for a given chip 'index' by querying the TGeoManager
   TGeoHMatrix* extractMatrixSensor(int index) const;
 
   // create matrix for transformation from sensor local frame to global one
@@ -407,7 +407,7 @@ class GeometryTGeo : public o2::itsmft::GeometryTGeo
   std::vector<int> mNumberOfChipsPerStave;      ///< number of chips per stave
   std::vector<int> mNumberOfChipsPerHalfBarrel; ///< number of chips per halfbarrel
   std::vector<int> mNumberOfChipsPerLayer;      ///< number of chips per stave
-  std::vector<int> mLastChipIndex;              ///< max ID of the detctor in the layer
+  std::vector<int> mLastChipIndex;              ///< max ID of the detector in the layer
   std::array<bool, MAXLAYERS> mIsLayerITS3;     ///< flag with the information of the ITS version (ITS2 or ITS3)
   std::array<char, MAXLAYERS> mLayerToWrapper;  ///< Layer to wrapper correspondence
 

Detectors/ITSMFT/MFT/base/include/MFTBase/GeometryTGeo.h

@@ -95,7 +95,7 @@ class GeometryTGeo : public o2::itsmft::GeometryTGeo
   Int_t getSensorIndex(Int_t half, Int_t disk, Int_t ladder, Int_t sensor) const;
 
   /// get layer index (0:9) from the chip index
-  Int_t getLayer(Int_t index) const;
+  Int_t getLayer(Int_t index) const final;
 
   /// This routine computes the half, disk, ladder and sensor number
   /// given the sensor index number
@@ -122,7 +122,7 @@ class GeometryTGeo : public o2::itsmft::GeometryTGeo
   {
     return extractNumberOfDisks(half);
   }
-  /// Returns the number of halfs MFT
+  /// Returns the number of halves MFT
   Int_t getNumberOfHalfs()
   {
     return extractNumberOfHalves();
@@ -181,7 +181,7 @@ class GeometryTGeo : public o2::itsmft::GeometryTGeo
   Int_t extractVolumeCopy(const Char_t* name, const Char_t* prefix) const;
 
   /// Get the transformation matrix of the sensor [...]
-  /// for a given sensor 'index' by quering the TGeoManager
+  /// for a given sensor 'index' by querying the TGeoManager
   TGeoHMatrix* extractMatrixSensor(Int_t index) const;
 
   // Create matrix for transformation from sensor local frame to global one

Detectors/ITSMFT/common/base/include/ITSMFTBase/DPLAlpideParam.h

@@ -26,17 +26,45 @@ constexpr float DEFStrobeDelay = o2::constants::lhc::LHCBunchSpacingNS * 4; // ~
 
 template <int N>
 struct DPLAlpideParam : public o2::conf::ConfigurableParamHelper<DPLAlpideParam<N>> {
+  static constexpr int getNLayers()
+  {
+    return N == o2::detectors::DetID::ITS ? 7 : 10;
+  }
 
   static constexpr std::string_view getParamName()
   {
     return N == o2::detectors::DetID::ITS ? ParamName[0] : ParamName[1];
   }
-  int roFrameLengthInBC = DEFROFLengthBC();           ///< ROF length in BC for continuos mode
-  float roFrameLengthTrig = DEFROFLengthTrig();       ///< length of RO frame in ns for triggered mode
-  float strobeDelay = DEFStrobeDelay;                 ///< strobe start (in ns) wrt ROF start
-  float strobeLengthCont = -1.;                       ///< if < 0, full ROF length - delay
-  float strobeLengthTrig = 100.;                      ///< length of the strobe in ns (sig. over threshold checked in this window only)
-  int roFrameBiasInBC = DEFROFBiasInBC();             ///< bias of the start of ROF wrt orbit start: t_irof = (irof*roFrameLengthInBC + roFrameBiasInBC)*BClengthMUS
+
+ public:
+  int roFrameLengthInBC = DEFROFLengthBC();      ///< ROF length in BC for continuous mode
+  float roFrameLengthTrig = DEFROFLengthTrig();  ///< length of RO frame in ns for triggered mode
+  float strobeDelay = DEFStrobeDelay;            ///< strobe start (in ns) wrt ROF start
+  float strobeLengthCont = -1.;                  ///< if < 0, full ROF length - delay
+  float strobeLengthTrig = 100.;                 ///< length of the strobe in ns (sig. over threshold checked in this window only)
+  int roFrameBiasInBC = DEFROFBiasInBC();        ///< bias of the start of ROF wrt orbit start: t_irof = (irof*roFrameLengthInBC + roFrameBiasInBC)*BClengthMUS
+  int roFrameLayerLengthInBC[getNLayers()] = {}; ///< staggering ROF length in BC for continuous mode per layer
+  int roFrameLayerBiasInBC[getNLayers()] = {};   ///< staggering ROF bias in BC for continuous mode per layer
+  int roFrameLayerDelayInBC[getNLayers()] = {};  ///< staggering ROF delay in BC for continuous mode per layer
+
+  static constexpr bool supportsStaggering() noexcept { return (N == o2::detectors::DetID::ITS) ? false : false; }
+  // test if staggering is on
+  bool withStaggering() const noexcept
+  {
+    if constexpr (!supportsStaggering()) {
+      return false;
+    }
+    for (int i{0}; i < getNLayers(); ++i) {
+      if (roFrameLayerLengthInBC[i] != 0) {
+        return true;
+      }
+    }
+    return false;
+  }
+  // get ROF length for any layer
+  int getROFLengthInBC(int layer) const noexcept { return (withStaggering()) ? roFrameLayerLengthInBC[layer] : roFrameLengthInBC; }
+  int getROFBiasInBC(int layer) const noexcept { return (withStaggering()) ? roFrameLayerBiasInBC[layer] : roFrameBiasInBC; }
+  int getROFDelayInBC(int layer) const noexcept { return (withStaggering()) ? roFrameLayerDelayInBC[layer] : 0; }
 
   // boilerplate stuff + make principal key
   O2ParamDef(DPLAlpideParam, getParamName().data());
@@ -46,7 +74,7 @@ struct DPLAlpideParam : public o2::conf::ConfigurableParamHelper<DPLAlpideParam<
 
   static constexpr int DEFROFLengthBC()
   {
-    // default ROF length in BC for continuos mode
+    // default ROF length in BC for continuous mode
     // allowed values: 1,2,3,4,6,9,11,12,18,22,27,33,36
     return N == o2::detectors::DetID::ITS ? o2::constants::lhc::LHCMaxBunches / 4 : o2::constants::lhc::LHCMaxBunches / 18;
   }

Detectors/ITSMFT/common/base/include/ITSMFTBase/GeometryTGeo.h

@@ -11,7 +11,7 @@
 
 /// \file GeometryTGeo.h
 /// \brief Definition of the GeometryTGeo class : common part for ITS and MFT
-/// \brief collects ITS and MFT common methods to acces matrices
+/// \brief collects ITS and MFT common methods to access matrices
 
 /// \author ruben.shahoyan@cern.ch
 #ifndef ALICEO2_ITSMFT_GEOMETRYTGEO_H_
@@ -37,7 +37,8 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   ~GeometryTGeo() override = default;
 
   Int_t getNumberOfChips() const { return mSize; }
-  /// build detector layout data, must be overriden by detector
+  virtual Int_t getLayer(Int_t index) const { return -1; };
+  /// build detector layout data, must be overridden by detector
   virtual void Build(int loadTrans) = 0;
 
   bool isOwner() const { return mOwner; }

Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/DigiParams.h

@@ -15,8 +15,10 @@
 #ifndef ALICEO2_ITSMFT_DIGIPARAMS_H
 #define ALICEO2_ITSMFT_DIGIPARAMS_H
 
+#include <vector>
+#include <algorithm>
 #include <Rtypes.h>
-#include <ITSMFTSimulation/AlpideSignalTrapezoid.h>
+#include "ITSMFTSimulation/AlpideSignalTrapezoid.h"
 #include "ITSMFTBase/DPLAlpideParam.h"
 
 ////////////////////////////////////////////////////////////
@@ -51,24 +53,24 @@ class DigiParams
   void setContinuous(bool v) { mIsContinuous = v; }
   bool isContinuous() const { return mIsContinuous; }
 
-  int getROFrameLengthInBC() const { return mROFrameLengthInBC; }
-  void setROFrameLengthInBC(int n) { mROFrameLengthInBC = n; }
+  int getROFrameLengthInBC(int layer = -1) const { return layer < 0 ? mROFrameLengthInBC : mROFrameLayerLengthInBC[layer]; }
+  void setROFrameLengthInBC(int n, int layer = -1) { layer < 0 ? mROFrameLengthInBC = n : mROFrameLayerLengthInBC[layer] = n; }
 
-  void setROFrameLength(float ns);
-  float getROFrameLength() const { return mROFrameLength; }
-  float getROFrameLengthInv() const { return mROFrameLengthInv; }
+  void setROFrameLength(float ns, int layer = -1);
+  float getROFrameLength(int layer = -1) const { return layer < 0 ? mROFrameLength : mROFrameLayerLength[layer]; }
+  float getROFrameLengthInv(int layer = -1) const { return layer < 0 ? mROFrameLengthInv : mROFrameLayerLengthInv[layer]; }
 
   void setStrobeDelay(float ns) { mStrobeDelay = ns; }
-  float getStrobeDelay() const { return mStrobeDelay; }
+  float getStrobeDelay(int layer = -1) const { return layer < 0 ? mStrobeDelay : mStrobeLayerDelay[layer]; }
 
   void setStrobeLength(float ns) { mStrobeLength = ns; }
-  float getStrobeLength() const { return mStrobeLength; }
+  float getStrobeLength(int layer = -1) const { return layer < 0 ? mStrobeLength : mStrobeLayerLength[layer]; }
 
   void setTimeOffset(double sec) { mTimeOffset = sec; }
   double getTimeOffset() const { return mTimeOffset; }
 
-  void setROFrameBiasInBC(int n) { mROFrameBiasInBC = n; }
-  int getROFrameBiasInBC() const { return mROFrameBiasInBC; }
+  void setROFrameBiasInBC(int n, int layer = -1) { layer < 0 ? mROFrameBiasInBC = n : mROFrameLayerBiasInBC[layer] = n; }
+  int getROFrameBiasInBC(int layer = -1) const { return layer < 0 ? mROFrameBiasInBC : mROFrameLayerBiasInBC[layer]; }
 
   void setChargeThreshold(int v, float frac2Account = 0.1);
   void setNSimSteps(int v);
@@ -96,13 +98,19 @@ class DigiParams
   const SignalShape& getSignalShape() const { return mSignalShape; }
   SignalShape& getSignalShape() { return (SignalShape&)mSignalShape; }
 
+  bool withStaggering() const noexcept { return !mROFrameLayerLength.empty(); }
+  void addROFrameLayerLengthInBC(int len) { mROFrameLayerLengthInBC.push_back(len); }
+  void addROFrameLayerBiasInBC(int len) { mROFrameLayerBiasInBC.push_back(len); }
+  void addStrobeLength(float ns) { mStrobeLayerLength.push_back(ns); }
+  void addStrobeDelay(float ns) { mStrobeLayerDelay.push_back(ns); }
+
   virtual void print() const;
 
  private:
   static constexpr double infTime = 1e99;
   bool mIsContinuous = false;              ///< flag for continuous simulation
   float mNoisePerPixel = 1.e-8;            ///< ALPIDE Noise per chip
-  int mROFrameLengthInBC = 0;              ///< ROF length in BC for continuos mode
+  int mROFrameLengthInBC = 0;              ///< ROF length in BC for continuous mode
   float mROFrameLength = 0;                ///< length of RO frame in ns
   float mStrobeDelay = 0.;                 ///< strobe start (in ns) wrt ROF start
   float mStrobeLength = 0;                 ///< length of the strobe in ns (sig. over threshold checked in this window only)
@@ -115,17 +123,24 @@ class DigiParams
 
   float mVbb = 0.0;   ///< back bias absolute value for MFT (in Volt)
   float mIBVbb = 0.0; ///< back bias absolute value for ITS Inner Barrel (in Volt)
-  float mOBVbb = 0.0; ///< back bias absolute value for ITS Outter Barrel (in Volt)
+  float mOBVbb = 0.0; ///< back bias absolute value for ITS Outer Barrel (in Volt)
+
+  std::vector<int> mROFrameLayerLengthInBC; ///< staggering ROF length in BC for continuous mode per layer
+  std::vector<int> mROFrameLayerBiasInBC;   ///< staggering ROF bias in BC for continuous mode per layer
+  std::vector<float> mROFrameLayerLength;   ///< staggering ROF length in ns for continuous mode per layer
+  std::vector<float> mStrobeLayerLength;    ///< staggering length of the strobe in ns (sig. over threshold checked in this window only)
+  std::vector<float> mStrobeLayerDelay;     ///< staggering delay of the strobe in ns
 
   o2::itsmft::AlpideSignalTrapezoid mSignalShape; ///< signal timeshape parameterization
 
   const o2::itsmft::AlpideSimResponse* mAlpSimResponse = nullptr; //!< pointer on external response
 
   // auxiliary precalculated parameters
-  float mROFrameLengthInv = 0; ///< inverse length of RO frame in ns
-  float mNSimStepsInv = 0;     ///< its inverse
+  float mROFrameLengthInv = 0;               ///< inverse length of RO frame in ns
+  std::vector<float> mROFrameLayerLengthInv; // inverse length of RO frame in ns per layer
+  float mNSimStepsInv = 0;                   ///< its inverse
 
-  ClassDef(DigiParams, 2);
+  ClassDef(DigiParams, 3);
 };
 } // namespace itsmft
 } // namespace o2

Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/Digitizer.h

@@ -49,14 +49,16 @@ class Digitizer : public TObject
 
  public:
   Digitizer() = default;
+  Digitizer(Digitizer&&) = delete;
+  Digitizer& operator=(Digitizer&&) = delete;
   ~Digitizer() override = default;
   Digitizer(const Digitizer&) = delete;
   Digitizer& operator=(const Digitizer&) = delete;
 
   void setDigits(std::vector<o2::itsmft::Digit>* dig) { mDigits = dig; }
   void setMCLabels(o2::dataformats::MCTruthContainer<o2::MCCompLabel>* mclb) { mMCLabels = mclb; }
   void setROFRecords(std::vector<o2::itsmft::ROFRecord>* rec) { mROFRecords = rec; }
-  o2::itsmft::DigiParams& getParams() { return (o2::itsmft::DigiParams&)mParams; }
+  o2::itsmft::DigiParams& getParams() { return mParams; }
   const o2::itsmft::DigiParams& getParams() const { return mParams; }
   void setNoiseMap(const o2::itsmft::NoiseMap* mp) { mNoiseMap = mp; }
   void setDeadChannelsMap(const o2::itsmft::NoiseMap* mp) { mDeadChanMap = mp; }
@@ -66,17 +68,17 @@ class Digitizer : public TObject
   auto getChipResponse(int chipID);
 
   /// Steer conversion of hits to digits
-  void process(const std::vector<Hit>* hits, int evID, int srcID);
-  void setEventTime(const o2::InteractionTimeRecord& irt);
+  void process(const std::vector<Hit>* hits, int evID, int srcID, int layer = -1);
+  void setEventTime(const o2::InteractionTimeRecord& irt, int layer = -1);
   double getEndTimeOfROFMax() const
   {
     ///< return the time corresponding to end of the last reserved ROFrame : mROFrameMax
-    return mParams.getROFrameLength() * (mROFrameMax + 1) + mParams.getTimeOffset();
+    return (mParams.getROFrameLength() * (double)(mROFrameMax + 1)) + mParams.getTimeOffset();
   }
 
   void setContinuous(bool v) { mParams.setContinuous(v); }
   bool isContinuous() const { return mParams.isContinuous(); }
-  void fillOutputContainer(uint32_t maxFrame = 0xffffffff);
+  void fillOutputContainer(uint32_t maxFrame = 0xffffffff, int layer = -1);
 
   void setDigiParams(const o2::itsmft::DigiParams& par) { mParams = par; }
   const o2::itsmft::DigiParams& getDigitParams() const { return mParams; }
@@ -91,11 +93,17 @@ class Digitizer : public TObject
     mEventROFrameMin = 0xffffffff;
     mEventROFrameMax = 0;
   }
+  void resetROFrameBounds()
+  {
+    mROFrameMin = 0;
+    mROFrameMax = 0;
+    mNewROFrame = 0;
+  }
 
  private:
-  void processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID, int srcID);
+  void processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID, int srcID, int lay);
   void registerDigits(ChipDigitsContainer& chip, uint32_t roFrame, float tInROF, int nROF,
-                      uint16_t row, uint16_t col, int nEle, o2::MCCompLabel& lbl);
+                      uint16_t row, uint16_t col, int nEle, o2::MCCompLabel& lbl, int lay);
 
   ExtraDig* getExtraDigBuffer(uint32_t roFrame)
   {
@@ -114,7 +122,7 @@ class Digitizer : public TObject
   o2::itsmft::DigiParams mParams;          ///< digitization parameters
   o2::InteractionTimeRecord mEventTime;    ///< global event time and interaction record
   o2::InteractionRecord mIRFirstSampledTF; ///< IR of the 1st sampled IR, noise-only ROFs will be inserted till this IR only
-  double mCollisionTimeWrtROF;
+  double mCollisionTimeWrtROF{};
   uint32_t mROFrameMin = 0; ///< lowest RO frame of current digits
   uint32_t mROFrameMax = 0; ///< highest RO frame of current digits
   uint32_t mNewROFrame = 0; ///< ROFrame corresponding to provided time