ITSMFT: staggered digitization

Signed-off-by: Felix Schlepper <[email protected]>

Author: f3sch

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,26 @@ 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 roFrameLayerRef = -1;                      ///< staggering reference layer, if >=0 turn staggering mode on
+  int roFrameLayerOffsetInBC[getNLayers()] = {}; ///< staggering offsets in BC to reference layer
+  int roFrameLayerLengthInBC[getNLayers()] = {}; ///< staggering ROF length in BC for continuous mode per layer
 
   // boilerplate stuff + make principal key
   O2ParamDef(DPLAlpideParam, getParamName().data());
@@ -46,7 +55,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 [email protected]
 #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,8 +53,8 @@ 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; }
@@ -62,7 +64,7 @@ class DigiParams
   float getStrobeDelay() const { return mStrobeDelay; }
 
   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; }
@@ -96,13 +98,21 @@ class DigiParams
   const SignalShape& getSignalShape() const { return mSignalShape; }
   SignalShape& getSignalShape() { return (SignalShape&)mSignalShape; }
 
+  void setROFrameLayerRef(int layer) { mROFrameLayerRef = layer; }
+  bool inStaggeredReadout() const noexcept { return mROFrameLayerRef != -1; }
+  void addROFrameLayerOffsetInBC(int off) { mROFrameLayerOffsetInBC.push_back(off); }
+  int getROFrameLayerOffsetInBC(int layer) const { return mROFrameLayerOffsetInBC[layer]; }
+  void addROFrameLayerLengthInBC(int len) { mROFrameLayerLengthInBC.push_back(len); }
+  void addROFrameLayerLength(float f) { mROFrameLayerLength.push_back(f); }
+  void addStrobeLength(float ns) { mStrobeLayerLength.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,7 +125,13 @@ 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)
+
+  int mROFrameLayerRef = -1;                ///< staggering reference layer, if >=0 turn staggering mode on
+  std::vector<int> mROFrameLayerOffsetInBC; ///< staggering offsets in BC to reference layer
+  std::vector<int> mROFrameLayerLengthInBC; ///< staggering ROF length 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)
 
   o2::itsmft::AlpideSignalTrapezoid mSignalShape; ///< signal timeshape parameterization
 
@@ -125,7 +141,7 @@ class DigiParams
   float mROFrameLengthInv = 0; ///< inverse length of RO frame in ns
   float mNSimStepsInv = 0;     ///< its inverse
 
-  ClassDef(DigiParams, 2);
+  ClassDef(DigiParams, 3);
 };
 } // namespace itsmft
 } // namespace o2

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

@@ -66,8 +66,8 @@ 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
@@ -76,7 +76,7 @@ class Digitizer : public TObject
 
   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,6 +91,12 @@ 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);

Detectors/ITSMFT/common/simulation/src/DigiParams.cxx

@@ -58,17 +58,23 @@ void DigiParams::setChargeThreshold(int v, float frac2Account)
 //______________________________________________
 void DigiParams::print() const
 {
-  // print settings
-  printf("Alpide digitization params:\n");
-  printf("Continuous readout             : %s\n", mIsContinuous ? "ON" : "OFF");
-  printf("Readout Frame Length(ns)       : %f\n", mROFrameLength);
-  printf("Strobe delay (ns)              : %f\n", mStrobeDelay);
-  printf("Strobe length (ns)             : %f\n", mStrobeLength);
-  printf("Threshold (N electrons)        : %d\n", mChargeThreshold);
-  printf("Min N electrons to account     : %d\n", mMinChargeToAccount);
-  printf("Number of charge sharing steps : %d\n", mNSimSteps);
-  printf("ELoss to N electrons factor    : %e\n", mEnergyToNElectrons);
-  printf("Noise level per pixel          : %e\n", mNoisePerPixel);
-  printf("Charge time-response:\n");
+  LOGF(info, "Alpide digitization params:");
+  LOGF(info, "Continuous readout               : %s", mIsContinuous ? "ON" : "OFF");
+  if (mROFrameLayerRef >= 0) {
+    LOGF(info, "Staggering mode with reference layer : %d", mROFrameLayerRef);
+    for (int i{0}; i < (int)mROFrameLayerLengthInBC.size(); ++i) {
+      LOGF(info, " Layer:%d Length(ns)[BC]      : %f [%d+%d]", i, mROFrameLayerLength[i], mROFrameLayerLengthInBC[i], mROFrameLayerOffsetInBC[i]);
+    }
+  } else {
+    LOGF(info, "Readout Frame Length(ns)         : %f", mROFrameLength);
+  }
+  LOGF(info, "Strobe delay (ns)                : %f", mStrobeDelay);
+  LOGF(info, "Strobe length (ns)               : %f", mStrobeLength);
+  LOGF(info, "Threshold (N electrons)          : %d", mChargeThreshold);
+  LOGF(info, "Min N electrons to account       : %d", mMinChargeToAccount);
+  LOGF(info, "Number of charge sharing steps   : %d", mNSimSteps);
+  LOGF(info, "ELoss to N electrons factor      : %e", mEnergyToNElectrons);
+  LOGF(info, "Noise level per pixel            : %e", mNoisePerPixel);
+  LOGF(info, "Charge time-response:");
   mSignalShape.print();
 }