tracking::digitization::StripPulseFitter Class Reference

Fits a pulse shape to the ADC samples of a single silicon-strip readout channel to extract hit amplitude and time. More...

#include <StripPulseFitter.h>

Classes
struct	FitResult

Public Member Functions
	StripPulseFitter (const PulseShape &shape, double t0_offset_ns, double sampling_interval_ns, double pedestal_adc, double noise_sigma_adc, double t_scan_min_ns=-50.0, double t_scan_max_ns=150.0, double t_scan_step_ns=1.0)
FitResult	fit (const std::vector< short > &samples) const
	Fit the pulse to the given ADC sample vector.

Private Member Functions
std::pair< double, double >	evalAtT (const std::vector< short > &samples, double T) const
	Evaluate χ²(T) and the corresponding best-fit amplitude.

Private Attributes
const PulseShape *	shape_
double	t0_offset_ns_
double	sampling_interval_ns_
double	pedestal_adc_
double	inv_sigma2_
	1/σ², pre-computed.
double	t_scan_min_ns_
double	t_scan_max_ns_
double	t_scan_step_ns_

Detailed Description

Fits a pulse shape to the ADC samples of a single silicon-strip readout channel to extract hit amplitude and time.

Algorithm

With N ADC samples and 2 free parameters (amplitude A and hit time T), the chi-squared is:

χ²(T) = Σ_i [(S_i − ped − A(T)·f(t_i − T)) / σ]²

where t_i = t0_offset + i·Δt are the sample times and f is the pulse shape. For each candidate T, A is solved analytically:

A(T) = Σ_i (S_i − ped)·f(t_i − T) / Σ_i f(t_i − T)²

A 1-D scan over T followed by a parabolic refinement near the minimum gives the fitted values. This is O(n_scan × N_samples) per strip and runs in < 1 µs.

The fit result t0 is defined as T − t0_offset, i.e. the hit arrival time relative to sample 0. A value of t0 = tp (peaking time) means the pulse peak coincides with sample 0.

Timing convention

Sample i is taken at time t_i = t0_offset_ns + i · sampling_interval_ns The pulse shape is evaluated at f(t_i − T) where T is the absolute hit arrival time in the same frame. The output t0 = T is stored directly so the caller can subtract their own reference as needed.

Definition at line 40 of file StripPulseFitter.h.

Constructor & Destructor Documentation

StripPulseFitter()

tracking::digitization::StripPulseFitter::StripPulseFitter	(	const PulseShape &	shape,
		double	t0_offset_ns,
		double	sampling_interval_ns,
		double	pedestal_adc,
		double	noise_sigma_adc,
		double	t_scan_min_ns = -50.0,
		double	t_scan_max_ns = 150.0,
		double	t_scan_step_ns = 1.0 )

Parameters

shape	Pulse shape function (owned externally).
t0_offset_ns	Time of sample 0 in the hit-time frame [ns].
sampling_interval_ns	Interval between samples [ns].
pedestal_adc	Per-sample pedestal [ADC counts].
noise_sigma_adc	Per-sample noise RMS [ADC counts], used for χ².
t_scan_min_ns	Lower bound of the T scan range [ns].
t_scan_max_ns	Upper bound of the T scan range [ns].
t_scan_step_ns	Step size of the coarse T scan [ns].

Definition at line 8 of file StripPulseFitter.cxx.

    : shape_(&shape),
      t0_offset_ns_(t0_offset_ns),
      sampling_interval_ns_(sampling_interval_ns),
      pedestal_adc_(pedestal_adc),
      inv_sigma2_(1.0 / (noise_sigma_adc * noise_sigma_adc)),
      t_scan_min_ns_(t_scan_min_ns),
      t_scan_max_ns_(t_scan_max_ns),
      t_scan_step_ns_(t_scan_step_ns) {}

Member Function Documentation

evalAtT()

std::pair< double, double > tracking::digitization::StripPulseFitter::evalAtT ( const std::vector< short > & samples, double T ) const

private

Evaluate χ²(T) and the corresponding best-fit amplitude.

Definition at line 26 of file StripPulseFitter.cxx.

                                                     {
  const int n = static_cast<int>(samples.size());
 
  // Evaluate pulse shape at each sample time.
  // t_i = t0_offset + i * dt  →  argument to shape = t_i - T
  double sum_sf = 0.0;  // Σ (S_i - ped) * f_i
  double sum_f2 = 0.0;  // Σ f_i²
 
  for (int i = 0; i < n; ++i) {
    const double t_arg = t0_offset_ns_ + i * sampling_interval_ns_ - T;
    const double fi = shape_->eval(t_arg);
    const double si = static_cast<double>(samples[i]) - pedestal_adc_;
    sum_sf += si * fi;
    sum_f2 += fi * fi;
  }
 
  // Degenerate: pulse shape is zero everywhere in the window.
  if (sum_f2 < 1.0e-12) {
    return {std::numeric_limits<double>::max(), 0.0};
  }
 
  const double amplitude = sum_sf / sum_f2;
 
  // Compute chi2 for this (T, amplitude) pair.
  double chi2 = 0.0;
  for (int i = 0; i < n; ++i) {
    const double t_arg = t0_offset_ns_ + i * sampling_interval_ns_ - T;
    const double fi = shape_->eval(t_arg);
    const double si = static_cast<double>(samples[i]) - pedestal_adc_;
    const double resid = si - amplitude * fi;
    chi2 += resid * resid * inv_sigma2_;
  }
 
  return {chi2, amplitude};
}

