def test_equalisation_prec(dtype, method, benchmark, backend):
benchmark.group = "equalisation " + method
fb = 40.e9
os = 2
fs = os * fb
N = 10**5
#mu = np.float32(4e-4)
mu = 4e-4
theta = np.pi / 5.45
theta2 = np.pi / 4
t_pmd = 75e-12
M = 4
ntaps = 40
snr = 14
sig = signals.SignalQAMGrayCoded(M, N, fb=fb, nmodes=2, dtype=dtype)
S = sig.resample(fs, renormalise=True, beta=0.1)
#S = impairments.apply_phase_noise(S, 100e3)
S = impairments.change_snr(S, snr)
SS = impairments.apply_PMD(S, theta, t_pmd)
if backend == "pth":
method = method + "_pth"
wxy, err = benchmark(
equalisation.equalise_signal,
SS,
mu,
Ntaps=ntaps,
method=method,
adaptive_stepsize=True,
)
def testquantize(self, dt):
s = signals.SignalQAMGrayCoded(32, 2**10, dtype=dt)
s2 = impairments.change_snr(s, 30)
sn = s2.make_decision()
assert np.dtype(dt) is sn.dtype
assert np.dtype(dt) is sn.symbols.dtype
assert np.dtype(dt) is s.coded_symbols.dtype
def test_dual_mode_64qam(self):
sig = signals.SignalQAMGrayCoded(64, 10**5, nmodes=2)
sig = impairments.change_snr(sig, 30)
sig = sig.resample(sig.fb*2, beta=0.1)
E, wx, e = equalisation.dual_mode_equalisation(sig, (1e-3, 1e-3), 19, adaptive_stepsize=(True, True))
ser = np.mean(E.cal_ser())
assert ser < 1e-5
def test_equalisation_prec(dtype, benchmark):
fb = 40.e9
os = 2
fs = os * fb
N = 10**5
#mu = np.float32(4e-4)
mu = 4e-4
theta = np.pi / 5.45
theta2 = np.pi / 4
t_pmd = 75e-12
M = 4
ntaps = 40
snr = 14
sig = signals.SignalQAMGrayCoded(M, N, fb=fb, nmodes=2, dtype=dtype)
S = sig.resample(fs, renormalise=True, beta=0.1)
S = impairments.apply_phase_noise(S, 100e3)
S = impairments.change_snr(S, snr)
SS = impairments.apply_PMD(S, theta, t_pmd)
wxy, err = benchmark(equalisation.equalise_signal,
SS,
mu,
Ntaps=ntaps,
method="mcma",
adaptive_stepsize=True)
E = equalisation.apply_filter(SS, wxy)
E = helpers.normalise_and_center(E)
E, ph = phaserec.viterbiviterbi(E, 11)
E = helpers.dump_edges(E, 20)
ser = E.cal_ser().mean()
npt.assert_allclose(0, ser, atol=3e-5)
def load_8QAM(N):
SNR = 40
phase_noise = 0e3
ovsmpl = 2
nmodes = 2
#sequence,sig= load.load_harder_capture(N)
#sequence = sequence[:nmodes,:N]
#while sequence.shape[1] < N:
# sequence = np.append(sequence,sequence,axis = 1)
#sequence = sequence[:,:N]
sig = signals.SignalQAMGrayCoded(4, N, fb=25e9, nmodes=nmodes)
#sig[:,:] = sequence
sequence = sig.copy()
if ovsmpl > 1:
sig = sig.resample(ovsmpl * sig.fb, beta=1)
sig = impairments.change_snr(sig, SNR)
sig = impairments.apply_phase_noise(sig, phase_noise)
matrix = imp.build_mixing_matrix(nmodes, 0.2, 0.2)
#sig = imp.apply_mltichnl_delayed_matrix_impairment(sig,0,matrix)
return sequence, sig
def test_recovery_with_pmd(self, theta, dgd):
snr = 30.
ntaps = 41
sig = signals.SignalWithPilots(64,
2**16,
1024,
32,
nframes=3,
nmodes=2,
fb=24e9)
sig2 = sig.resample(2 * sig.fb, beta=0.1, renormalise=True)
sig3 = impairments.change_snr(sig2, snr)
sig3 = impairments.apply_PMD(sig3, theta * np.pi, dgd)
sig4 = sig3[:, 20000:]
sig4.sync2frame(corr_coarse_foe=False)
s1, s2 = equalisation.pilot_equaliser(sig4, [5e-3, 5e-3],
ntaps,
True,
adaptive_stepsize=True,
foe_comp=False)
ph = phaserec.find_pilot_const_phase(
s2.extract_pilots()[:, :s2._pilot_seq_len], s2.pilot_seq)
s2 = phaserec.correct_pilot_const_phase(s2, ph)
ser = s2.cal_ser(synced=False)
snr_m = s2.est_snr(synced=False)
snr_db = 10 * np.log10(np.mean(snr_m))
assert np.mean(ser) < 1e-4
def test_vstheory_ber(self, M, snr, synced):
s = signals.SignalQAMGrayCoded(M, 2 ** 16)
off = {4: 6, 16: 13, 64: 18, 128: 20}
ss = impairments.change_snr(s, snr+off[M])
ber = ss.cal_ber(synced=synced)
ber_t = theory.ber_vs_es_over_n0_qam(10**((snr+off[M])/10), M)
npt.assert_allclose(ber, ber_t, rtol=0.15)
def test_vstheory_evm(self, M, snr, synced):
s = signals.SignalQAMGrayCoded(M, 2 ** 16)
off = {4: 6, 16: 13, 64: 18, 128: 20}
snr = snr+off[M]
ss = impairments.change_snr(s, snr)
evm = helpers.lin2dB(ss.cal_evm(synced=synced)**2)
npt.assert_allclose(snr, -evm, rtol=0.01)
def build_and_impair_signal(set, sigdir):
nmodes = set['nmodes']
N = set['N']
t_conv = N - 50000
t_stop = N - 1000
sig = signals.SignalQAMGrayCoded(4, N, fb=25e9, nmodes=nmodes)
sig_Martin = sig.copy()
trainingSyms = sig.copy()
ovsmpl = set['ovsmpl']
if ovsmpl > 1:
sig = sig.resample(ovsmpl * sig.fb, beta=0.1, renormalise=True)
if set['impulse_impaired']:
sig = apply_impulse_response_impairment(sig)
matrix = build_mixing_matrix(nmodes, set['mixing'], set['loss'])
sig = apply_mltichnl_delayed_matrix_impairment(sig, set['delay'], matrix)
if set['pmd'] > 0:
for i_dmode in range(int(nmodes / 2)):
sig[i_dmode * 2:i_dmode * 2 + 2] = impairments.apply_PMD(
sig[i_dmode * 2:i_dmode * 2 + 2], np.pi / 5.6, set['pmd'])
sig = impairments.change_snr(sig, set['snr'])
sig = impairments.apply_phase_noise(sig, set['phase_noise'])
plot_constellation(sig[:, t_conv:t_stop], "Recieved", True, sigdir)
return sig, sig_Martin, trainingSyms
def test_apply_filter(dtype, benchmark):
fb = 40.e9
os = 2
fs = os * fb
N = 10**5
mu = 4e-4
theta = np.pi / 5.45
theta2 = np.pi / 4
t_pmd = 75e-12
M = 4
ntaps = 40
snr = 14
sig = signals.SignalQAMGrayCoded(M, N, fb=fb, nmodes=2, dtype=dtype)
S = sig.resample(fs, renormalise=True, beta=0.1)
S = impairments.change_snr(S, snr)
SS = impairments.apply_PMD(S, theta, t_pmd)
wxy, err = equalisation.equalise_signal(SS,
mu,
Ntaps=ntaps,
method="mcma",
adaptive_step=True)
E1 = equalisation.apply_filter(SS, wxy, method="pyx")
E2 = equalisation.apply_filter(SS, wxy, method="py")
E2 = E1.recreate_from_np_array(E2)
E1 = helpers.normalise_and_center(E1)
E2 = helpers.normalise_and_center(E2)
E1, ph = phaserec.viterbiviterbi(E1, 11)
E2, ph = phaserec.viterbiviterbi(E2, 11)
E1 = helpers.dump_edges(E1, 20)
E2 = helpers.dump_edges(E2, 20)
ser1 = E1.cal_ser().mean()
ser2 = E2.cal_ser().mean()
npt.assert_allclose(0, ser1, atol=3e-5)
npt.assert_allclose(0, ser2, atol=3e-5)
def test_apply_filter_benchmark(dtype, method, benchmark):
benchmark.group = "apply filter " + str(dtype)
fb = 40.e9
os = 2
fs = os * fb
N = 2**17
mu = 4e-4
theta = np.pi / 5.45
theta2 = np.pi / 4
t_pmd = 75e-12
M = 4
ntaps = 40
snr = 14
sig = signals.SignalQAMGrayCoded(M, N, fb=fb, nmodes=2, dtype=dtype)
S = sig.resample(fs, renormalise=True, beta=0.1)
SS = impairments.change_snr(S, snr)
#SS = impairments.apply_PMD(S, theta, t_pmd)
wxy, err = equalisation.equalise_signal(SS,
mu,
Ntaps=ntaps,
method="mcma",
adaptive_step=True)
E1 = benchmark(equalisation.apply_filter, SS, wxy, method)
E1 = helpers.normalise_and_center(E1)
ser = E1.cal_ser()
npt.assert_allclose(0, ser, atol=3e-5)
def test_sync_reorder_modes(self, Nmodes, M):
sig = signals.SignalQAMGrayCoded(M, 2**16, nmodes=Nmodes)
sig = impairments.change_snr(sig, M + 10)
idx = np.arange(Nmodes)
np.random.shuffle(idx)
s2 = sig[idx, :]
ser = s2.cal_ser()
npt.assert_array_almost_equal(ser, 0)
def test_real_valued_single_mode(self, method):
s = signals.SignalQAMGrayCoded(4, 10**5, nmodes=1, fb=25e9)
s2 = s.resample(s.fb*2, beta=0.1)
s2 = impairments.sim_mod_response(s*0.2, dcbias=1.1)
s3 = helpers.normalise_and_center(s2)
s4 = impairments.change_snr(s3, 15)
s5, wx, err = equalisation.equalise_signal(s4, 1e-3, Ntaps=17, method=method, adaptive_stepsize=True, apply=True)
assert s5.cal_ser() < 1e5
def test_sync_frame(self, ntaps, shift):
s = signals.SignalWithPilots(128, 2**16, 1024, 32, nframes=3)
s = s.resample(2*s.fs, beta=0.1)
s = impairments.change_snr(s, 30)
s = np.roll(s, shift, axis=-1)
s.sync2frame(Ntaps=ntaps, adaptive_stepsize=True, mu=1e-2, method="cma", Niter=10)
shf = shift-ntaps//2
npt.assert_equal(s.shiftfctrs[0], shf - shf%2)
def test_nmodes(self, nmodes, snr_nmodes, fast):
snr = 12.
s = signals.SignalQAMGrayCoded(4, 10**3, nmodes=nmodes)
s2 = impairments.change_snr(s, snr)
if snr_nmodes:
mi = s2.cal_mi(snr=np.ones(nmodes) * snr, fast=fast)
else:
mi = s2.cal_mi(snr=snr, fast=fast)
assert mi.size == nmodes
def test_vstheory_ber(self, M, snr, os):
s = signals.SignalQAMGrayCoded(M, 2 ** 16)
off = {4: 6, 16: 13, 64: 18, 128: 20}
s = s.resample(os, beta=0.1, renormalise=True)
ss = impairments.change_snr(s, snr+off[M])
ss = ss.resample(1, beta=0.1, renormalise=True)
ber = ss.cal_ber()
ber_t = theory.ber_vs_es_over_n0_qam(10**((snr+off[M])/10), M)
npt.assert_allclose(ber, ber_t, rtol=0.18)
def test_vstheory_evm(self, M, snr, os):
s = signals.SignalQAMGrayCoded(M, 2 ** 16)
off = {4: 6, 16: 13, 64: 18, 128: 20}
snr = snr+off[M]
s = s.resample(os, beta=0.1, renormalise=True)
ss = impairments.change_snr(s, snr)
ss = ss.resample(1, beta=0.1, renormalise=True)
evm = helpers.lin2dB(ss.cal_evm() ** 2)
npt.assert_allclose(snr, -evm, rtol=0.1)
def test_verbose_ber_syms(self, M):
s = signals.SignalQAMGrayCoded(M, 2**12)
snr = 30
s = impairments.change_snr(s, snr)
d = abs(np.unique(np.diff(s.coded_symbols.real)))
dmin = d[np.where(d>0)].min()
s2 = _flip_symbols(s, [100], dmin)
ser, errs, syms = s2.cal_ber(synced=True, verbose=True)
assert syms.shape == s2.bits.shape
def test_sync_frame_equalise(self, ntaps, shift):
s = signals.SignalWithPilots(128, 2**16, 512, 32, nframes=3, nmodes=1)
s = s.resample(2*s.fs, beta=0.1)
s = impairments.change_snr(s, 40)
s = np.roll(s, shift, axis=-1)
wx1, ret = s.sync2frame(Ntaps=ntaps, returntaps=True, adaptive_stepsize=True, mu=1e-2, method="cma", Niter=10)
ss = np.roll(s, -s.shiftfctrs[0], axis=-1)
so = core.equalisation.apply_filter(ss, ss.os, wx1)
npt.assert_array_equal(np.sign(so[0,:512].imag), np.sign(s.pilot_seq[0].imag))
npt.assert_array_equal(np.sign(so[0,:512].real), np.sign(s.pilot_seq[0].real))
def test_verbose_ser(self, M):
s = signals.SignalQAMGrayCoded(M, 2**12)
snr = 30
s = impairments.change_snr(s, snr)
d = abs(np.unique(np.diff(s.coded_symbols.real)))
dmin = d[np.where(d>0)].min()
s2 = _flip_symbols(s, [100], dmin)
ser, errs, syms = s2.cal_ser(synced=True, verbose=True)
assert errs[0,100] != 0
assert np.count_nonzero(errs) == 1
def test_nframes_calculation(self, nmodes, method, frames):
ss = signals.SignalWithPilots(64,
2**16,
1024,
32,
nframes=3,
nmodes=nmodes)
s2 = impairments.change_snr(ss, 20)
m = getattr(s2, method)(frames=frames)
print(m)
def test_selected_modes(self, modes, sigmodes):
sig = signals.SignalQAMGrayCoded(4, 2**15, nmodes=sigmodes)
sig = impairments.change_snr(sig, 15)
sig = sig.resample(sig.fb*2, beta=0.1)
E, wx, e = cequalisation.equalise_signal(sig, sig.os, 1e-3, sig.M, Ntaps=10, modes=modes, apply=True)
if modes is None:
modes = np.arange(sigmodes)
E = sig.recreate_from_np_array(E)
ser = np.mean(E.cal_ser())
assert ser < 1e-5
def test_vs_gmi(self, snr, fast, with_snr):
s = signals.SignalQAMGrayCoded(4, 10**3, nmodes=1)
s2 = impairments.change_snr(s, snr)
if with_snr:
mi = s2.cal_mi(snr=snr, fast=fast)
gmi = s2.cal_gmi(snr=snr)[0]
else:
mi = s2.cal_mi(fast=fast)
gmi = s2.cal_gmi()[0]
npt.assert_allclose(gmi, mi, rtol=0.05)
def test_ser_vs_theory(self, shift, M, snr):
from qampy import theory, impairments
s = signals.SignalQAMGrayCoded(M, 10**5, nmodes=1)
ser_t = theory.ser_vs_es_over_n0_qam(10**(snr / 10), M)
if ser_t < 1e-4:
assert True
return
s2 = impairments.change_snr(s, snr)
s2 = np.roll(s2, shift, axis=-1)
ser = s2.cal_ser()
npt.assert_allclose(ser, ser_t, rtol=0.4)
def test_cpe(self,lw):
snr = 37
ntaps = 17
sig = signals.SignalWithPilots(64, 2**16, 1024, 32, nframes=3, nmodes=2, fb=24e9)
sig2 = sig.resample(2*sig.fb, beta=0.01, renormalise=True)
sig2 = impairments.apply_phase_noise(sig2, 100e3)
sig3 = impairments.change_snr(sig2, snr)
sig4 = sig3[:, 20000:]
sig4.sync2frame(corr_coarse_foe=False)
s1, s2 = equalisation.pilot_equalizer(sig4, [1e-3, 1e-3], ntaps, True, adaptive_stepsize=True, foe_comp=False)
d, ph = phaserec.pilot_cpe(s2, nframes=1)
assert np.mean(d.cal_ber()) < 1e-5
def test_swap_pols(self):
snr = 30.
sig = signals.SignalWithPilots(64, 2**16, 1024, 32, nframes=3, nmodes=2, fb=24e9)
sig2 = sig.resample(2*sig.fb, beta=0.1, renormalise=True)
sig2 = impairments.change_snr(sig2, snr)
sig3 = sig2[::-1]
sig4 = sig3[:, 20000:]
sig4.sync2frame(corr_coarse_foe=False)
s1, s2 = equalisation.pilot_equalizer(sig4, [1e-3, 1e-3], 17, True, adaptive_stepsize=True, foe_comp=False)
ph = phaserec.find_pilot_const_phase(s2.extract_pilots()[:,:s2._pilot_seq_len], s2.pilot_seq)
s2 = phaserec.correct_pilot_const_phase(s2, ph)
ser = s2.cal_ser(synced=True)
assert np.mean(ser) < 1e-4
def test_phaserec_bps_2stage(lw, M):
fb = 40.e9
os = 1
fs = os * fb
N = 2**17
snr = 30
shiftN = np.random.randint(-N / 2, N / 2, 1)
s = signals.SignalQAMGrayCoded(M, N, fb=fb)
s = s.resample(fs, beta=0.1, renormalise=True)
s = impairments.change_snr(s, snr)
s = np.roll(s, shiftN, axis=1)
pp = impairments.apply_phase_noise(s, lw)
recoverd, ph1 = phaserec.bps_twostage(pp, max(4, M // 2), 14, method='pyt')
recoverd = helpers.dump_edges(recoverd, 20)
ser = recoverd.cal_ser()
npt.assert_allclose(ser, 0)
def test_symbols(self, sigmodes, symbolsmodes):
selected_modes = np.arange(sigmodes)
sig = signals.SignalQAMGrayCoded(4, 2**15, nmodes=sigmodes)
sig = impairments.change_snr(sig, 15)
sig = sig.resample(sig.fb*2, beta=0.1)
if symbolsmodes is not None:
symbols = sig.coded_symbols
if symbolsmodes > 0:
symbols = np.tile(symbols, (symbolsmodes, 1))
else:
symbols = None
E, wx, e = cequalisation.equalise_signal(sig, sig.os, 1e-3, sig.M, Ntaps=10, symbols=None, apply=True,
modes=selected_modes)
E = sig.recreate_from_np_array(E)
ser = np.mean(E.cal_ser())
assert ser < 1e-5
def test_cal_gmi_frames(self, frame):
M = 64
sig = signals.SignalWithPilots(M,
10**4 + 1000,
1000,
0,
nframes=3,
nmodes=1)
sig2 = impairments.change_snr(sig[:, :sig.frame_len], 25)
sig[0, frame * sig.frame_len:(frame + 1) * sig.frame_len] = sig2[:]
for i in range(3):
gmi = sig.cal_gmi(frames=[i])[0]
if i == frame:
assert np.isclose(gmi, sig2.cal_gmi()[0])
else:
assert np.isclose(gmi, np.log2(M))
def test_est_snr_frames(self, frame):
M = 64
snr_in = 25.
sig = signals.SignalWithPilots(M,
10**4 + 1000,
1000,
0,
nframes=3,
nmodes=1)
sig2 = impairments.change_snr(sig[:, :sig.frame_len], snr_in)
sig[0, frame * sig.frame_len:(frame + 1) * sig.frame_len] = sig2[:]
for i in range(3):
snr = sig.est_snr(frames=[i])
if i == frame:
assert np.isclose(snr, 10**(snr_in / 10), rtol=0.03)
else:
assert np.all(snr > 10e15)
