Realistic BTOF digitization

src/algorithms/digi/LGADChargeSharing.cc

@@ -0,0 +1,185 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// Copyright (C) 2024 Chun Yuen Tsang, Prithwish Tribedy
+//
+// Spread energy deposition from one strip to neighboring strips within sensor boundaries
+
+#include <DD4hep/DetElement.h>
+#include <DD4hep/Handle.h>
+#include <DD4hep/Readout.h>
+#include <DD4hep/Segmentations.h>
+#include <DD4hep/Volumes.h>
+#include <Evaluator/DD4hepUnits.h>
+#include <Math/GenVector/Cartesian3D.h>
+#include <Math/GenVector/DisplacementVector3D.h>
+#include <TGeoManager.h>
+#include <TGeoMatrix.h>
+#include <TGeoVolume.h>
+#include <algorithms/geo.h>
+#include <algorithms/service.h>
+#include <edm4hep/Vector3d.h>
+#include <edm4hep/Vector3f.h>
+#include <fmt/core.h>
+#include <cmath>
+#include <gsl/pointers>
+#include <stdexcept>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "DD4hep/Detector.h"
+#include "LGADChargeSharing.h"
+#include "algorithms/digi/LGADChargeSharingConfig.h"
+#include "services/evaluator/EvaluatorSvc.h"
+
+namespace eicrecon {
+
+void LGADChargeSharing::init() {
+  m_detector = algorithms::GeoSvc::instance().detector();
+  m_converter = algorithms::GeoSvc::instance().cellIDPositionConverter();
+
+  auto seg  = m_detector->readout(m_cfg.readout).segmentation();
+  auto type = seg.type();
+  if (type != "CartesianGridXY")
+    throw std::runtime_error("Unsupported segmentation type: " + type +
+                             ". BarrelTOF must use CartesianGridXY.");
+  // retrieve meaning of cellID bits
+  m_decoder = seg.decoder();
+  m_idSpec = m_detector->readout(m_cfg.readout).idSpec();
+
+  // convert cellID to name value pairs for EvaluatorSvc to determine of different cells are neighbors
+  std::function hit_pair_to_map = [this](const dd4hep::rec::CellID& id1, const dd4hep::rec::CellID& id2) {
+      std::unordered_map<std::string, double> params;
+      for(const auto &p : m_idSpec.fields()) {
+        const std::string &name = p.first;
+        const dd4hep::IDDescriptor::Field* field = p.second;
+        params.emplace(name + "_1", field->value(id1));
+        params.emplace(name + "_2", field->value(id2));
+        trace("{}_1 = {}", name, field->value(id1));
+        trace("{}_2 = {}", name, field->value(id2));
+      }
+      return params;
+    };
+
+  auto& serviceSvc = algorithms::ServiceSvc::instance();
+  _is_same_sensor = serviceSvc.service<EvaluatorSvc>("EvaluatorSvc")->compile(m_cfg.same_sensor_condition, hit_pair_to_map);
+
+}
+
+void LGADChargeSharing::process(const LGADChargeSharing::Input& input,
+                                const LGADChargeSharing::Output& output) const {
+  const auto [simhits] = input;
+  auto [sharedHits]    = output;
+
+  for (const auto& hit : *simhits) {
+    auto cellID = hit.getCellID();
+
+    std::unordered_set<dd4hep::rec::CellID> dp;
+    std::vector<dd4hep::rec::CellID> neighbors;
+    this->_findAllNeighborsInSensor(cellID, neighbors, dp);
+
+    double edep       = hit.getEDep();
+    double time       = hit.getTime();
+    auto momentum     = hit.getMomentum();
+    auto truePos      = hit.getPosition();
+    auto localPos_hit = this->_global2Local(
+        dd4hep::Position(truePos.x * dd4hep::mm, truePos.y * dd4hep::mm, truePos.z * dd4hep::mm));
+
+    for (const auto neighbor : neighbors) {
+      // integrate over neighbor area to get total energy deposition
+      auto localPos_neighbor = this->_cell2LocalPosition(neighbor);
+      auto cellDimension     = m_converter->cellDimensions(neighbor);
+
+      double edep_cell = edep *
+                         _integralGaus(localPos_hit.x(), m_cfg.sigma_sharingx,
+                                       localPos_neighbor.x() - 0.5 * cellDimension[0],
+                                       localPos_neighbor.x() + 0.5 * cellDimension[0]) *
+                         _integralGaus(localPos_hit.y(), m_cfg.sigma_sharingy,
+                                       localPos_neighbor.y() - 0.5 * cellDimension[1],
+                                       localPos_neighbor.y() + 0.5 * cellDimension[1]);
+
+      if (edep_cell > 0) {
+        auto globalPos = m_converter->position(neighbor);
+        auto hit       = sharedHits->create();
+        hit.setCellID(neighbor);
+        hit.setEDep(edep_cell);
+        hit.setTime(time);
+        hit.setPosition({globalPos.x(), globalPos.y(), globalPos.z()});
+        hit.setMomentum({momentum.x, momentum.y, momentum.z});
+      }
+    }
+  }
+} // LGADChargeSharing:process
+
+void LGADChargeSharing::_findAllNeighborsInSensor(
+    dd4hep::rec::CellID hitCell, std::vector<dd4hep::rec::CellID>& answer,
+    std::unordered_set<dd4hep::rec::CellID>& dp) const {
+  // search all neighbors with DFS
+  answer.push_back(hitCell);
+  dp.insert(hitCell);
+
+  for(const auto& field : m_cfg.neighbor_fields) {
+    // searchDir should either be +1 or -1
+    for(int searchDir = -1; searchDir <= 1; searchDir += 2) {
+      auto fieldID = m_decoder->get(hitCell, field);
+      auto testCell = hitCell;
+      try {
+        m_decoder->set(testCell, field, fieldID + searchDir);
+      } catch (const std::runtime_error& err) {
+        // catch overflow error
+        // ignore if invalid position ID
+        continue;
+      }
+
+      // check if new cellID really exists
+      try {
+        auto pos = m_converter->position(testCell);
+        if (testCell != m_converter->cellID(pos))
+          continue;
+      } catch (const std::invalid_argument& err) {
+        // Ignore CellID that is invalid
+        continue;
+      }
+
+      // only look for cells that have not been searched
+      if (dp.find(testCell) == dp.end()) {
+        if (_is_same_sensor(hitCell, testCell)) {
+          // inside the same sensor
+          this->_findAllNeighborsInSensor(testCell, answer, dp);
+        }
+      }
+    }
+  }
+}
+
+double LGADChargeSharing::_integralGaus(double mean, double sd, double low_lim,
+                                        double up_lim) const {
+  // return integral Gauss(mean, sd) dx from x = low_lim to x = up_lim
+  // default value is set when sd = 0
+  double up  = mean > up_lim ? -0.5 : 0.5;
+  double low = mean > low_lim ? -0.5 : 0.5;
+  if (sd > 0) {
+    up  = -0.5 * std::erf(std::sqrt(2) * (mean - up_lim) / sd);
+    low = -0.5 * std::erf(std::sqrt(2) * (mean - low_lim) / sd);
+  }
+  return up - low;
+}
+
+dd4hep::Position LGADChargeSharing::_cell2LocalPosition(const dd4hep::rec::CellID& cell) const {
+  auto position = m_converter->position(cell); // global position
+  return this->_global2Local(position);
+}
+
+dd4hep::Position LGADChargeSharing::_global2Local(const dd4hep::Position& pos) const {
+  auto geoManager = m_detector->world().volume()->GetGeoManager();
+  auto node       = geoManager->FindNode(pos.x(), pos.y(), pos.z());
+  auto currMatrix = geoManager->GetCurrentMatrix();
+
+  double g[3], l[3];
+  pos.GetCoordinates(g);
+  currMatrix->MasterToLocal(g, l);
+  dd4hep::Position position;
+  position.SetCoordinates(l);
+  return position;
+}
+
+} // namespace eicrecon

