Realistic digitization of silicon strip sensor hits. More...

#include <SiStripDigitizer.h>

Classes
struct	SensorParams
	All parameters describing one silicon strip sensor layer. More...

Public Member Functions
	SiStripDigitizer (const SensorParams &params)

void	seed (uint64_t s)
	Seed the internal random-number engine.

std::map< int, double >	computeStripCharges (double edep, const Acts::Vector3 &local_pos, const Acts::Vector3 &local_dir, double path_length) const
	Simulate charge collection for a single hit.

void	applyNoiseAndThreshold (std::map< int, double > &strip_charges)
	Add Gaussian electronic noise to signal strips and their immediate neighbours, then remove strips below the readout threshold.

const SensorParams &	params () const

SensorParams &	mutableParams ()

void	setThickness (double thickness)
	Set the sensor thickness [mm] from the geometry before processing hits.

Private Member Functions
int	adaptiveNSegments (const Acts::Vector3 &local_dir, double path_length) const
	Number of track sub-segments, chosen adaptively so that the U displacement per segment does not exceed deposition_granularity × sense_pitch.

double	diffusionSigma (double d, bool is_minority) const
	Diffusion sigma [mm] for carriers drifting distance `d` [mm].

double	stripFraction (double u0, double sigma, double strip_center, double pitch) const
	Fraction of a Gaussian charge cloud (centred at `u0` with sigma `sigma`) collected by a strip of width `pitch` centred at `strip_center`.

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
	Simulate one carrier type and return the sense-strip charge map.

std::map< int, double >	senseToReadout (const std::map< int, double > &sense_charges) const
	Sum sense-strip charges into readout-strip charges according to the AC-coupling ratio ratio = round(readout_pitch / sense_pitch).

Private Attributes
SensorParams	params_

std::default_random_engine	generator_

std::normal_distribution< double >	normal_ {0.0, 1.0}

Detailed Description

Realistic digitization of silicon strip sensor hits.

Follows the physics model of CDFSiSensorSim (itself a port of the LCSIM / HPS Java digitization). For each SimTrackerHit the track segment through the sensor is divided adaptively into sub-segments whose number is chosen so that the U displacement per segment is at most a configurable fraction of the sense pitch. For each sub-segment:

Charge creation: N_ehp = Edep / E_pair (E_pair = 3.62 eV for Si).
Charge trapping: linear collection-efficiency penalty proportional to drift distance (configurable; 0 for unirradiated sensors).
Diffusion sigma: carrier-type-aware trapezoidal-field formula
- minority carriers (e⁻ in p-type bulk, h⁺ in n-type): σ² = (kT/q)·t²/V_dep · ln(V_sum / (V_sum − 2·V_dep·d/t))
- majority carriers (h⁺ in p-type, e⁻ in n-type): σ² = (kT/q)·t²/V_dep · ln((ΔV + 2·V_dep·d/t) / ΔV) where d is the drift distance, V_sum = V_bias+V_dep, ΔV = V_bias−V_dep. Falls back to uniform-field formula when V_bias ≤ V_dep.
Lorentz drift: charge cloud centroid shifted by d·tan(θ_L) in U; effective 1-D sigma broadened by 1/cos²(θ_L) = 1+tan²(θ_L).
Strip charge integration: Gaussian integrated over each sense strip via the error function.
Sense→readout transfer: sense strips (fine pitch) summed into readout strips (coarser pitch) according to the AC-coupling ratio.

Both electron and hole sides can be simulated independently; by default only the electron (n-strip) side is read out, as for a single-sided p-type sensor.

Coordinate convention

local[0] = U (precision direction, perpendicular to strips) local[1] = V (strip direction) local[2] = W (surface normal)

Electrons are collected at W = +thickness/2 (the n-strip side). Holes are collected at W = −thickness/2 (the p-bulk/backplane side).

Strip indexing: readout strip m is centred at U = (m − N/2) · readout_pitch, where N = n_readout_strips (default 512). Strip 0 is at the most-negative U edge; strip N−1 at the most-positive U edge. The sensor centre is between strips N/2−1 and N/2. Mapping: sense strip n → readout strip ⌊n / ratio⌋ + N/2 where ratio = round(readout_pitch / sense_pitch).

Definition at line 58 of file SiStripDigitizer.h.

Constructor & Destructor Documentation

◆ SiStripDigitizer()

tracking::digitization::SiStripDigitizer::SiStripDigitizer ( const SensorParams & params )

