def test_t():
# Use the default "model" tree (Don't load signal from MDSplus)
shot = -1
# Create `Signal` object
sig = Signal(shot, 1)
# Now, overwrite properties of `sig` to easily test `_getSlice()` method
sig.Fs = 1.
sig._downsample = 1
sig.t0 = 0
sig.x = np.arange(10)
# (1) `sig.t()` is equal to `sig.x` for the above parameters
np.testing.assert_equal(sig.t(), sig.x)
# (2) Linear shift
sig.t0 += 1
np.testing.assert_equal(sig.t(), sig.x + 1)
# (3) Double the sampling rate at which signal is retrieved
sig.Fs *= 2
np.testing.assert_equal(sig.t(), (sig.x / sig.Fs) + 1)
# (4) The time base computed by the `sig.t()` method corresponds
# to the retrieved points in `sig.x`, which may be downsampled
# from the full digitized record. The downsampling is folded
# into the sampling rate `sig.Fs` at which the signal is retrieved,
# however, so altering `sig._downsample` should *not* affect `sig.t()`;
# that is, `sig.t()` should remain unchanged from (3)
sig._downsample = 2
np.testing.assert_equal(sig.t(), (sig.x / sig.Fs) + 1)
return
def test__getSlice():
# Use the default "model" tree
shot = -1
# Test signal and limiting slicing values
x = np.arange(10)
imin = 0
imax = len(x)
# Create `Signal` object
sig = Signal(shot, 1)
# ValueError tests
tools.assert_raises(ValueError, sig._getSlice, *[x], **{'tlim': [1]})
tools.assert_raises(ValueError, sig._getSlice, *[x], **{'tlim': [1, 2, 3]})
# -------------------------------------------------------------------------
# (1) No downsampling, trivial `t0_dig`
# -------------------------------------------------------------------------
# Now, overwrite properties of `sig` to easily test `_getSlice()` method
sig.Fs = 1.
sig._downsample = 1
# (1a) No actual slicing
tools.assert_equal(
sig._getSlice(x, tlim=None, t0_dig=0.),
slice(imin, imax, 1))
# (1b) Slicing from both ends, no downsampling
tlim = [1, 8]
tools.assert_equal(
sig._getSlice(x, tlim=tlim, t0_dig=0.),
slice(tlim[0], tlim[1] + 1, 1))
# (1c) Slicing from lower end only, no downsampling
tlim = [1, 10 + np.finfo(float).eps]
tools.assert_equal(
sig._getSlice(x, tlim=tlim, t0_dig=0.),
slice(tlim[0], imax, 1))
# (1d) Slicing from upper end only, no downsampling
tlim = [-1 - np.finfo(float).eps, 8]
tools.assert_equal(
sig._getSlice(x, tlim=tlim, t0_dig=0.),
slice(imin, tlim[1] + 1, 1))
# -------------------------------------------------------------------------
# (2) Downsampling, trivial `t0_dig`
# -------------------------------------------------------------------------
# Vary `sig.Fs` and `sig._downsample` inversely such that
# the `tlim` values can stay the same as above.
sig._downsample = 2 # Note: must be an *integer*
sig.Fs /= sig._downsample
# (2a) Downsampling only
tools.assert_equal(
sig._getSlice(x, tlim=None, t0_dig=0.),
slice(imin, imax, sig._downsample))
# (2b) Slicing from both ends, no downsampling
tlim = [1, 8]
tools.assert_equal(
sig._getSlice(x, tlim=tlim, t0_dig=0.),
slice(tlim[0], tlim[1] + 1, sig._downsample))
# (2c) Slicing from lower end only, no downsampling
tlim = [1, 10 + np.finfo(float).eps]
tools.assert_equal(
sig._getSlice(x, tlim=tlim, t0_dig=0.),
slice(tlim[0], imax, sig._downsample))
# (2d) Slicing from upper end only, no downsampling
tlim = [-1 - np.finfo(float).eps, 8]
tools.assert_equal(
sig._getSlice(x, tlim=tlim, t0_dig=0.),
slice(imin, tlim[1] + 1, sig._downsample))
# -------------------------------------------------------------------------
# (3) Downsampling, non-trivial `t0_dig`
# -------------------------------------------------------------------------
# Lower slicing indices *within* the bounds of the array should be
# decremented by `np.floor(t0_dig)` relative to (2), and
# upper slicing indices *within* the bounds of the array should be
# decremented by `np.ceil(t0_dig)` (Note that this is equivalent to
# (`1 + np.floor(t0_dig)`) relative to (2).
t0_dig = 1.5
# (3a) Downsampling only; `t0_dig` does not come into play
# when `tlim` is None
tools.assert_equal(
sig._getSlice(x, tlim=None, t0_dig=t0_dig),
slice(imin, imax, sig._downsample))
# (3b) Slicing from both ends, no downsampling
tlim = [2, 8]
tools.assert_equal(
sig._getSlice(x, tlim=tlim, t0_dig=t0_dig),
slice(tlim[0] - np.floor(t0_dig),
tlim[1] - np.floor(t0_dig),
sig._downsample))
# (3c) Slicing from lower end only, no downsampling
tlim = [2, 10 + np.finfo(float).eps + t0_dig]
tools.assert_equal(
sig._getSlice(x, tlim=tlim, t0_dig=t0_dig),
slice(tlim[0] - np.floor(t0_dig), imax, sig._downsample))
# (3d) Slicing from upper end only, no downsampling
tlim = [-1 - np.finfo(float).eps + t0_dig, 8]
tools.assert_equal(
sig._getSlice(x, tlim=tlim, t0_dig=t0_dig),
slice(imin, tlim[1] - np.floor(t0_dig), sig._downsample))
return