ldmx::PulseFitter Class Reference

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

#include <PulseFitter.h>

Classes
struct	FitResult

Public Member Functions
	PulseFitter (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.
FitResult	fitFixed (const std::vector< short > &samples, double T) const
	Amplitude only fit with the hit time T known, e.g.

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 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 PulseFitter.h.

Constructor & Destructor Documentation

PulseFitter()

ldmx::PulseFitter::PulseFitter	(	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 PulseFitter.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 > ldmx::PulseFitter::evalAtT ( const std::vector< short > & samples, double T ) const

private

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

Definition at line 25 of file PulseFitter.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 ldmx::PulseShape::eval(), and inv_sigma2_.

Referenced by fit(), and fitFixed().

fit()

PulseFitter::FitResult ldmx::PulseFitter::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 66 of file PulseFitter.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;
      // T_hi is the next point, forget one found for an earlier minimum
      chi2_hi = std::numeric_limits<double>::max();
      t_hi = t;
    } else if (t_prev == best_t) {
      // 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 = chi2_lo - best_chi2;
    const double dc2 = chi2_hi - best_chi2;
    // Vertex of parabola: ΔT = (d2²·dc1 - d1²·dc2) / (2·(d1·dc2 + d2·dc1))
    const double denom = 2.0 * (d1 * dc2 + d2 * dc1);
    if (std::abs(denom) > 1.0e-12) {
      const double delta = (d2 * d2 * dc1 - d1 * d1 * dc2) / 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 ldmx::PulseFitter::FitResult::amplitude, ldmx::PulseFitter::FitResult::chi2, ldmx::PulseFitter::FitResult::converged, evalAtT(), ldmx::PulseFitter::FitResult::ndf, and ldmx::PulseFitter::FitResult::t0.

Referenced by ecal::EcalRecProducer::produce(), and tracking::reco::SiStripWaveformFitProcessor::produce().

fitFixed()

PulseFitter::FitResult ldmx::PulseFitter::fitFixed	(	const std::vector< short > &	samples,
		double	T ) const

Amplitude only fit with the hit time T known, e.g.

from another detector.

Parameters

samples	ADC values (one per sample).
T	Hit time in the same frame as t0_offset [ns].

Definition at line 159 of file PulseFitter.cxx.

                                                             {
  FitResult result;
  result.ndf = static_cast<int>(samples.size()) - 1;
  auto [chi2, amp] = evalAtT(samples, T);
  result.amplitude = amp;
  result.t0 = T;
  result.chi2 = chi2;
  result.converged = chi2 < std::numeric_limits<double>::max();
  return result;
}

References ldmx::PulseFitter::FitResult::amplitude, ldmx::PulseFitter::FitResult::chi2, ldmx::PulseFitter::FitResult::converged, evalAtT(), ldmx::PulseFitter::FitResult::ndf, and ldmx::PulseFitter::FitResult::t0.

Referenced by ecal::EcalRecProducer::produce().

Member Data Documentation

inv_sigma2_

double ldmx::PulseFitter::inv_sigma2_

private

1/σ², pre-computed.

Definition at line 95 of file PulseFitter.h.

Referenced by evalAtT().

pedestal_adc_

double ldmx::PulseFitter::pedestal_adc_

private

Definition at line 94 of file PulseFitter.h.

sampling_interval_ns_

double ldmx::PulseFitter::sampling_interval_ns_

private

Definition at line 93 of file PulseFitter.h.

shape_

const PulseShape* ldmx::PulseFitter::shape_

private

Definition at line 91 of file PulseFitter.h.

t0_offset_ns_

double ldmx::PulseFitter::t0_offset_ns_

private

Definition at line 92 of file PulseFitter.h.

t_scan_max_ns_

double ldmx::PulseFitter::t_scan_max_ns_

private

Definition at line 97 of file PulseFitter.h.

t_scan_min_ns_

double ldmx::PulseFitter::t_scan_min_ns_

private

Definition at line 96 of file PulseFitter.h.

t_scan_step_ns_

double ldmx::PulseFitter::t_scan_step_ns_

private

Definition at line 98 of file PulseFitter.h.

---

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

• Tools/include/Tools/PulseFitter.h
• Tools/src/Tools/PulseFitter.cxx