inlineexplicit

Definition at line 120 of file SiStripDigitizer.h.

120: params_(params) {}

Member Function Documentation

◆ adaptiveNSegments()

int tracking::digitization::SiStripDigitizer::adaptiveNSegments	(	const Acts::Vector3 &	local_dir,
		double	path_length ) const

private

Number of track sub-segments, chosen adaptively so that the U displacement per segment does not exceed deposition_granularity × sense_pitch.

Definition at line 26 of file SiStripDigitizer.cxx.

                                                                  {
  // Ensure U-displacement per segment <= granularity * sense_pitch.
  // For near-normal-incidence tracks (dir_u ≈ 0) the adaptive count can be
  // very small; clamp to n_segments_min.
  const double max_step = params_.deposition_granularity * params_.sense_pitch;
  const double total_u = std::abs(path_length * local_dir[0]);
  const int adaptive =
      (max_step > 0.0) ? static_cast<int>(std::ceil(total_u / max_step)) : 1;
  return std::max(params_.n_segments_min, adaptive);
}

References tracking::digitization::SiStripDigitizer::SensorParams::deposition_granularity, tracking::digitization::SiStripDigitizer::SensorParams::n_segments_min, and tracking::digitization::SiStripDigitizer::SensorParams::sense_pitch.

Referenced by computeStripCharges().

◆ applyNoiseAndThreshold()

void tracking::digitization::SiStripDigitizer::applyNoiseAndThreshold ( std::map< int, double > & strip_charges )

Add Gaussian electronic noise to signal strips and their immediate neighbours, then remove strips below the readout threshold.

Parameters

strip_charges Readout-strip charge map. Modified in place.

Definition at line 243 of file SiStripDigitizer.cxx.

                                        {
  // Add the immediate neighbours of every signal strip so that noise alone
  // can promote them above threshold (as in a real detector where every
  // strip has readout noise).
  std::set<int> extra;
  for (const auto& [strip, charge] : strip_charges) {
    extra.insert(strip - 1);
    extra.insert(strip + 1);
  }
  for (int s : extra) {
    strip_charges.emplace(s, 0.0);  // does not overwrite existing entries
  }
 
  // Add Gaussian noise to all strips.
  for (auto& [strip, charge] : strip_charges) {
    charge += params_.noise_electrons * normal_(generator_);
  }
 
  // Remove strips below the readout threshold.
  for (auto it = strip_charges.begin(); it != strip_charges.end();) {
    it = (it->second < params_.threshold_electrons) ? strip_charges.erase(it)
                                                    : std::next(it);
  }
}

References tracking::digitization::SiStripDigitizer::SensorParams::noise_electrons, and tracking::digitization::SiStripDigitizer::SensorParams::threshold_electrons.

◆ computeCarrierCharges()

std::map< int, double > tracking::digitization::SiStripDigitizer::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

private

Simulate one carrier type and return the sense-strip charge map.

Parameters

q_per_seg	Charge per sub-segment [electrons].
n_seg	Number of sub-segments.
local_pos	3D hit midpoint in local coordinates [mm].
local_dir	Unit track direction in local coordinates.
path_length	Path length through sensor [mm].
w_collect	W coordinate of collection electrode [mm].
lorentz_tan	tan(θ_Lorentz) for this carrier (may be 0).
is_minority	True if this carrier is the minority species.

