SignalInterpolation2 Struct Reference

Interpolation of signal shape using function values and the first derivative. More...

#include <ECLWaveformFit.h>

Public Member Functions
	SignalInterpolation2 ()
	Default constructor.
	SignalInterpolation2 (const std::vector< double > &)
	Constructor with parameters with the parameter layout as in ECLDigitWaveformParameters.
void	getShape (double t0, double *function, double *derivatives) const
	Returns signal shape and derivatives in 31 equidistant time points starting from t0. More...

Public Attributes
double	m_FunctionInterpolation [c_nt *c_ndt+c_ntail]
	Function values.
double	m_DerivativeInterpolation [c_nt *c_ndt+c_ntail]
	Derivative values.
double	m_r0
	Assuming exponential drop of the signal function far away from 0, extrapolate it to +inf. More...
double	m_r1
	See above/.

Static Public Attributes
constexpr static int	c_nt = 12
	Signal function is sampled in c_nt time steps with c_ndt substeps and c_ntail steps. More...
constexpr static int	c_ndt = 5
	Number of substeps.
constexpr static int	c_ntail = 20
	Number of tail steps.
constexpr static double	c_dt = 0.5
	Time step.
constexpr static double	c_idt = 1 / c_dt
	Inverted time step.
constexpr static double	c_dtn = c_dt / c_ndt
	Time substep.
constexpr static double	c_idtn = c_ndt / c_dt
	Inverted time substep.

Detailed Description

Interpolation of signal shape using function values and the first derivative.

Definition at line 57 of file ECLWaveformFit.h.

Member Function Documentation

getShape()

void getShape	(	double	t0,
		double *	function,
		double *	derivatives
	)		const

Returns signal shape and derivatives in 31 equidistant time points starting from t0.

Parameters

[in]	t0	Time.
[out]	function	Function values.
[out]	derivatives	Derivatives.

Definition at line 579 of file ECLWaveformFit.cc.

{
  /* If before pulse start time (negative times), return 0. */
  int k = 0;
  while (t0 < 0) {
    function[k] = 0;
    derivatives[k] = 0;
    t0 += c_dt;
    ++k;
    if (k >= c_NFitPoints)
      return;
  }
 
  /* Function and derivative values. */
  double function0[c_NFitPoints], function1[c_NFitPoints];
  double derivative0[c_NFitPoints], derivative1[c_NFitPoints];
 
  /* Interpolate first c_nt points (short time steps). */
  double x = t0 * c_idtn;
  double ix = floor(x);
  double w = x - ix;
  int j = ix;
  double w2 = w * w;
  double hw2 = 0.5 * w2;
  double tw3 = ((1. / 6) * w) * w2;
 
  /* Number of interpolation points. */
  int iMax = k + c_nt;
  if (iMax > c_NFitPoints)
    iMax = c_NFitPoints;
 
  /* Fill interpolation points. */
  for (int i = k; i < iMax; ++i) {
    function0[i] = m_FunctionInterpolation[j];
    function1[i] = m_FunctionInterpolation[j + 1];
    derivative0[i] = m_DerivativeInterpolation[j];
    derivative1[i] = m_DerivativeInterpolation[j + 1];
    j = j + c_ndt;
  }
 
  /* Interpolation. */
  #pragma omp simd
  for (int i = k; i < iMax; ++i) {
    double a[4];
    double dfdt = (function1[i] - function0[i]) * c_idtn;
    double fp = derivative1[i] + derivative0[i];
    a[0] = function0[i];
    a[1] = derivative0[i];
    a[2] = -((fp + derivative0[i]) - 3 * dfdt);
    a[3] = fp - 2 * dfdt;
    double b2 = 2 * a[2];
    double b3 = 6 * a[3];
    function[i] = a[0] + c_dtn * (a[1] * w + b2 * hw2 + b3 * tw3);
    derivatives[i] = a[1] + b2 * w + b3 * hw2;
  }
  t0 = t0 + c_dt * c_nt;
  if (iMax == c_NFitPoints)
    return;
  k = iMax;
 
  /* Interpolate next c_ntail points (long time steps). */
  x = t0 * c_idt;
  ix = floor(x);
  w = x - ix;
  w2 = w * w;
  hw2 = 0.5 * w2;
  tw3 = ((1. / 6) * w) * w2;
 
  /* Number of interpolation points. */
  iMax = k + c_ntail - 1;
  if (iMax > c_NFitPoints)
    iMax = c_NFitPoints;
 
  /* Interpolation. */
  #pragma omp simd
  for (int i = k; i < iMax; ++i) {
    j = c_nt * c_ndt + i - k;
    /*
     * The interpolation step is the same as the distance between
     * the fit points. It is possible to load the values in the interpolation
     * loop while keeping its vectorization.
     */
    double f0 = m_FunctionInterpolation[j];
    double f1 = m_FunctionInterpolation[j + 1];
    double fp0 = m_DerivativeInterpolation[j];
    double fp1 = m_DerivativeInterpolation[j + 1];
    double a[4];
    double dfdt = (f1 - f0) * c_idt;
    double fp = fp1 + fp0;
    a[0] = f0;
    a[1] = fp0;
    a[2] = -((fp + fp0) - 3 * dfdt);
    a[3] = fp - 2 * dfdt;
    double b2 = 2 * a[2];
    double b3 = 6 * a[3];
    function[i] = a[0] + c_dt * (a[1] * w + b2 * hw2 + b3 * tw3);
    derivatives[i] = a[1] + b2 * w + b3 * hw2;
  }
  if (iMax == c_NFitPoints)
    return;
  k = iMax;
 
  /* Exponential tail. */
  while (k < c_NFitPoints) {
    function[k] = function[k - 1] * m_r0;
    derivatives[k] = derivatives[k - 1] * m_r1;
    ++k;
  }
}

Member Data Documentation

c_nt

constexpr static int c_nt = 12

staticconstexpr

Signal function is sampled in c_nt time steps with c_ndt substeps and c_ntail steps.

c_dt is the time step.

Definition at line 63 of file ECLWaveformFit.h.

m_r0

double m_r0

Assuming exponential drop of the signal function far away from 0, extrapolate it to +inf.

f(i_last + i) = f(i_last)*m_r0^i f'(i_last + i) = f'(i_last)*m_r1^i where i_last is the last point within sampled values in m_FunctionInterpolation (m_DerivativeInterpolation).

Definition at line 97 of file ECLWaveformFit.h.

---

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

• ecl/modules/eclWaveformFit/include/ECLWaveformFit.h
• ecl/modules/eclWaveformFit/src/ECLWaveformFit.cc