ITS/MFT digitizer builds ROFs from 1st IR of TF containing HBFUtils.orbitFirstSampled

Author: shahor02

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

@@ -17,7 +17,7 @@
 #include <deque>
 #include <memory>
 
-#include "Rtypes.h"  // for Digitizer::Class, Double_t, ClassDef, etc
+#include "Rtypes.h" // for Digitizer::Class
 #include "TObject.h" // for TObject
 
 #include "ITSMFTSimulation/ChipDigitsContainer.h"
@@ -71,28 +71,28 @@ class Digitizer : public TObject
 
   void setContinuous(bool v) { mParams.setContinuous(v); }
   bool isContinuous() const { return mParams.isContinuous(); }
-  void fillOutputContainer(UInt_t maxFrame = 0xffffffff);
+  void fillOutputContainer(uint32_t maxFrame = 0xffffffff);
 
   void setDigiParams(const o2::itsmft::DigiParams& par) { mParams = par; }
   const o2::itsmft::DigiParams& getDigitParams() const { return mParams; }
 
   // provide the common itsmft::GeometryTGeo to access matrices and segmentation
   void setGeometry(const o2::itsmft::GeometryTGeo* gm) { mGeometry = gm; }
 
-  UInt_t getEventROFrameMin() const { return mEventROFrameMin; }
-  UInt_t getEventROFrameMax() const { return mEventROFrameMax; }
+  uint32_t getEventROFrameMin() const { return mEventROFrameMin; }
+  uint32_t getEventROFrameMax() const { return mEventROFrameMax; }
   void resetEventROFrames()
   {
     mEventROFrameMin = 0xffffffff;
     mEventROFrameMax = 0;
   }
 
  private:
-  void processHit(const o2::itsmft::Hit& hit, UInt_t& maxFr, int evID, int srcID);
-  void registerDigits(ChipDigitsContainer& chip, UInt_t roFrame, float tInROF, int nROF,
-                      UShort_t row, UShort_t col, int nEle, o2::MCCompLabel& lbl);
+  void processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID, int srcID);
+  void registerDigits(ChipDigitsContainer& chip, uint32_t roFrame, float tInROF, int nROF,
+                      uint16_t row, uint16_t col, int nEle, o2::MCCompLabel& lbl);
 
-  ExtraDig* getExtraDigBuffer(UInt_t roFrame)
+  ExtraDig* getExtraDigBuffer(uint32_t roFrame)
   {
     if (mROFrameMin > roFrame) {
       return nullptr; // nothing to do
@@ -108,13 +108,14 @@ 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;
-  UInt_t mROFrameMin = 0;         ///< lowest RO frame of current digits
-  UInt_t mROFrameMax = 0;         ///< highest RO frame of current digits
-  UInt_t mNewROFrame = 0;         ///< ROFrame corresponding to provided time
+  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
 
-  UInt_t mEventROFrameMin = 0xffffffff; ///< lowest RO frame for processed events (w/o automatic noise ROFs)
-  UInt_t mEventROFrameMax = 0;          ///< highest RO frame forfor processed events (w/o automatic noise ROFs)
+  uint32_t mEventROFrameMin = 0xffffffff; ///< lowest RO frame for processed events (w/o automatic noise ROFs)
+  uint32_t mEventROFrameMax = 0;          ///< highest RO frame forfor processed events (w/o automatic noise ROFs)
 
   std::unique_ptr<o2::itsmft::AlpideSimResponse> mAlpSimResp; // simulated response
 

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

@@ -16,6 +16,7 @@
 #include "ITSMFTSimulation/Digitizer.h"
 #include "MathUtils/Cartesian.h"
 #include "SimulationDataFormat/MCTruthContainer.h"
+#include "DetectorsRaw/HBFUtils.h"
 
 #include <TRandom.h>
 #include <climits>
@@ -44,6 +45,7 @@ void Digitizer::init()
     mParams.setAlpSimResponse(mAlpSimResp.get());
   }
   mParams.print();
+  mIRFirstSampledTF = o2::raw::HBFUtils::Instance().getFirstSampledTFIR();
 }
 
 //_______________________________________________________________________
@@ -92,7 +94,7 @@ void Digitizer::setEventTime(const o2::InteractionTimeRecord& irt)
   // RO frame corresponding to provided time
   mCollisionTimeWrtROF = mEventTime.timeInBCNS; // in triggered mode the ROF starts at BC (is there a delay?)
   if (mParams.isContinuous()) {
-    auto nbc = mEventTime.toLong();
+    auto nbc = mEventTime.differenceInBC(mIRFirstSampledTF);
     if (mCollisionTimeWrtROF < 0 && nbc > 0) {
       nbc--;
     }
@@ -114,7 +116,7 @@ void Digitizer::setEventTime(const o2::InteractionTimeRecord& irt)
 }
 
 //_______________________________________________________________________
