Realistic BTOF digitization

src/algorithms/digi/TOFHitDigiConfig.h

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// Copyright (C) 2024 Souvik Paul
+
+#pragma once
+
+#include <DD4hep/DD4hepUnits.h>
+
+namespace eicrecon {
+
+struct TOFHitDigiConfig {
+  // single hit energy deposition threshold
+  double threshold{1.0 * dd4hep::keV};
+  double tRes = 0.1; /// TODO 8 of what units??? Same TODO in juggler. Probably [ns]
+                     // digitization settings
+  // unsigned int             pedMeanADC{0};
+  // double                   pedSigmaADC{0};
+  double resolutionTDC{1};
+  double resolutionADC{1};
+
+  // Parameters of AC-LGAD signal generation - Added by Souvik
+  double gain           = 80;
+  double risetime       = 0.45; // 0.02; //in ns
+  double sigma_analog   = 0.293951;
+  double sigma_sharingx = 0.1;
+  double sigma_sharingy = 0.5;
+  double Vm             = -1e-4 * gain; // Vm = voltage maximum. When EDep = 1e-4 GeV, voltage corresponds to ADC = adc_max
+  double t_thres        = 0.1 * Vm;
+  double ignore_thres   = 0.01 * Vm; // If EDep below this value, digitization for the cell will be ignored. Speed up calculation
+                                     //
+  double tMin     = 0.1;
+  double tMax     = 100.0;
+  int total_time  = ceil(tMax - tMin);
+  int time_period = 25;
+  int nBins       = 1024;
+  int adc_bit     = 8;
+  int tdc_bit     = 10;
+
+  int adc_range = pow(2, adc_bit);
+  int tdc_range = pow(2, tdc_bit);
+};
+
+} // namespace eicrecon

src/detectors/BTOF/BTOF.cc

@@ -18,34 +18,29 @@
 #include "extensions/jana/JOmniFactoryGeneratorT.h"
 #include "factories/digi/SiliconTrackerDigi_factory.h"
 #include "factories/tracking/TrackerHitReconstruction_factory.h"