src/algorithms/digi/LGADChargeSharing.h

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// Copyright (C) 2024 Chun Yuen Tsang, Prithwish Tribedy
+//
+// Spread energy deposition from one strip to neighboring strips within sensor boundaries
+
+#pragma once
+
+#include <DD4hep/IDDescriptor.h>
+#include <DD4hep/Objects.h>
+#include <DDRec/CellIDPositionConverter.h>
+#include <DDSegmentation/BitFieldCoder.h>
+#include <algorithms/algorithm.h>
+#include <edm4hep/SimTrackerHitCollection.h>
+#include <functional>
+#include <string>
+#include <string_view>
+#include <unordered_set>
+#include <vector>
+
+#include "DD4hep/Detector.h"
+#include "algorithms/digi/LGADChargeSharingConfig.h"
+#include "algorithms/interfaces/WithPodConfig.h"
+
+namespace eicrecon {
+
+using LGADChargeSharingAlgorithm =
+    algorithms::Algorithm<algorithms::Input<edm4hep::SimTrackerHitCollection>,
+                          algorithms::Output<edm4hep::SimTrackerHitCollection>>;
+
+class LGADChargeSharing : public LGADChargeSharingAlgorithm,
+                          public WithPodConfig<LGADChargeSharingConfig> {
+
+public:
+  LGADChargeSharing(std::string_view name)
+      : LGADChargeSharingAlgorithm{name, {"TOFBarrelHits"}, {"TOFBarrelSharedHits"}, ""} {};
+
+  void init() final;
+  void process(const Input&, const Output&) const final;
+
+private:
+  void _findAllNeighborsInSensor(dd4hep::rec::CellID hitCell,
+                                 std::vector<dd4hep::rec::CellID>& answer,
+                                 std::unordered_set<dd4hep::rec::CellID>& dp) const;
+  double _integralGaus(double mean, double sd, double low_lim, double up_lim) const;
+  dd4hep::Position _cell2LocalPosition(const dd4hep::rec::CellID& cell) const;
+  dd4hep::Position _global2Local(const dd4hep::Position& pos) const;
+
+  const dd4hep::DDSegmentation::BitFieldCoder* m_decoder  = nullptr;
+  const dd4hep::Detector* m_detector                      = nullptr;
+  const dd4hep::rec::CellIDPositionConverter* m_converter = nullptr;
+  dd4hep::IDDescriptor m_idSpec;
+
+  // helper function to find neighbors
+  std::function<bool(const dd4hep::rec::CellID &id1, const dd4hep::rec::CellID &id2)> _is_same_sensor;
+
+};
+
+} // namespace eicrecon

