SiStripDigitizer.h

#pragma once
 
#include <map>
#include <random>
#include <utility>
 
#include "Acts/Definitions/Algebra.hpp"
#include "SimCore/Event/SimTrackerHit.h"
#include "Tracking/Digitization/SiStripConstants.h"
 
namespace tracking::digitization {
 
class SiStripDigitizer {
 public:
  struct SensorParams {
    double thickness{0.0};
    double sense_pitch{SENSE_PITCH_MM};
    double readout_pitch{READOUT_PITCH_MM};
    double bias_voltage{BIAS_VOLTAGE_V};
    double depletion_voltage{DEPLETION_VOLTAGE_V};
    double temperature{TEMPERATURE_K};
    double noise_electrons{NOISE_ELECTRONS};
    double threshold_electrons{THRESHOLD_ELECTRONS};
    bool is_n_type{true};
    bool electron_side_readout{false};
    bool hole_side_readout{true};
    /*****   lorentz angles should be calculated from sensor geometry  and
     * bfield  *********/
    double electron_lorentz_tangent{0.0};
    double hole_lorentz_tangent{0.0};
    double trapping{0.0};
    double deposition_granularity{0.10};
    int n_segments_min{5};
    int n_readout_strips{N_READOUT_STRIPS};
    double readout_transfer_efficiency{READOUT_TRANSFER_EFFICIENCY};
    double sense_transfer_efficiency{SENSE_TRANSFER_EFFICIENCY};
  };
 
  SiStripDigitizer() = default;
 
  explicit SiStripDigitizer(const SensorParams& params) : params_(params) {}
 
  void seed(uint64_t s) { generator_.seed(s); }
 
  std::map<int, double> computeStripCharges(double edep,
                                            const Acts::Vector3& local_pos,
                                            const Acts::Vector3& local_dir,
                                            double path_length) const;
 
  void applyNoiseAndThreshold(std::map<int, double>& strip_charges);
 
  const SensorParams& params() const { return params_; }
  SensorParams& mutableParams() { return params_; }
 
  void setThickness(double thickness) { params_.thickness = thickness; }
 
 private:
  int adaptiveNSegments(const Acts::Vector3& local_dir,
                        double path_length) const;
 
  double diffusionSigma(double d, bool is_minority) const;
 
  double stripFraction(double u0, double sigma, double strip_center,
                       double pitch) const;
 
  std::map<int, double> computeCarrierCharges(
      double q_per_seg, int n_seg, const Acts::Vector3& local_pos,
      const Acts::Vector3& local_dir, double path_length, double w_collect,
      double lorentz_tan, bool is_minority) const;
 
  std::map<int, double> senseToReadout(
      const std::map<int, double>& sense_charges) const;
 
  SensorParams params_;
  std::default_random_engine generator_;
  std::normal_distribution<double> normal_{0.0, 1.0};
};
 
}  // namespace tracking::digitization