Definition at line 90 of file SiStripDigitizer.cxx.

                                                {
  // 1/cos²(θ_L) = 1 + tan²(θ_L): Lorentz broadening of the diffusion sigma.
  const double inv_cos2 = 1.0 + lorentz_tan * lorentz_tan;
 
  std::map<int, double> sense_charges;
 
  for (int iseg = 0; iseg < n_seg; ++iseg) {
    // Fractional position along the track: f = 0 (entry) → 1 (exit).
    const double f = (iseg + 0.5) / n_seg;
 
    // 3D segment centre in sensor-local coordinates [mm].
    const Acts::Vector3 seg_pos =
        local_pos + (f - 0.5) * path_length * local_dir;
 
    const double u_seg = seg_pos[0];
    const double w_seg = seg_pos[2];
 
    // Drift distance to collection electrode, clamped to sensor thickness.
    const double drift =
        std::max(0.0, std::min(params_.thickness, std::abs(w_collect - w_seg)));
 
    // Charge trapping: linear model from CDFSiSensorSim.
    // trapping_ = fraction lost per 100 µm (= 0.1 mm) of drift.
    // collection_efficiency = 1 − 10·trapping·drift_mm
    double q_seg = q_per_seg;
    if (params_.trapping > 0.0) {
      const double efficiency =
          std::max(0.0, std::min(1.0, 1.0 - 10.0 * params_.trapping * drift));
      q_seg *= efficiency;
    }
 
    // Diffusion sigma [mm] with 1/cos²(θ_L) broadening from Lorentz angle.
    const double sigma_1d = diffusionSigma(drift, is_minority);
    const double sigma =
        std::max(sigma_1d * std::sqrt(inv_cos2), 1.0e-4);  // ≥ 0.1 µm
 
    // Lorentz shift: carriers arrive at U = u_seg + drift · tan(θ_L).
    const double u_dest = u_seg + drift * lorentz_tan;
 
    // Deposit charge on sense strips within 5 sigma of the charge centroid.
    const int strip_lo = static_cast<int>(
        std::floor((u_dest - 5.0 * sigma) / params_.sense_pitch));
    const int strip_hi = static_cast<int>(
        std::ceil((u_dest + 5.0 * sigma) / params_.sense_pitch));
 
    for (int istrip = strip_lo; istrip <= strip_hi; ++istrip) {
      const double strip_center = istrip * params_.sense_pitch;
      const double frac =
          stripFraction(u_dest, sigma, strip_center, params_.sense_pitch);
      if (frac > 1.0e-7) {
        sense_charges[istrip] += q_seg * frac;
      }
    }
  }
 
  return sense_charges;
}

References diffusionSigma(), tracking::digitization::SiStripDigitizer::SensorParams::sense_pitch, stripFraction(), tracking::digitization::SiStripDigitizer::SensorParams::thickness, and tracking::digitization::SiStripDigitizer::SensorParams::trapping.

Referenced by computeStripCharges().

◆ computeStripCharges()

std::map< int, double > tracking::digitization::SiStripDigitizer::computeStripCharges	(	double	edep,
		const Acts::Vector3 &	local_pos,
		const Acts::Vector3 &	local_dir,
		double	path_length ) const

Simulate charge collection for a single hit.

Runs both electron and hole sides as configured, performs the sense-to-readout charge transfer, and returns the final readout-strip charge map.

Parameters

edep	Energy deposited in the sensitive volume [MeV].
local_pos	3D hit midpoint in sensor-local coordinates [mm].
local_dir	Unit track direction in sensor-local coordinates.
path_length	Track path length through the sensor volume [mm].

Returns: Map of readout_strip_index → collected charge [electrons]. Indices are in [0, n_readout_strips); strip 0 is at the most-negative U edge of the sensor.

Definition at line 202 of file SiStripDigitizer.cxx.

                              {
  const double total_electrons = edep / ENERGY_PER_EHP_MEV;
  const int n_seg = adaptiveNSegments(local_dir, path_length);
  const double q_per_seg = total_electrons / n_seg;
 
  // Minority-carrier flags for the two bulk types.
  // p-type bulk (is_n_type = false): electrons = minority, holes = majority.
  // n-type bulk (is_n_type = true):  holes     = minority, electrons =
  // majority.
  const bool electron_is_minority = !params_.is_n_type;
  const bool hole_is_minority = params_.is_n_type;
 
  std::map<int, double> readout_charges;
 
  // Electron side: collection at W = +thickness/2 (n-strip side).
  if (params_.electron_side_readout) {
    const double w_electron = +0.5 * params_.thickness;
    auto sense = computeCarrierCharges(
        q_per_seg, n_seg, local_pos, local_dir, path_length, w_electron,
        params_.electron_lorentz_tangent, electron_is_minority);
    for (const auto& [strip, charge] : senseToReadout(sense)) {
      readout_charges[strip] += charge;
    }
  }
 
  // Hole side: collection at W = −thickness/2 (p-bulk / backplane side).
  if (params_.hole_side_readout) {
    const double w_hole = -0.5 * params_.thickness;
    auto sense = computeCarrierCharges(
        q_per_seg, n_seg, local_pos, local_dir, path_length, w_hole,
        params_.hole_lorentz_tangent, hole_is_minority);
    for (const auto& [strip, charge] : senseToReadout(sense)) {
      readout_charges[strip] += charge;
    }
  }
 
  return readout_charges;
}