+#include "factories/digi/BTOFChargeSharing_factory.h"
+#include "factories/digi/TOFPulseGeneration_factory.h"
+#include "factories/digi/TOFPulseDigitization_factory.h"
 #include "global/pid_lut/PIDLookup_factory.h"
 #include "services/geometry/dd4hep/DD4hep_service.h"
 
 extern "C" {
-void InitPlugin(JApplication *app) {
-    InitJANAPlugin(app);
+void InitPlugin(JApplication* app) {
+  InitJANAPlugin(app);
 
-    using namespace eicrecon;
+  using namespace eicrecon;
 
-    // Digitization
-    app->Add(new JOmniFactoryGeneratorT<SiliconTrackerDigi_factory>(
-        "TOFBarrelRawHit",
-        {
-          "TOFBarrelHits"
-        },
-        {
-          "TOFBarrelRawHit",
-          "TOFBarrelRawHitAssociations"
-        },
-        {
-            .threshold = 6.0 * dd4hep::keV,
-            .timeResolution = 0.025,    // [ns]
-        },
-        app
-    ));
+  // Digitization
+  app->Add(new JOmniFactoryGeneratorT<SiliconTrackerDigi_factory>(
+      "TOFBarrelRawHit", {"TOFBarrelHits"}, {"TOFBarrelRawHit", "TOFBarrelRawHitAssociations"},
+      {
+          .threshold      = 6.0 * dd4hep::keV,
+          .timeResolution = 0.025, // [ns]
+      },
+      app));
 
-    // Convert raw digitized hits into hits with geometry info (ready for tracking)
-    app->Add(new JOmniFactoryGeneratorT<TrackerHitReconstruction_factory>(
+// Convert raw digitized hits into hits with geometry info (ready for tracking)
+      app->Add(new JOmniFactoryGeneratorT<TrackerHitReconstruction_factory>(
         "TOFBarrelRecHit",
         {"TOFBarrelRawHit"},    // Input data collection tags
         {"TOFBarrelRecHit"},     // Output data tag
@@ -55,53 +50,75 @@ void InitPlugin(JApplication *app) {
         app
     ));         // Hit reco default config for factories
 
-    int BarrelTOF_ID = 0;
-    try {
-        auto detector = app->GetService<DD4hep_service>()->detector();
-        BarrelTOF_ID = detector->constant<int>("BarrelTOF_ID");
-    } catch(const std::runtime_error&) {
-        // Nothing
-    }
-    PIDLookupConfig pid_cfg {
-      .filename="calibrations/tof.lut",
-      .system=BarrelTOF_ID,
-      .pdg_values={11, 211, 321, 2212},
-      .charge_values={1},
-      .momentum_edges={0.0, 0.3, 0.6, 0.9, 1.2, 1.5, 1.8, 2.1, 2.4, 2.7, 3.0, 3.3, 3.6, 3.9, 4.2, 4.5, 4.8, 5.1, 5.4, 5.7, 6.0},
-      .polar_edges={2.50, 10.95, 19.40, 27.85, 36.30, 44.75, 53.20, 61.65, 70.10, 78.55, 87.00, 95.45, 103.90, 112.35, 120.80, 129.25, 137.70, 146.15, 154.60},
-      .azimuthal_binning={0., 360., 360.}, // lower, upper, step
-      .momentum_bin_centers_in_lut=true,
-      .polar_bin_centers_in_lut=true,
-    };
+  app->Add(new JOmniFactoryGeneratorT<BTOFChargeSharing_factory>(
+      "BTOFChargeSharing",
+      {"TOFBarrelHits"},
+      {"TOFBarrelSharedHits"},
+      {},
+      app
+  ));
+
+  app->Add(new JOmniFactoryGeneratorT<TOFPulseGeneration_factory>(
+      "BTOFPulseGeneration",
+      {"TOFBarrelSharedHits"},
+      {"TOFBarrelPulse"},
+      {},
+      app
+  ));
+
+  app->Add(new JOmniFactoryGeneratorT<TOFPulseDigitization_factory>(
+      "BTOFPulseDigitization",
+      {"TOFBarrelPulse"},
+      {"TOFBarrelADCTDC"},
+      {},
+      app
+  ));
+
+  int BarrelTOF_ID = 0;
+  try {
+    auto detector = app->GetService<DD4hep_service>()->detector();
+    BarrelTOF_ID  = detector->constant<int>("BarrelTOF_ID");
+  } catch (const std::runtime_error&) {
+    // Nothing
+  }
+  PIDLookupConfig pid_cfg{
+      .filename       = "calibrations/tof.lut",
+      .system         = BarrelTOF_ID,
+      .pdg_values     = {11, 211, 321, 2212},
+      .charge_values  = {1},
+      .momentum_edges = {0.0, 0.3, 0.6, 0.9, 1.2, 1.5, 1.8, 2.1, 2.4, 2.7, 3.0,
+                         3.3, 3.6, 3.9, 4.2, 4.5, 4.8, 5.1, 5.4, 5.7, 6.0},
+      .polar_edges    = {2.50, 10.95, 19.40, 27.85, 36.30, 44.75, 53.20, 61.65, 70.10, 78.55, 87.00,
+                         95.45, 103.90, 112.35, 120.80, 129.25, 137.70, 146.15, 154.60},
+      .azimuthal_binning           = {0., 360., 360.}, // lower, upper, step
+      .momentum_bin_centers_in_lut = true,
+      .polar_bin_centers_in_lut    = true,
+  };
 
-    app->Add(new JOmniFactoryGeneratorT<PIDLookup_factory>(
-          "CombinedTOFTruthSeededLUTPID",
-          {
+  app->Add(new JOmniFactoryGeneratorT<PIDLookup_factory>(
+      "CombinedTOFTruthSeededLUTPID",
+      {
           "ReconstructedTruthSeededChargedWithPFRICHPIDParticles",
           "ReconstructedTruthSeededChargedWithPFRICHPIDParticleAssociations",
-          },
-          {
+      },
+      {
           "ReconstructedTruthSeededChargedWithPFRICHTOFPIDParticles",
           "ReconstructedTruthSeededChargedWithPFRICHTOFPIDParticleAssociations",
           "CombinedTOFTruthSeededParticleIDs",
-          },
-          pid_cfg,
-          app
-          ));
+      },
+      pid_cfg, app));
 
-    app->Add(new JOmniFactoryGeneratorT<PIDLookup_factory>(
-          "CombinedTOFLUTPID",
-          {
+  app->Add(new JOmniFactoryGeneratorT<PIDLookup_factory>(
+      "CombinedTOFLUTPID",
+      {
           "ReconstructedChargedWithPFRICHPIDParticles",
           "ReconstructedChargedWithPFRICHPIDParticleAssociations",
-          },
-          {
+      },
+      {
           "ReconstructedChargedWithPFRICHTOFPIDParticles",
           "ReconstructedChargedWithPFRICHTOFPIDParticleAssociations",
           "CombinedTOFParticleIDs",
-          },
-          pid_cfg,
-          app
-          ));
+      },
+      pid_cfg, app));
 }
 } // extern "C"

src/detectors/BTOF/BTOFChargeSharing.cc

@@ -0,0 +1,182 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// Copyright (C) 2024 Chun Yuen Tsang, Prithwish Tribedy
+//
+// Spread energy desposition from one strip to neighboring strips within sensor boundaries
+
+// Author: Chun Yuen Tsang
+// Date: 10/22/2024
+
+#include "DD4hep/Detector.h"
+#include "DDRec/Surface.h"
+#include "TF1.h"
+#include "TMath.h"
+#include <Evaluator/DD4hepUnits.h>
+#include <TGraph.h>
+#include <bitset>
+#include <fmt/format.h>
+#include <iostream>
+#include <vector>
+
+#include "BTOFChargeSharing.h"
+#include "Math/SpecFunc.h"
+#include "algorithms/digi/TOFHitDigiConfig.h"
+#include <algorithms/geo.h>
+
+// using namespace dd4hep;
+// using namespace dd4hep::Geometry;
+// using namespace dd4hep::DDRec;
+// using namespace eicrecon;
+using namespace dd4hep::xml;
+
+namespace eicrecon {
+
+void BTOFChargeSharing::init() {
+  m_detector = algorithms::GeoSvc::instance().detector();;
+  m_converter = algorithms::GeoSvc::instance().cellIDPositionConverter();
+
+  auto seg       = m_detector->readout("TOFBarrelHits").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();
+}
+
+void BTOFChargeSharing::_findAllNeighborsInSensor(
+    dd4hep::rec::CellID hitCell, std::shared_ptr<std::vector<dd4hep::rec::CellID>>& ans,
+    std::unordered_set<dd4hep::rec::CellID>& dp) const {
+  // use MST to find all neighbor within a sensor
+  // I can probably write down the formula by hand, but why do things manually when computer do
+  // everything for you?
+  const std::vector<std::pair<int, int>> searchDirs{{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+  ans->push_back(hitCell);
+  dp.insert(hitCell);
+
+  auto sensorID = this -> _getSensorID(hitCell);
+  auto xID      = m_decoder->get(hitCell, "x");
+  auto yID      = m_decoder->get(hitCell, "y");
+  for (const auto& dir : searchDirs) {
+    auto testCell = hitCell;
+    try {
+      m_decoder->set(testCell, "x", xID + dir.first);
+      m_decoder->set(testCell, "y", yID + dir.second);
+    } catch (const std::runtime_error& err) {
+      // catch overflow error
+      // ignore if invalid position ID
+      continue;
+    }
+
+    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()) {
+      auto testSensorID = _getSensorID(testCell);
+      if (testSensorID == sensorID) {
+        // inside the same sensor
+        this->_findAllNeighborsInSensor(testCell, ans, dp);
+      }
+    }
+  }
+}
+
+const dd4hep::rec::CellID
+BTOFChargeSharing::_getSensorID(const dd4hep::rec::CellID& hitCell) const {
+  // fix x-y, what you left with are ids that corresponds to sensor info
+  // cellID may change when position changes.
+  auto sensorID = hitCell; //_converter -> cellID(_converter -> position(hitCell));
+  m_decoder->set(sensorID, "x", 0);
+  m_decoder->set(sensorID, "y", 0);
+
+  return sensorID;
+}
+
+double BTOFChargeSharing::_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
+  double up  = -0.5 * ROOT::Math::erf(TMath::Sqrt(2) * (mean - up_lim) / sd);
+  double low = -0.5 * ROOT::Math::erf(TMath::Sqrt(2) * (mean - low_lim) / sd);
+  return up - low;
+}
+
+dd4hep::Position BTOFChargeSharing::_cell2LocalPosition(const dd4hep::rec::CellID& cell) const {
+  auto position   = m_converter -> position(cell); // global position
+  return this -> _global2Local(position);
+}
+
+dd4hep::Position BTOFChargeSharing::_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;
+}
+
+void BTOFChargeSharing::process(const BTOFChargeSharing::Input& input,
+                                const BTOFChargeSharing::Output& output) const {
+  const auto [simhits] = input;
+  auto [sharedHits] = output;
+  std::shared_ptr<std::vector<dd4hep::rec::CellID>> neighbors;
+
+  for(const auto & hit : *simhits) {
+    auto cellID = hit.getCellID();
+    /*if(m_useCache) {
+      auto it = m_cache.find(cellID);
+      if(it != m_cache.end())
+        neighbors = it -> second;
+    }*/
+
+    if(!neighbors){
+      std::unordered_set<dd4hep::rec::CellID> dp;
+      neighbors = std::make_shared<std::vector<dd4hep::rec::CellID>>();
+      this -> _findAllNeighborsInSensor(cellID, neighbors, dp);
+
+      // fill cache
+      /*if(m_useCache)
+         for(const auto cell : *neighbors)
+           m_cache[cell] = neighbors;*/
+    }
+
+    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 / 10., truePos.y / 10., truePos.z / 10.));
+
+    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});
+       }
+    }
+  }
+} // BTOFChargeSharing:process
+} // namespace eicrecon