-void Digitizer::fillOutputContainer(UInt_t frameLast)
+void Digitizer::fillOutputContainer(uint32_t frameLast)
 {
   // fill output with digits from min.cached up to requested frame, generating the noise beforehand
   if (frameLast > mROFrameMax) {
@@ -164,7 +166,7 @@ void Digitizer::fillOutputContainer(UInt_t frameLast)
     // finalize ROF record
     rcROF.setNEntries(mDigits->size() - rcROF.getFirstEntry()); // number of digits
     if (isContinuous()) {
-      rcROF.getBCData().setFromLong(mROFrameMin * mParams.getROFrameLengthInBC());
+      rcROF.getBCData().setFromLong(mIRFirstSampledTF.toLong() + mROFrameMin * mParams.getROFrameLengthInBC());
     } else {
       rcROF.getBCData() = mEventTime; // RSTODO do we need to add trigger delay?
     }
@@ -179,7 +181,7 @@ void Digitizer::fillOutputContainer(UInt_t frameLast)
 }
 
 //_______________________________________________________________________
-void Digitizer::processHit(const o2::itsmft::Hit& hit, UInt_t& maxFr, int evID, int srcID)
+void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID, int srcID)
 {
   // convert single hit to digits
   float timeInROF = hit.GetTime() * sec2ns;
@@ -203,9 +205,9 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, UInt_t& maxFr, int evID,
   // frame of the hit signal start wrt event ROFrame
   int roFrameRel = int(timeInROF * mParams.getROFrameLengthInv());
   // frame of the hit signal end  wrt event ROFrame: in the triggered mode we read just 1 frame
-  UInt_t roFrameRelMax = mParams.isContinuous() ? (timeInROF + tTot) * mParams.getROFrameLengthInv() : roFrameRel;
+  uint32_t roFrameRelMax = mParams.isContinuous() ? (timeInROF + tTot) * mParams.getROFrameLengthInv() : roFrameRel;
   int nFrames = roFrameRelMax + 1 - roFrameRel;
-  UInt_t roFrameMax = mNewROFrame + roFrameRelMax;
+  uint32_t roFrameMax = mNewROFrame + roFrameRelMax;
   if (roFrameMax > maxFr) {
     maxFr = roFrameMax; // if signal extends beyond current maxFrame, increase the latter
   }
@@ -325,7 +327,7 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, UInt_t& maxFr, int evID,
   auto& chip = mChips[hit.GetDetectorID()];
   auto roFrameAbs = mNewROFrame + roFrameRel;
   for (int irow = rowSpan; irow--;) {
-    UShort_t rowIS = irow + rowS;
+    uint16_t rowIS = irow + rowS;
     for (int icol = colSpan; icol--;) {
       float nEleResp = respMatrix[irow][icol];
       if (!nEleResp) {
@@ -336,24 +338,24 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, UInt_t& maxFr, int evID,
       if (nEle < mParams.getMinChargeToAccount()) {
         continue;
       }
-      UShort_t colIS = icol + colS;
+      uint16_t colIS = icol + colS;
       //
       registerDigits(chip, roFrameAbs, timeInROF, nFrames, rowIS, colIS, nEle, lbl);
     }
   }
 }
 
 //________________________________________________________________________________
-void Digitizer::registerDigits(ChipDigitsContainer& chip, UInt_t roFrame, float tInROF, int nROF,
-                               UShort_t row, UShort_t col, int nEle, o2::MCCompLabel& lbl)
+void Digitizer::registerDigits(ChipDigitsContainer& chip, uint32_t roFrame, float tInROF, int nROF,
+                               uint16_t row, uint16_t col, int nEle, o2::MCCompLabel& lbl)
 {
   // Register digits for given pixel, accounting for the possible signal contribution to
   // multiple ROFrame. The signal starts at time tInROF wrt the start of provided roFrame
   // In every ROFrame we check the collected signal during strobe
 
   float tStrobe = mParams.getStrobeDelay() - tInROF; // strobe start wrt signal start
   for (int i = 0; i < nROF; i++) {
-    UInt_t roFr = roFrame + i;
+    uint32_t roFr = roFrame + i;
     int nEleROF = mParams.getSignalShape().getCollectedCharge(nEle, tStrobe, tStrobe + mParams.getStrobeLength());
     tStrobe += mParams.getROFrameLength(); // for the next ROF