References adaptiveNSegments(), computeCarrierCharges(), tracking::digitization::SiStripDigitizer::SensorParams::electron_lorentz_tangent, tracking::digitization::SiStripDigitizer::SensorParams::electron_side_readout, tracking::digitization::SiStripDigitizer::SensorParams::hole_lorentz_tangent, tracking::digitization::SiStripDigitizer::SensorParams::hole_side_readout, tracking::digitization::SiStripDigitizer::SensorParams::is_n_type, senseToReadout(), and tracking::digitization::SiStripDigitizer::SensorParams::thickness.

◆ diffusionSigma()

double tracking::digitization::SiStripDigitizer::diffusionSigma	(	double	d,
		bool	is_minority ) const

private

Diffusion sigma [mm] for carriers drifting distance d [mm].

Parameters

d	Drift distance [mm].
is_minority	True for minority carriers (e⁻ in p-type, h⁺ in n-type); false for majority carriers.

Definition at line 38 of file SiStripDigitizer.cxx.

                                                                        {
  const double kt_q = KT_Q_300K * params_.temperature / 300.0;
  const double t = params_.thickness;
  const double vb = params_.bias_voltage;
  const double vd = params_.depletion_voltage;
 
  double sigma_sq = 0.0;
 
  if (vb > vd && vd > 0.0) {
    const double cf = 2.0 * vd * d / t;
    const double base = kt_q * t * t / vd;
 
    if (is_minority) {
      // Minority carriers (e⁻ in p-type, h⁺ in n-type):
      //   σ² = (kT/q)·t²/Vd · ln( V_sum / (V_sum − cf) )
      // These carriers drift quickly through the high-field region →
      // smaller diffusion sigma.
      const double v_sum = vb + vd;
      const double denom = v_sum - cf;
      if (denom > 0.0) {
        sigma_sq = base * std::log(v_sum / denom);
      }
    } else {
      // Majority carriers (h⁺ in p-type, e⁻ in n-type):
      //   σ² = (kT/q)·t²/Vd · ln( (ΔV + cf) / ΔV )
      // These carriers drift through the low-field region →
      // larger diffusion sigma.
      const double delta_v = vb - vd;
      if (delta_v > 0.0) {
        sigma_sq = base * std::log(1.0 + cf / delta_v);
      }
    }
  } else if (vb > 0.0) {
    // Uniform-field fallback (V_bias ≤ V_dep or V_dep = 0):
    //   σ² = 2·(kT/q)·d·t / V_bias
    sigma_sq = 2.0 * kt_q * d * t / vb;
  }
 
  return std::sqrt(std::max(sigma_sq, 0.0));
}

References tracking::digitization::SiStripDigitizer::SensorParams::bias_voltage, tracking::digitization::SiStripDigitizer::SensorParams::depletion_voltage, tracking::digitization::SiStripDigitizer::SensorParams::temperature, and tracking::digitization::SiStripDigitizer::SensorParams::thickness.

Referenced by computeCarrierCharges().

◆ mutableParams()

SensorParams & tracking::digitization::SiStripDigitizer::mutableParams ( )

inline

Definition at line 156 of file SiStripDigitizer.h.

156{ return params_; }

◆ params()

const SensorParams & tracking::digitization::SiStripDigitizer::params ( ) const

inline

Definition at line 155 of file SiStripDigitizer.h.

155{ return params_; }

◆ seed()

void tracking::digitization::SiStripDigitizer::seed ( uint64_t s )

inline

Seed the internal random-number engine.

Call from onNewRun once a seed is available from the framework seed service.

Definition at line 124 of file SiStripDigitizer.h.

124{ generator_.seed(s); }

◆ senseToReadout()

std::map< int, double > tracking::digitization::SiStripDigitizer::senseToReadout ( const std::map< int, double > & sense_charges ) const

private

Sum sense-strip charges into readout-strip charges according to the AC-coupling ratio ratio = round(readout_pitch / sense_pitch).

Sense strip n maps to readout strip floor(n / ratio).