src/algorithms/digi/LGADChargeSharingConfig.h

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// Copyright (C) 2024 Souvik Paul
+
+#pragma once
+
+#include <DD4hep/DD4hepUnits.h>
+
+namespace eicrecon {
+
+struct LGADChargeSharingConfig {
+  // Parameters of AC-LGAD signal generation
+  double sigma_sharingx;
+  double sigma_sharingy;
+
+  std::string readout;
+  std::string same_sensor_condition;
+  std::vector<std::string> neighbor_fields;
+};
+
+} // namespace eicrecon

src/algorithms/digi/LGADPulseDigitization.cc

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// Copyright (C) 2024 Souvik Paul, Chun Yuen Tsang, Prithwish Tribedy
+// Special Acknowledgement: Kolja Kauder
+//
+// Convert ADC pulses from LGADPulseGeneration into ADC and TDC values
+
+#include <podio/RelationRange.h>
+#include <stdlib.h>
+#include <algorithm>
+#include <cmath>
+#include <gsl/pointers>
+#include <limits>
+#include <vector>
+
+#include "LGADPulseDigitization.h"
+#include "algorithms/digi/LGADPulseDigitizationConfig.h"
+
+namespace eicrecon {
+
+void LGADPulseDigitization::process(const LGADPulseDigitization::Input& input,
+                                   const LGADPulseDigitization::Output& output) const {
+  const auto [simhits] = input;
+  auto [rawhits]       = output;
+
+  double thres = m_cfg.t_thres;
+  int adc_range = m_cfg.adc_range;
+
+  for (const auto& pulse : *simhits) {
+    double intersectionX = 0.0;
+    int tdc              = std::numeric_limits<int>::max();
+    int adc              = 0;
+    double V             = 0.0;
+
+    int time_bin         = 0;
+    double adc_prev      = 0;
+    double time_interval = pulse.getInterval();
+    auto adcs            = pulse.getAdcCounts();
+    double n_EICROC_cycle = static_cast<int>(std::floor(pulse.getTime()/m_cfg.tMax + 1e-3));
+    for (const auto adc : adcs) {
+      if (adc_prev >= thres && adc <= thres) {
+        tdc = time_bin + n_EICROC_cycle * m_cfg.tdc_range;
+      }
+      if (std::abs(adc) > std::abs(V)) // To get peak of the Analog signal
+        V = adc;
+      adc_prev = adc;
+      ++time_bin;
+    }
+
+    // limit the range of adc values
+    adc = std::min(static_cast<double>(adc_range), std::round(-V));
+    // only store valid hits
+    if (tdc < std::numeric_limits<int>::max())
+      rawhits->create(pulse.getCellID(), adc, tdc);
+    //-----------------------------------------------------------
+  }
+} // LGADPulseDigitization:process
+} // namespace eicrecon

