class TestReturnObject(object):
s = signals.ResampledQAM(16, 2 ** 16, fb=20e9, fs=40e9, nmodes=2)
os = 2
def test_apply_filter_basic(self):
s2 = cimpairments.simulate_transmission(self.s, self.s.fb, self.s.fs, snr=20, dgd=100e-12)
wx, err = equalisation.equalise_signal(s2, 1e-3, Ntaps=11)
s3 = equalisation.apply_filter(s2, wx)
assert type(s3) is type(self.s)
def test_eq_applykw(self):
s2 = cimpairments.simulate_transmission(self.s, self.s.fb, self.s.fs, snr=20, dgd=100e-12)
s3, wx, err = equalisation.equalise_signal(s2, 1e-3, Ntaps=11, apply=True)
assert type(s3) is type(self.s)
def test_eq_applykw_dual(self):
s2 = cimpairments.simulate_transmission(self.s, self.s.fb, self.s.fs, snr=20, dgd=100e-12)
s3, wx, err = equalisation.dual_mode_equalisation(s2, (1e-3, 1e-3), 11, apply=True)
assert type(s3) is type(self.s)
@pytest.mark.xfail(reason="The core equalisation functions are not expected to preserve subclasses")
def test_apply_filter_adv(self):
s2 = cimpairments.simulate_transmission(self.s, self.s.fb, self.s.fs, snr=20, dgd=100e-12)
wx, err = cequalisation.equalise_signal(s2, self.os, 1e-3, s2.M, Ntaps=11)
s3 = equalisation.apply_filter(s2, self.os, wx)
assert type(s3) is type(self.s)
def test_nd_dualmode(self, N):
import numpy as np
from qampy import impairments
s = signals.ResampledQAM(16, 2**16, fb=20e9, fs=40e9, nmodes=N)
s2 = impairments.change_snr(s, 25)
E, wx, err = equalisation.dual_mode_equalisation(
s2, (1e-3, 1e-3), 11, apply=True, adaptive_stepsize=(True, True))
assert np.mean(E.cal_ber() < 1e-3)
def test_preserveattr(self, attr):
s1 = signals.ResampledQAM(16, 1000, fs=2)
s2 = s1 + 10
a1 = getattr(s1, attr)
a2 = getattr(s2, attr)
if isinstance(a1, np.ndarray):
npt.assert_array_almost_equal(a1, a2)
else:
assert a1 == a2
class TestReturnObjects(object):
s = signals.ResampledQAM(16, 2**14, fs=2, nmodes=2)
def test_rotate_field(self):
s2 = impairments.rotate_field(self.s, np.pi / 3)
assert type(self.s) is type(s2)
def test_apply_PMD(self):
s2 = impairments.apply_PMD(self.s, np.pi / 3, 1e-3)
assert type(self.s) is type(s2)
def test_apply_phase_noise(self):
s2 = impairments.apply_phase_noise(self.s, 1e-3)
assert type(self.s) is type(s2)
def test_change_snr(self):
s2 = impairments.change_snr(self.s, 30)
assert type(self.s) is type(s2)
def test_add_carrier_offset(self):
s2 = impairments.add_carrier_offset(self.s, 1e-3)
assert type(self.s) is type(s2)
def test_simulate_transmission(self):
s2 = impairments.simulate_transmission(self.s,
snr=20,
freq_off=1e-4,
lwdth=1e-4,
dgd=1e-2)
assert type(self.s) is type(s2)
@pytest.mark.parametrize("attr", ["fs", "symbols", "fb"])
def test_add_awgn(self, attr):
s2 = impairments.add_awgn(self.s, 0.01)
assert getattr(self.s, attr) is getattr(s2, attr)
@pytest.mark.parametrize("attr", ["fs", "symbols", "fb"])
def test_rotate_field_attr(self, attr):
s2 = impairments.rotate_field(self.s, np.pi / 3)
assert getattr(self.s, attr) is getattr(s2, attr)
@pytest.mark.parametrize("attr", ["fs", "symbols", "fb"])
def test_apply_PMD_attr(self, attr):
s2 = impairments.apply_PMD(self.s, np.pi / 3, 1e-3)
assert getattr(self.s, attr) is getattr(s2, attr)
@pytest.mark.parametrize("attr", ["fs", "symbols", "fb"])
def test_apply_phase_noise_attr(self, attr):
s2 = impairments.apply_phase_noise(self.s, 1e-3)
assert getattr(self.s, attr) is getattr(s2, attr)
@pytest.mark.parametrize("attr", ["fs", "symbols", "fb"])
def test_add_awgn_attr(self, attr):
s2 = impairments.add_awgn(self.s, 0.01)
assert getattr(self.s, attr) is getattr(s2, attr)
class TestReturnObjectsAdv(object):
s = signals.ResampledQAM(16, 2 ** 14, fs=2, nmodes=2)
@pytest.mark.xfail(reason="core version does not preserve subclass")
def test_pre_filter(self):
s2 = cfilter.pre_filter(self.s, 0.01)
assert type(self.s) is type(s2)
@pytest.mark.xfail(reason="core version does not preserve subclass")
def test_filter_signal(self):
s2 = cfilter.filter_signal(self.s, self.s.fs, 0.001)
assert type(self.s) is type(s2)
def test_filter_signal_analog(self):
s2 = cfilter.filter_signal_analog(self.s, self.s.fs, 0.001)
assert type(self.s) is type(s2)
@pytest.mark.xfail(reason="core version does not preserve subclass")
def test_rrcos_pulseshaping(self):
s2 = cfilter.rrcos_pulseshaping(self.s, self.s.fs, 1 / self.s.fb, 0.1)
assert type(self.s) is type(s2)
def test_mvg_avg(self):
s2 = cfilter.moving_average(self.s)
assert type(self.s) is type(s2)
@pytest.mark.parametrize("attr", ["fs", "symbols", "fb"])
@pytest.mark.xfail(reason="core version does not preserve subclass")
def test_pre_filter_attr(self, attr):
s2 = cfilter.pre_filter(self.s, 0.01)
assert getattr(self.s, attr) is getattr(s2, attr)
@pytest.mark.xfail(reason="core version does not preserve subclass")
@pytest.mark.parametrize("attr", ["fs", "symbols", "fb"])
def test_filter_signal_attr(self, attr):
s2 = cfilter.filter_signal(self.s, self.s.fs, 0.01)
assert getattr(self.s, attr) is getattr(s2, attr)
@pytest.mark.parametrize("attr", ["fs", "symbols", "fb"])
def test_filter_signal_analog_attr(self, attr):
s2 = cfilter.filter_signal_analog(self.s, self.s.fs, 0.01)
assert getattr(self.s, attr) is getattr(s2, attr)
@pytest.mark.xfail(reason="core version does not preserve subclass")
@pytest.mark.parametrize("attr", ["fs", "symbols", "fb"])
def test_rrcos_pulseshaping_attr(self, attr):
s2 = cfilter.rrcos_pulseshaping(self.s, self.s.fs, 1 / self.s.fb, 0.1)
assert getattr(self.s, attr) is getattr(s2, attr)
@pytest.mark.parametrize("attr", ["fs", "symbols", "fb"])
def test_mvg_avg_attr(self, attr):
s2 = cfilter.moving_average(self.s)
assert getattr(self.s, attr) is getattr(s2, attr)
class TestReturnObjectsBasic(object):
s = signals.ResampledQAM(16, 2 ** 14, fs=2, nmodes=2)
def test_pre_filter(self):
s2 = filtering.pre_filter(self.s, 0.01)
assert type(self.s) is type(s2)
@pytest.mark.xfail(reason="filter_signal is not exported to basic")
def test_filter_signal(self):
s2 = filtering.filter_signal(self.s, self.s.fs, 0.001)
assert type(self.s) is type(s2)
def test_filter_signal_analog(self):
s2 = filtering.filter_signal_analog(self.s, 0.001)
assert type(self.s) is type(s2)
def test_rrcos_pulseshaping(self):
s2 = filtering.rrcos_pulseshaping(self.s, 0.1)
assert type(self.s) is type(s2)
def test_mvg_avg(self):
s2 = filtering.moving_average(self.s)
assert type(self.s) is type(s2)
@pytest.mark.parametrize("attr", ["fs", "symbols", "fb"])
def test_pre_filter_attr(self, attr):
s2 = filtering.pre_filter(self.s, 0.01)
assert getattr(self.s, attr) is getattr(s2, attr)
@pytest.mark.xfail(reason="filter_signal is not exported to basic")
@pytest.mark.parametrize("attr", ["fs", "symbols", "fb"])
def test_filter_signal_attr(self, attr):
s2 = filtering.filter_signal(self.s, 0.01)
assert getattr(self.s, attr) is getattr(s2, attr)
@pytest.mark.parametrize("attr", ["fs", "symbols", "fb"])
def test_filter_signal_analog_attr(self, attr):
s2 = filtering.filter_signal_analog(self.s, 0.01)
assert getattr(self.s, attr) is getattr(s2, attr)
@pytest.mark.parametrize("attr", ["fs", "symbols", "fb"])
def test_rrcos_pulseshaping_attr(self, attr):
s2 = filtering.rrcos_pulseshaping(self.s, 0.1)
assert getattr(self.s, attr) is getattr(s2, attr)
@pytest.mark.parametrize("attr", ["fs", "symbols", "fb"])
def test_mvg_avg_attr(self, attr):
s2 = filtering.moving_average(self.s)
assert getattr(self.s, attr) is getattr(s2, attr)
def test_ber_value(self):
s = signals.ResampledQAM(16, 2**16)
s += 0.05 * (np.random.randn(2**16) + 1.j * np.random.randn(2**16))
ber = s.cal_ber()
assert ber[0] == 0
def test_ber_shape(self, nmodes):
s = signals.ResampledQAM(16, 2**16, nmodes=nmodes)
ber = s.cal_ber()
assert ber.shape[0] == nmodes
def test_evm_value(self):
s = signals.ResampledQAM(16, 2**16)
evm = s.cal_evm()
assert evm[0] < 1e-4
def test_evm_shape(self, nmodes):
s = signals.ResampledQAM(16, 2**16, nmodes=nmodes)
evm = s.cal_evm()
assert evm.shape[0] == nmodes
def test_mvg_avg(self, dtype):
s = signals.ResampledQAM(16, 2 ** 14, fs=2, nmodes=2, dtype=dtype)
s2 = filtering.moving_average(s)
assert type(s) is type(s2)
assert s.dtype is s2.dtype
def test_add_carrier_offset(self, dtype):
s = signals.ResampledQAM(16, 2**14, fs=2, nmodes=2, dtype=dtype)
s2 = impairments.add_carrier_offset(s, 1e-3)
assert np.dtype(dtype) is s2.dtype
def test_apply_phase_noise(self, dtype):
s = signals.ResampledQAM(16, 2**14, fs=2, nmodes=2, dtype=dtype)
s2 = impairments.apply_phase_noise(s, 1e-3)
assert np.dtype(dtype) is s2.dtype
theta = 1 * np.pi / 4.5
theta2 = np.pi / 4.3
M = 64
snr = 25
muCMA = 0.19e-2
muRDE = 0.19e-2
ntaps = 15
t_pmd = 100.e-12
Ncma = None
Nrde = None
sig = signals.ResampledQAM(M,
N,
nmodes=2,
fb=fb,
fs=fs,
resamplekwargs={
"beta": 0.01,
"renormalise": True
})
sig = impairments.change_snr(sig, snr)
SS = impairments.apply_PMD(sig, theta, t_pmd)
E_m, wxy_m, (err_m, err_rde_m) = equalisation.dual_mode_equalisation(
SS.astype(np.complex64), (muCMA, muRDE),
ntaps,
TrSyms=(Ncma, Nrde),
methods=("mcma", "sbd"),
adaptive_stepsize=(True, True))
E_s, wxy_s, (err_s, err_rde_s) = equalisation.dual_mode_equalisation(
def test_cal_gmi_shape(self, nmodes):
s = signals.ResampledQAM(16, 2**16, nmodes=nmodes)
gmi, gmi_pb = s.cal_gmi()
assert gmi.shape[0] == nmodes
def test_est_snr_shape(self, nmodes):
s = signals.ResampledQAM(16, 2**16, nmodes=nmodes)
snr = s.est_snr()
assert snr.shape[0] == nmodes
def test_attr_present(self, attr):
s = signals.ResampledQAM(128, 2**12)
assert getattr(s, attr) is not None
def test_filter_signal_analog_attr(self, attr):
s = signals.ResampledQAM(16, 2 ** 14, fs=2, nmodes=2)
s2 = filtering.filter_signal_analog(s, 0.01)
assert getattr(s, attr) is getattr(s2, attr)
def test_rrcos_pulseshaping_attr(self, attr):
s = signals.ResampledQAM(16, 2 ** 14, fs=2, nmodes=2)
s2 = filtering.rrcos_pulseshaping(s, 0.1)
assert getattr(s, attr) is getattr(s2, attr)
def test_mvg_avg_attr(self, attr):
s = signals.ResampledQAM(16, 2 ** 14, fs=2, nmodes=2)
s2 = filtering.moving_average(s)
assert getattr(s, attr) is getattr(s2, attr)
def test_est_snr_value(self):
s = signals.ResampledQAM(16, 2**16)
snr = s.est_snr()
assert snr[0] > 1e25
def test_samplerate(self, os, nmodes):
N = 1000
Nn = os * N
s = signals.ResampledQAM(16, N, fs=os, nmodes=nmodes)
assert s.shape == (nmodes, Nn)
def test_cal_gmi_value(self, M):
s = signals.ResampledQAM(M, 2**16)
s += 0.0004 * (np.random.randn(2**16) + 1.j * np.random.randn(2**16))
nbits = np.log2(M)
gmi, gmi_pb = s.cal_gmi()
npt.assert_almost_equal(gmi[0], nbits)
def test_symbols_implace_op(self):
s = signals.ResampledQAM(4, 2**12)
avg1 = (abs(s.symbols)**2).mean()
s += 5
avg2 = (abs(s.symbols)**2).mean()
npt.assert_array_almost_equal(avg1, avg2)
def test_rotate_field(self, dtype):
s = signals.ResampledQAM(16, 2**14, fs=2, nmodes=2, dtype=dtype)
s2 = impairments.rotate_field(s, np.pi / 3)
assert np.dtype(dtype) is s2.dtype
def test_symbolinherit3(self):
N = 1000
s = signals.ResampledQAM(16, N, fs=2)
sn = s.resample(1, beta=0.2)
npt.assert_array_almost_equal(s.symbols, sn.symbols)
def test_change_snr(self, dtype):
s = signals.ResampledQAM(16, 2**14, fs=2, nmodes=2, dtype=dtype)
s2 = impairments.change_snr(s, 30)
assert np.dtype(dtype) is s2.dtype
def test_symbol_attr(self, attr):
s = signals.ResampledQAM(16, 2000, fs=2)
a = getattr(s, attr)
assert a is not None
class TestReturnObjects(object):
s = signals.ResampledQAM(16, 2**14, fs=2, nmodes=2)
def test_rotate_field(self):
s2 = impairments.rotate_field(self.s, np.pi / 3)
assert type(self.s) is type(s2)
def test_apply_PMD(self):
s2 = impairments.apply_PMD(self.s, np.pi / 3, 1e-3)
assert type(self.s) is type(s2)
def test_apply_phase_noise(self):
s2 = impairments.apply_phase_noise(self.s, 1e-3)
assert type(self.s) is type(s2)
def test_change_snr(self):
s2 = impairments.change_snr(self.s, 30)
assert type(self.s) is type(s2)
def test_add_carrier_offset(self):
s2 = impairments.add_carrier_offset(self.s, 1e-3)
assert type(self.s) is type(s2)
def test_simulate_transmission(self):
s2 = impairments.simulate_transmission(self.s,
snr=20,
freq_off=1e-4,
lwdth=1e-4,
dgd=1e-2)
assert type(self.s) is type(s2)
def test_sim_tx_response(self):
s = signals.SignalQAMGrayCoded(64, 2**15, fb=20e9, nmodes=1)
s2 = s.resample(s.fb * 2, beta=0.1)
s3 = impairments.sim_tx_response(s2)
assert type(s) is type(s2)
def test_sim_DAC_response(self):
s = signals.SignalQAMGrayCoded(64, 2**15, fb=20e9, nmodes=1)
s2 = s.resample(s.fb * 2, beta=0.1)
s3 = impairments.sim_DAC_response(s2)
assert type(s) is type(s2)
def test_sim_mod_response(self):
s = signals.SignalQAMGrayCoded(64, 2**15, fb=20e9, nmodes=1)
s2 = s.resample(s.fb * 2, beta=0.1)
s3 = impairments.sim_mod_response(s2)
assert type(s) is type(s2)
@pytest.mark.parametrize("attr", ["fs", "symbols", "fb"])
def test_sim_tx_response(self, attr):
s2 = impairments.sim_tx_response(self.s, dac_params={"cutoff": 0.9})
assert getattr(self.s, attr) is getattr(s2, attr)
@pytest.mark.parametrize("attr", ["fs", "symbols", "fb"])
def test_sim_DAC_response(self, attr):
s2 = impairments.sim_DAC_response(self.s, cutoff=0.9)
assert getattr(self.s, attr) is getattr(s2, attr)
@pytest.mark.parametrize("attr", ["fs", "symbols", "fb"])
def test_sim_mod_response(self, attr):
s2 = impairments.sim_mod_response(self.s)
assert getattr(self.s, attr) is getattr(s2, attr)
@pytest.mark.parametrize("attr", ["fs", "symbols", "fb"])
def test_add_awgn(self, attr):
s2 = impairments.add_awgn(self.s, 0.01)
assert getattr(self.s, attr) is getattr(s2, attr)
@pytest.mark.parametrize("attr", ["fs", "symbols", "fb"])
def test_rotate_field_attr(self, attr):
s2 = impairments.rotate_field(self.s, np.pi / 3)
assert getattr(self.s, attr) is getattr(s2, attr)
@pytest.mark.parametrize("attr", ["fs", "symbols", "fb"])
def test_apply_PMD_attr(self, attr):
s2 = impairments.apply_PMD(self.s, np.pi / 3, 1e-3)
assert getattr(self.s, attr) is getattr(s2, attr)
@pytest.mark.parametrize("attr", ["fs", "symbols", "fb"])
def test_apply_phase_noise_attr(self, attr):
s2 = impairments.apply_phase_noise(self.s, 1e-3)
assert getattr(self.s, attr) is getattr(s2, attr)
@pytest.mark.parametrize("attr", ["fs", "symbols", "fb"])
def test_add_awgn_attr(self, attr):
s2 = impairments.add_awgn(self.s, 0.01)
assert getattr(self.s, attr) is getattr(s2, attr)
def test_ser_value(self):
s = signals.ResampledQAM(16, 2**16)
ser = s.cal_ser()
assert ser[0] == 0
