def test_times_wrong(self):
with pytest.raises(ValueError):
Integrate(self.sh, start=self.start_time - 1. * u.s)
with pytest.raises(ValueError):
Integrate(self.sh, start=self.start_time + 3. * u.s)
with pytest.raises(AssertionError):
Integrate(self.sh, step=1. * u.hr)
def test_integrate_n_part(self, n, samples_per_frame):
# Also test same as above by passing on start.
ref_data = self.raw_power[121 * n:131 * n].reshape(-1, n, 2).sum(1)
st = Square(self.sh)
ip = Integrate(st,
n / self.sh.sample_rate,
start=121 * n,
average=False,
samples_per_frame=samples_per_frame)
assert abs(ip.start_time - (self.sh.start_time +
121 * n / self.sh.sample_rate)) < 1. * u.ns
assert ip.sample_rate == self.sh.sample_rate / n
integrated = ip.read(10)
data = integrated['data']
count = integrated['count']
assert ip.tell() == 10
assert abs(ip.time - (self.sh.start_time +
131 * n / self.sh.sample_rate)) < 1. * u.ns
assert st.dtype is ref_data.dtype is data.dtype
assert data.shape == ref_data.shape
assert np.allclose(data, ref_data)
assert np.all(count == n)
def test_integrate_stack(self):
fh = Stack(self.sh, 25, self.phase)
data = fh.read(3)
ih = Integrate(fh, 3)
data2 = ih.read(1)
assert np.all(data2 == data.mean(0))
assert ih.tell() == 1
assert abs(ih.time - (self.sh.start_time + 3 / self.F0)) < 1. * u.ns
def test_integrate_time_non_integer_ratio(self, samples_per_frame):
# Getting non-integer number of samples. With 2.26,
# 1st sample will be 0.00 - 2.26 -> 2 samples;
# 2nd .. 2.26 - 4.52 -> 3 samples;
# 3rd .. 4.52 - 6.78 -> 2 samples; etc.
expected_count = [2, 3, 2, 2, 2, 3, 2, 2]
step = 2.26 / self.sample_rate
raw = self.raw_power[:18]
ref_data = np.add.reduceat(
raw, np.add.accumulate([0] + expected_count[:-1]))
st = Square(self.sh)
ip = Integrate(st,
step,
average=False,
samples_per_frame=samples_per_frame)
assert ip.start_time == self.sh.start_time
assert ip.sample_rate == 1. / step
# Square and integrate everything.
integrated = ip.read(8)
data = integrated['data']
count = integrated['count']
assert ip.tell() == 8
assert abs(ip.time - (ip.start_time + 8 / ip.sample_rate)) < 1. * u.ns
assert st.dtype is ref_data.dtype is data.dtype
assert data.shape == ref_data.shape
assert np.allclose(data, ref_data)
assert np.all(count.T == expected_count)
# Check we can get there with an offset as well
start_time = self.start_time + step
ip = Integrate(st,
step,
start=start_time,
average=False,
samples_per_frame=samples_per_frame)
assert abs(ip.start_time - start_time) < 1 * u.ns
integrated2 = ip.read(7)
assert np.all(integrated2 == integrated[1:])
start_time = self.start_time + 3 * step
ip = Integrate(st,
step,
start=start_time,
average=False,
samples_per_frame=samples_per_frame)
assert abs(ip.start_time - start_time) < 1. * u.ns
integrated2 = ip.read(5)
assert np.all(integrated2 == integrated[3:])
def test_integrate_all(self):
# Load baseband file and get reference intensities.
ref_data = self.raw_power.mean(0)
st = Square(self.sh)
ip = Integrate(st)
assert ip.start_time == self.sh.start_time
assert abs(ip.stop_time - self.sh.stop_time) < 1. * u.ns
assert abs(ip.stop_time - self.sh.start_time -
1. / ip.sample_rate) < 1. * u.ns
# Square and integrate everything.
data = ip.read()
assert ip.tell() == ip.shape[0]
assert st.dtype is ref_data.dtype is data.dtype
assert data.shape == (1, 2)
assert np.allclose(data, ref_data)
def test_integrate_part(self):
# Use start to integrate only part.
ref_data = self.raw_power[151:].mean(0)
st = Square(self.sh)
ip = Integrate(st, start=151)
assert abs(ip.start_time - (self.sh.start_time +
151 / self.sh.sample_rate)) < 1. * u.ns
assert abs(ip.stop_time - self.sh.stop_time) < 1. * u.ns
# Square and integrate everything.
data = ip.read()
assert np.allclose(data, ref_data)
r = repr(ip)
assert r.startswith('Integrate(ih')
assert 'start=151' in r
assert 'step' not in r
def test_integrate_n_via_time_part(self, n, samples_per_frame):
# Also test same as above by passing on start time.
ref_data = self.raw_power[151 * n:161 * n].reshape(-1, n, 2).sum(1)
st = Square(self.sh)
st.seek(151 * n)
start = st.time
ip = Integrate(st,
n / self.sh.sample_rate,
start=start,
average=False,
samples_per_frame=samples_per_frame)
integrated = ip.read(10)
data = integrated['data']
count = integrated['count']
assert ip.tell() == 10
assert st.dtype is ref_data.dtype is data.dtype
assert data.shape == ref_data.shape
assert np.allclose(data, ref_data)
assert np.all(count == n)
def test_integrate_all_no_average(self):
# Load baseband file and get reference intensities.
ref_data = self.raw_power.sum(0)
st = Square(self.sh)
ip = Integrate(st, average=False)
assert ip.start_time == self.sh.start_time
assert abs(ip.stop_time - self.sh.stop_time) < 1. * u.ns
assert abs(ip.stop_time - self.sh.start_time -
1. / ip.sample_rate) < 1. * u.ns
# Square and integrate everything.
integrated = ip.read()
data = integrated['data']
count = integrated['count']
assert ip.tell() == ip.shape[0]
assert st.dtype is ref_data.dtype is data.dtype
assert data.shape == (1, 2)
assert np.allclose(data, ref_data)
assert np.all(count == self.sh.shape[0])
def test_integrate_n(self, n, samples_per_frame, seek):
n_sample = self.raw_power.shape[0] // n
seek = seek if seek > 0 else n_sample + seek
ref_data = (self.raw_power[seek * n:(seek + 10) * n].reshape(-1, n,
2).sum(1))
st = Square(self.sh)
ip = Integrate(st,
n,
average=False,
samples_per_frame=samples_per_frame)
assert ip.shape[0] == n_sample
assert ip.start_time == self.sh.start_time
assert ip.sample_rate == self.sh.sample_rate / n
ip.seek(seek)
assert abs(ip.time -
(self.sh.start_time + seek / ip.sample_rate)) < 1. * u.ns
integrated = ip.read(10)
data = integrated['data']
count = integrated['count']
assert ip.tell() == seek + 10
assert st.dtype is ref_data.dtype is data.dtype
assert data.shape == ref_data.shape
assert np.allclose(data, ref_data)
assert np.all(count == n)
r = repr(ip)
assert f"step={n}" in r
assert 'average=False' in r
def test_basics(self, samples_per_frame):
ref_data = self.raw_data.reshape(-1, 5, 2).mean(1)
fh = Integrate(self.sh,
u.cycle / 25,
self.phase,
samples_per_frame=samples_per_frame)
assert fh.start_time == self.sh.start_time
assert fh.stop_time == self.sh.stop_time
assert fh.sample_rate == 25 / u.cycle
assert fh.samples_per_frame == samples_per_frame
data = fh.read(20)
assert np.all(data == ref_data[:20])
fh.seek(250)
data = fh.read(75)
assert np.all(data == ref_data[250:325])
if samples_per_frame > 1: # very slow otherwise.
data = fh.read()
assert np.all(data == ref_data[325:])
def test_integrate_n_via_time(self, n, samples_per_frame):
ref_data = self.raw_power[151 * n:161 * n].reshape(-1, n, 2).sum(1)
st = Square(self.sh)
ip = Integrate(st,
n / self.sh.sample_rate,
average=False,
samples_per_frame=samples_per_frame)
assert ip.start_time == self.sh.start_time
assert ip.sample_rate == self.sh.sample_rate / n
ip.seek(151)
integrated = ip.read(10)
data = integrated['data']
count = integrated['count']
assert ip.tell() == 161
assert abs(ip.time - (self.sh.start_time +
161 * n / self.sh.sample_rate)) < 1. * u.ns
assert st.dtype is ref_data.dtype is data.dtype
assert data.shape == ref_data.shape
assert np.allclose(data, ref_data)
assert np.all(count == n)