Use integrator/differentiator with vanishing group delay

I discovered issues with the current implementation of the integrator that's used to calculate the local_timer_deviations. It is done by computing the cumulative sum (numpy.cumsum). The equivalent IIR filter reads

$y[n] = y[n-1] + x[n] \Delta t$

. The problem with is the group delay of negative half a sample. This is not a problem if the differentiation is performed by the standard operation

$y[n] = \frac{x[n] - x[n-1]}{\Delta t}$

since it will compensate perfectly the group delay to zero again. The problem becomes noticeable if the sampling rate is changed between integration and differentiation since a half sample delay will be different in terms of absolute time before and after decimation.

I would suggest to use integration and differentiation operations that have zero group delay:

• integration:
  $y[n] = y[n-1] + \frac{x[n-1] + x[n]}{2}\Delta t$
• differentiation:
  $y[n] = \frac{x[n+1] - x[n-1]}{2\Delta t}$

added bug label

changed title from Use {-more accurate integrator to calculate local_timer_deviations-} to Use integrator/differentiator with zero group delay

changed the description

changed title from Use integrator/differentiator with zero group delay to Use integrator/differentiator with vanishing group delay

That's a good point. I guess the same problem also arises in LISANode, where we also use a simple integrator to compute the timer deviations?

Does this small time shift impact your TDI results in a meaningful way?

For me the problems didn't arise in TDI but in some Kalman filter experiments. I only saw it when looking very closely (fs level)...

Basically, at the moment the timer deviations are inconsistent with the clock frequency drift/jitter variables. Which can be easily fixed by the solution pointed out above. It might not have a huge impact on many algorithms but it definitely maters in some...

This is an issue that can be easily fixed in LISA Instrument, so let's try to have it for v1.0.1.

I suggest using cumulative trapezoidal integration (available in scipy.integrate), which should have a vanishing group delay. If I understand correctly, it works how @mastaa proposed.

The source code is this:

    nd = len(y.shape)
    slice1 = tupleset((slice(None),)*nd, axis, slice(1, None))
    slice2 = tupleset((slice(None),)*nd, axis, slice(None, -1))
    res = np.cumsum(d * (y[slice1] + y[slice2]) / 2.0, axis=axis)

@mastaa, can you take a look and try this?

changed milestone to %v1.0.1

created merge request !78 (merged) to address this issue

mentioned in merge request !78 (merged)

closed with merge request !78 (merged)

mentioned in commit 487a22cd