its3 digitization parameter sets

Author: ChunzhengLab

Detectors/Upgrades/ITS3/simulation/CMakeLists.txt

@@ -15,8 +15,10 @@ o2_add_library(ITS3Simulation
                        src/DescriptorInnerBarrelITS3.cxx
                        src/Digitizer.cxx
                        src/DigiParams.cxx
+                       src/ITS3DPLDigitizerParam.cxx
+                       src/ChipDigitsContainer.cxx
                PUBLIC_LINK_LIBRARIES O2::SimulationDataFormat
-                                     O2::ITSBase O2::ITSMFTSimulation
+                                     O2::ITSBase O2::ITSMFTSimulation O2::ITSMFTBase
                                      ROOT::Physics)
 
 o2_target_root_dictionary(ITS3Simulation
@@ -25,6 +27,8 @@ o2_target_root_dictionary(ITS3Simulation
                                   include/ITS3Simulation/DescriptorInnerBarrelITS3.h
                                   include/ITS3Simulation/Digitizer.h
                                   include/ITS3Simulation/DigiParams.h
+                                  include/ITS3Simulation/ITS3DPLDigitizerParam.h
+                                  include/ITS3Simulation/ChipDigitsContainer.h
                                   )
 
 o2_data_file(COPY data  DESTINATION Detectors/ITS3/simulation)

Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ChipDigitsContainer.h

@@ -0,0 +1,53 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef ALICEO2_ITS3_CHIPDIGITSCONTAINER_
+#define ALICEO2_ITS3_CHIPDIGITSCONTAINER_
+
+#include "ITSMFTBase/SegmentationAlpide.h"        // Base class in o2::itsmft namespace
+#include "ITSMFTSimulation/ChipDigitsContainer.h" // Base class in o2::itsmft namespace
+#include "ITS3Base/SegmentationMosaix.h"          // OB segmentation implementation
+#include "ITS3Base/SpecsV2.h"                     // Provides SpecsV2::isDetITS3() interface
+#include "ITS3Simulation/DigiParams.h"            // ITS3-specific DigiParams interface
+#include <TRandom.h>
+
+namespace o2
+{
+namespace its3
+{
+
+// IB uses the Alpide segmentation,
+// OB uses the Mosaix segmentation.
+using SegmentationIB = SegmentationMosaix;
+using SegmentationOB = o2::itsmft::SegmentationAlpide;
+class ChipDigitsContainer : public o2::itsmft::ChipDigitsContainer
+{
+ private:
+  bool innerBarrel; ///< true if the chip belongs to the inner barrel (IB), false if outer barrel (OB)
+  int maxRows;      ///< maximum number of rows
+  int maxCols;      ///< maximum number of columns
+
+ public:
+  explicit ChipDigitsContainer(UShort_t idx = 0);
+
+  /// Returns whether the chip is in the inner barrel (IB)
+  bool isIB() const;
+  /// Adds noise digits, deleted the one using the itsmft::DigiParams interface
+  void addNoise(UInt_t rofMin, UInt_t rofMax, const o2::itsmft::DigiParams* params, int maxRows = o2::itsmft::SegmentationAlpide::NRows, int maxCols = o2::itsmft::SegmentationAlpide::NCols) = delete;
+  void addNoise(UInt_t rofMin, UInt_t rofMax, const o2::its3::DigiParams* params);
+
+  ClassDefNV(ChipDigitsContainer, 1);
+};
+
+} // namespace its3
+} // namespace o2
+
+#endif // ALICEO2_ITS3_CHIPDIGITSCONTAINER_

Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DigiParams.h

@@ -19,7 +19,28 @@ namespace o2::its3
 
 class DigiParams final : public o2::itsmft::DigiParams
 {
+ private:
+  float mIBNoisePerPixel = 1.e-8;
+  int mIBChargeThreshold = 150;   ///< charge threshold in Nelectrons
+  int mIBMinChargeToAccount = 15; ///< minimum charge contribution to account
+  int mIBNSimSteps = 18;          ///< number of steps in response simulation
+  float mIBNSimStepsInv = 0;      ///< its inverse
+
  public:
+  DigiParams();
+
+  void setIBNoisePerPixel(float v) { mIBNoisePerPixel = v; }
+  float getIBNoisePerPixel() const { return mIBNoisePerPixel; }
+
+  void setIBChargeThreshold(int v, float frac2Account = 0.1);
+  int getIBChargeThreshold() const { return mIBChargeThreshold; }
+
+  void setIBNSimSteps(int v);
+  int getIBNSimSteps() const { return mIBNSimSteps; }
+  float getIBNSimStepsInv() const { return mIBNSimStepsInv; }
+
+  int getIBMinChargeToAccount() const { return mIBMinChargeToAccount; }
+
   const o2::itsmft::AlpideSimResponse* getAlpSimResponse() const = delete;
   void setAlpSimResponse(const o2::itsmft::AlpideSimResponse* par) = delete;
 

Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/Digitizer.h

@@ -21,12 +21,12 @@
 #include "Rtypes.h"
 #include "TObject.h"
 
-#include "ITSMFTSimulation/ChipDigitsContainer.h"
 #include "ITSMFTSimulation/AlpideSimResponse.h"
 #include "ITSMFTSimulation/Hit.h"
 #include "ITSBase/GeometryTGeo.h"
 #include "ITS3Base/SegmentationMosaix.h"
 #include "ITS3Simulation/DigiParams.h"
+#include "ITS3Simulation/ChipDigitsContainer.h"
 #include "DataFormatsITSMFT/Digit.h"
 #include "DataFormatsITSMFT/ROFRecord.h"
 #include "CommonDataFormat/InteractionRecord.h"
@@ -78,7 +78,7 @@ class Digitizer : public TObject
 
  private:
   void processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID, int srcID);
-  void registerDigits(o2::itsmft::ChipDigitsContainer& chip, uint32_t roFrame, float tInROF, int nROF,
+  void registerDigits(o2::its3::ChipDigitsContainer& chip, uint32_t roFrame, float tInROF, int nROF,
                       uint16_t row, uint16_t col, int nEle, o2::MCCompLabel& lbl);
 
   ExtraDig* getExtraDigBuffer(uint32_t roFrame)
@@ -118,7 +118,7 @@ class Digitizer : public TObject
 
   const o2::its::GeometryTGeo* mGeometry = nullptr; ///< ITS3 geometry
 
-  std::vector<o2::itsmft::ChipDigitsContainer> mChips; ///< Array of chips digits containers
+  std::vector<o2::its3::ChipDigitsContainer> mChips;   ///< Array of chips digits containers
   std::deque<std::unique_ptr<ExtraDig>> mExtraBuff;    ///< burrer (per roFrame) for extra digits
 
   std::vector<o2::itsmft::Digit>* mDigits = nullptr;                       //! output digits

Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ITS3DPLDigitizerParam.h

@@ -0,0 +1,33 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+
+#ifndef ALICEO2_ITS3DPLDIGITIZERPARAM_H_
+#define ALICEO2_ITS3DPLDIGITIZERPARAM_H_
+
+#include "CommonUtils/ConfigurableParam.h"
+#include "CommonUtils/ConfigurableParamHelper.h"
+#include "ITSMFTSimulation/DPLDigitizerParam.h"
+#include <string>
+
+namespace o2
+{
+namespace its3
+{
+
+struct ITS3DPLDigitizerParam : public o2::conf::ConfigurableParamHelper<ITS3DPLDigitizerParam> {
+  float IBNoisePerPixel = 1.e-8; ///< MOSAIX Noise per channel
+  int IBChargeThreshold = 150;   ///< charge threshold in Nelectrons for IB
+  int IBMinChargeToAccount = 15; ///< minimum charge contribution to account for IB
+  int nIBSimSteps = 18;          ///< number of steps in response for IB
+
+  O2ParamDef(ITS3DPLDigitizerParam, "ITS3DPLDigitizerParam");
+};
+
+} // namespace its3
+} // namespace o2
+
+#endif

Detectors/Upgrades/ITS3/simulation/src/ChipDigitsContainer.cxx

@@ -0,0 +1,68 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "ITS3Simulation/ChipDigitsContainer.h"
+
+namespace o2
+{
+namespace its3
+{
+
+ChipDigitsContainer::ChipDigitsContainer(UShort_t idx)
+  : o2::itsmft::ChipDigitsContainer(idx),
+    innerBarrel(constants::detID::isDetITS3(idx)),
+    maxRows(innerBarrel ? SegmentationOB::NRows : SegmentationIB::NRows),
+    maxCols(innerBarrel ? SegmentationOB::NCols : SegmentationIB::NCols)
+{
+}
+
+bool ChipDigitsContainer::isIB() const
+{
+  return innerBarrel;
+}
+
+void ChipDigitsContainer::addNoise(UInt_t rofMin, UInt_t rofMax, const o2::its3::DigiParams* params)
+{
+  UInt_t row = 0;
+  UInt_t col = 0;
+  Int_t nhits = 0;
+  constexpr float ns2sec = 1e-9;
+  float mean = 0.f;
+  int nel = 0;
+
+  if (isIB()) {
+    // Inner barrel: use ITS3-specific noise interface with OB segmentation.
+    mean = params->getIBNoisePerPixel() * SegmentationOB::NPixels;
+    nel = static_cast<int>(params->getIBChargeThreshold() * 1.1);
+  } else {
+    // Outer barrel: use base class noise interface with IB segmentation.
+    mean = params->getNoisePerPixel() * SegmentationIB::NPixels;
+    nel = static_cast<int>(params->getChargeThreshold() * 1.1);
+  }
+
+  for (UInt_t rof = rofMin; rof <= rofMax; ++rof) {
+    nhits = gRandom->Poisson(mean);
+    for (Int_t i = 0; i < nhits; ++i) {
+      row = gRandom->Integer(maxRows);
+      col = gRandom->Integer(maxCols);
+      if (mNoiseMap && mNoiseMap->isNoisy(mChipIndex, row, col))
+        continue;
+      if (mDeadChanMap && mDeadChanMap->isNoisy(mChipIndex, row, col))
+        continue;
+      auto key = getOrderingKey(rof, row, col);
+      if (!findDigit(key))
+        addDigit(key, rof, row, col, nel, o2::MCCompLabel(true));
+    }
+  }
+}
+
+} // namespace its3
+} // namespace o2

Detectors/Upgrades/ITS3/simulation/src/DigiParams.cxx

@@ -20,19 +20,50 @@ ClassImp(o2::its3::DigiParams);
 namespace o2::its3
 {
 
+DigiParams::DigiParams()
+{
+  // make sure the defaults are consistent
+  setIBNSimSteps(mIBNSimSteps);
+}
+
+void DigiParams::setIBNSimSteps(int v)
+{
+  // set number of sampling steps in silicon
+  mIBNSimSteps = v > 0 ? v : 1;
+  mIBNSimStepsInv = 1.f / mIBNSimSteps;
+}
+
+void DigiParams::setIBChargeThreshold(int v, float frac2Account)
+{
+  // set charge threshold for digits creation and its fraction to account
+  // contribution from single hit
+  mIBChargeThreshold = v;
+  mIBMinChargeToAccount = v * frac2Account;
+  if (mIBMinChargeToAccount < 0 || mIBMinChargeToAccount > mIBChargeThreshold) {
+    mIBMinChargeToAccount = mIBChargeThreshold;
+  }
+  LOG(info) << "Set Mosaix charge threshold to " << mIBChargeThreshold
+            << ", single hit will be accounted from " << mIBMinChargeToAccount
+            << " electrons";
+}
+
 void DigiParams::print() const
 {
   // print settings
   LOGF(info, "ITS3 DigiParams settings:");
-  LOGF(info, "Continuous readout             : %s", isContinuous() ? "ON" : "OFF");
-  LOGF(info, "Readout Frame Length(ns)       : %f", getROFrameLength());
-  LOGF(info, "Strobe delay (ns)              : %f", getStrobeDelay());
-  LOGF(info, "Strobe length (ns)             : %f", getStrobeLength());
-  LOGF(info, "Threshold (N electrons)        : %d", getChargeThreshold());
-  LOGF(info, "Min N electrons to account     : %d", getMinChargeToAccount());
-  LOGF(info, "Number of charge sharing steps : %d", getNSimSteps());
-  LOGF(info, "ELoss to N electrons factor    : %e", getEnergyToNElectrons());
-  LOGF(info, "Noise level per pixel          : %e", getNoisePerPixel());
+  LOGF(info, "Continuous readout                : %s", isContinuous() ? "ON" : "OFF");
+  LOGF(info, "Readout Frame Length(ns)          : %f", getROFrameLength());
+  LOGF(info, "Strobe delay (ns)                 : %f", getStrobeDelay());
+  LOGF(info, "Strobe length (ns)                : %f", getStrobeLength());
+  LOGF(info, "IB Threshold (N electrons)        : %d", getIBChargeThreshold());
+  LOGF(info, "OB Threshold (N electrons)        : %d", getChargeThreshold());
+  LOGF(info, "Min N electrons to account for IB : %d", getIBMinChargeToAccount());
+  LOGF(info, "Min N electrons to account for OB : %d", getMinChargeToAccount());
+  LOGF(info, "Number of charge sharing steps of IB    : %d", getIBNSimSteps());
+  LOGF(info, "Number of charge sharing steps of OB    : %d", getNSimSteps());
+  LOGF(info, "ELoss to N electrons factor       : %e", getEnergyToNElectrons());
+  LOGF(info, "Noise level per pixel of IB       : %e", getIBNoisePerPixel());
+  LOGF(info, "Noise level per pixel of OB       : %e", getNoisePerPixel());
   LOGF(info, "Charge time-response:\n");
   getSignalShape().print();
 }