Definition at line 151 of file SiStripDigitizer.cxx.

                                                    {
  const int ratio =
      std::max(1, static_cast<int>(
                      std::round(params_.readout_pitch / params_.sense_pitch)));
 
  const int offset = params_.n_readout_strips / 2;
  std::map<int, double> readout_charges;
 
  if (ratio == 1) {
    // No interleaving: paired strip only, apply readout transfer efficiency.
    for (const auto& [sense_strip, charge] : sense_charges) {
      readout_charges[sense_strip + offset] +=
          charge * params_.readout_transfer_efficiency;
    }
    return readout_charges;
  }
 
  // AC-coupled sense→readout transfer following HPS CDFSiSensorSim.
  //
  // For each sense strip n, compute its position within its readout group:
  //   k                = floor(n / ratio)   — group index
  //   position_in_group = n − ratio × k     — 0 … ratio−1
  //
  // position_in_group == 0: "paired" strip, physically under readout strip r.
  //   → transfers readout_transfer_efficiency × charge to readout r.
  //
  // position_in_group > 0: "unpaired" strip, between readout strips r and r+1.
  //   → transfers sense_transfer_efficiency × charge to EACH of r and r+1.
  //   (total ≈ 2 × 0.419 = 0.838; ~16% lost to capacitive cross-talk)
 
  for (const auto& [sense_strip, charge] : sense_charges) {
    const int k =
        static_cast<int>(std::floor(static_cast<double>(sense_strip) / ratio));
    const int position_in_group = sense_strip - ratio * k;
    const int r = k + offset;
 
    if (position_in_group == 0) {
      readout_charges[r] += charge * params_.readout_transfer_efficiency;
    } else {
      readout_charges[r] += charge * params_.sense_transfer_efficiency;
      readout_charges[r + 1] += charge * params_.sense_transfer_efficiency;
    }
  }
  return readout_charges;
}

References tracking::digitization::SiStripDigitizer::SensorParams::n_readout_strips, tracking::digitization::SiStripDigitizer::SensorParams::readout_pitch, tracking::digitization::SiStripDigitizer::SensorParams::readout_transfer_efficiency, tracking::digitization::SiStripDigitizer::SensorParams::sense_pitch, and tracking::digitization::SiStripDigitizer::SensorParams::sense_transfer_efficiency.

Referenced by computeStripCharges().

◆ setThickness()

void tracking::digitization::SiStripDigitizer::setThickness ( double thickness )

inline

Set the sensor thickness [mm] from the geometry before processing hits.

Definition at line 159 of file SiStripDigitizer.h.

159{ params_.thickness = thickness; }

References tracking::digitization::SiStripDigitizer::SensorParams::thickness.

◆ stripFraction()

double tracking::digitization::SiStripDigitizer::stripFraction	(	double	u0,
		double	sigma,
		double	strip_center,
		double	pitch ) const

private

Fraction of a Gaussian charge cloud (centred at u0 with sigma sigma) collected by a strip of width pitch centred at strip_center.

Definition at line 79 of file SiStripDigitizer.cxx.

                                                           {
  // Integral of N(u0, sigma) over [strip_center − pitch/2, strip_center +
  // pitch/2]
  const double inv_sqrt2_sigma = 1.0 / (std::sqrt(2.0) * sigma);
  const double lo = (strip_center - 0.5 * pitch - u0) * inv_sqrt2_sigma;
  const double hi = (strip_center + 0.5 * pitch - u0) * inv_sqrt2_sigma;
  return 0.5 * (std::erf(hi) - std::erf(lo));
}

Referenced by computeCarrierCharges().

Member Data Documentation

◆ generator_

std::default_random_engine tracking::digitization::SiStripDigitizer::generator_

private

Definition at line 213 of file SiStripDigitizer.h.

◆ normal_

std::normal_distribution<double> tracking::digitization::SiStripDigitizer::normal_ {0.0, 1.0}

private

Definition at line 214 of file SiStripDigitizer.h.

214{0.0, 1.0};

◆ params_

SensorParams tracking::digitization::SiStripDigitizer::params_

private

Definition at line 212 of file SiStripDigitizer.h.

The documentation for this class was generated from the following files:

Tracking/include/Tracking/Digitization/SiStripDigitizer.h
Tracking/src/Tracking/Digitization/SiStripDigitizer.cxx

Classes

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Coordinate convention

Constructor & Destructor Documentation

◆ SiStripDigitizer()

Member Function Documentation

◆ adaptiveNSegments()

◆ applyNoiseAndThreshold()

◆ computeCarrierCharges()

◆ computeStripCharges()

◆ diffusionSigma()

◆ mutableParams()

◆ params()

◆ seed()

◆ senseToReadout()

◆ setThickness()

◆ stripFraction()

Member Data Documentation

◆ generator_

◆ normal_

◆ params_