src/algorithms/digi/LGADPulseDigitization.h

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// Copyright (C) 2024 Souvik Paul, Chun Yuen Tsang, Prithwish Tribedy
+// Special Acknowledgement: Kolja Kauder
+//
+// Convert ADC pulses from LGADPulseGeneration into ADC and TDC values
+
+#pragma once
+
+#include <algorithms/algorithm.h>
+#include <edm4eic/RawTrackerHitCollection.h>
+#include <edm4hep/RawTimeSeriesCollection.h>
+#include <string>
+#include <string_view>
+
+#include "algorithms/digi/LGADPulseDigitizationConfig.h"
+#include "algorithms/interfaces/WithPodConfig.h"
+
+namespace eicrecon {
+
+using LGADPulseDigitizationAlgorithm =
+    algorithms::Algorithm<algorithms::Input<edm4hep::RawTimeSeriesCollection>,
+                          algorithms::Output<edm4eic::RawTrackerHitCollection>>;
+
+class LGADPulseDigitization : public LGADPulseDigitizationAlgorithm,
+                             public WithPodConfig<LGADPulseDigitizationConfig> {
+
+public:
+  LGADPulseDigitization(std::string_view name)
+      : LGADPulseDigitizationAlgorithm{name, {"LGADPulse"}, {"ADCTDCOutput"}, {}} {}
+  void init(){};
+  void process(const Input&, const Output&) const final;
+};
+
+} // namespace eicrecon

src/algorithms/digi/LGADPulseDigitizationConfig.h

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// Copyright (C) 2024 Souvik Paul
+
+#pragma once
+
+#include <DD4hep/DD4hepUnits.h>
+
+namespace eicrecon {
+
+struct LGADPulseDigitizationConfig {
+  int adc_bit = 8;
+  int tdc_bit = 10;
+  // total number of TDC/ADC values
+  // Since digitizer starts at zero, max ADC value = adc_range - 1
+  // Similar for TDC
+  int adc_range = std::pow(2, adc_bit);
+  int tdc_range = std::pow(2, tdc_bit);
+
+
+  double t_thres      = -0.1 * adc_range;  // TDC value = time when pulse exceed t_thres. Negative because LGAD voltage is negative when hit
+  // period of the sensor clock. Time internal to sensor will all be digitized to integer multiple
+  // of tInterval
+  double tMax         = 25 * dd4hep::ns; // 25 ns is the period of 40MHz EIC clock
+};
+
+} // namespace eicrecon