References tracking::digitization::PulseShape::eval(), and inv_sigma2_.

Referenced by fit().

fit()

StripPulseFitter::FitResult tracking::digitization::StripPulseFitter::fit

(

const std::vector< short > &

samples

)

const

Fit the pulse to the given ADC sample vector.

Parameters

samples

ADC values (one per sample, any integer type cast to short).

Definition at line 67 of file StripPulseFitter.cxx.

                                           {
  FitResult result;
  result.ndf = static_cast<int>(samples.size()) - 2;
 
  // Quick sanity: check that at least one sample is above pedestal.
  bool any_signal = false;
  for (auto s : samples) {
    if (static_cast<double>(s) > pedestal_adc_) {
      any_signal = true;
      break;
    }
  }
  if (!any_signal) {
    return result;  // converged = false
  }
 
  // -------------------------------------------------------------------
  // Coarse scan over T to find the approximate minimum.
  // -------------------------------------------------------------------
  double best_chi2 = std::numeric_limits<double>::max();
  double best_T = t_scan_min_ns_;
  double best_amp = 0.0;
 
  // Keep track of the three-point neighbourhood for parabolic refinement.
  double T_lo = t_scan_min_ns_, chi2_lo = std::numeric_limits<double>::max();
  double T_hi = t_scan_min_ns_, chi2_hi = std::numeric_limits<double>::max();
 
  double T_prev = t_scan_min_ns_;
  double chi2_prev = std::numeric_limits<double>::max();
 
  for (double T = t_scan_min_ns_; T <= t_scan_max_ns_; T += t_scan_step_ns_) {
    auto [chi2, amp] = evalAtT(samples, T);
 
    if (chi2 < best_chi2) {
      // Update neighbourhood: the previous point becomes T_lo.
      T_lo = T_prev;
      chi2_lo = chi2_prev;
      best_chi2 = chi2;
      best_T = T;
      best_amp = amp;
    } else if (T > best_T && chi2_hi > best_chi2) {
      // First point to the right of the minimum.
      T_hi = T;
      chi2_hi = chi2;
    }
 
    T_prev = T;
    chi2_prev = chi2;
  }
 
  // -------------------------------------------------------------------
  // Parabolic refinement around the minimum if neighbours are available.
  // -------------------------------------------------------------------
  if (T_lo < best_T && T_hi > best_T && chi2_lo > best_chi2 &&
      chi2_hi > best_chi2) {
    // Fit a parabola through (T_lo, chi2_lo), (best_T, best_chi2), (T_hi,
    // chi2_hi).
    const double d1 = best_T - T_lo;
    const double d2 = T_hi - best_T;
    const double dc1 = best_chi2 - chi2_lo;
    const double dc2 = chi2_hi - best_chi2;
    // Vertex of parabola: ΔT = (d1²·dc2 - d2²·dc1) / (2·(d1·dc2 + d2·dc1))
    const double denom = 2.0 * (d1 * dc2 + d2 * dc1);
    if (std::abs(denom) > 1.0e-12) {
      const double delta = (d1 * d1 * dc2 - d2 * d2 * dc1) / denom;
      // Only accept the refinement if it stays within the bracket.
      if (std::abs(delta) < std::max(d1, d2)) {
        const double T_refined = best_T + delta;
        auto [chi2_ref, amp_ref] = evalAtT(samples, T_refined);
        if (chi2_ref < best_chi2) {
          best_T = T_refined;
          best_amp = amp_ref;
          best_chi2 = chi2_ref;
        }
      }
    }
  }
 
  result.amplitude = best_amp;
  result.t0 = best_T;
  result.chi2 = best_chi2;
  result.converged = true;
  return result;
}

References tracking::digitization::StripPulseFitter::FitResult::amplitude, tracking::digitization::StripPulseFitter::FitResult::chi2, tracking::digitization::StripPulseFitter::FitResult::converged, evalAtT(), tracking::digitization::StripPulseFitter::FitResult::ndf, and tracking::digitization::StripPulseFitter::FitResult::t0.

Member Data Documentation

inv_sigma2_

double tracking::digitization::StripPulseFitter::inv_sigma2_

private

1/σ², pre-computed.

Definition at line 83 of file StripPulseFitter.h.

Referenced by evalAtT().

pedestal_adc_

double tracking::digitization::StripPulseFitter::pedestal_adc_

private

Definition at line 82 of file StripPulseFitter.h.

sampling_interval_ns_

double tracking::digitization::StripPulseFitter::sampling_interval_ns_

private

Definition at line 81 of file StripPulseFitter.h.

shape_

const PulseShape* tracking::digitization::StripPulseFitter::shape_

private

Definition at line 79 of file StripPulseFitter.h.

t0_offset_ns_

double tracking::digitization::StripPulseFitter::t0_offset_ns_

private

Definition at line 80 of file StripPulseFitter.h.

t_scan_max_ns_

double tracking::digitization::StripPulseFitter::t_scan_max_ns_

private

Definition at line 85 of file StripPulseFitter.h.

t_scan_min_ns_

double tracking::digitization::StripPulseFitter::t_scan_min_ns_

private

Definition at line 84 of file StripPulseFitter.h.

t_scan_step_ns_

double tracking::digitization::StripPulseFitter::t_scan_step_ns_

private

Definition at line 86 of file StripPulseFitter.h.

---

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

• Tracking/include/Tracking/Digitization/StripPulseFitter.h
• Tracking/src/Tracking/Digitization/StripPulseFitter.cxx