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_select_angles_benchmark(dtype, method, benchmark, M): benchmark.group = "select_angle" from qampy.core.dsp_cython import bps if method == "pyx": from qampy.core.dsp_cython import select_angles elif method == "pyt": from qampy.core.pythran_dsp import select_angles fb = 40.e9 N = 2**17 NL = 40 sig = signals.SignalQAMGrayCoded(M, N, fb=fb, nmodes=1, dtype=dtype) sig = impairments.apply_phase_noise(sig, 40e3) if dtype is np.dtype(np.complex64): fdtype = np.float32 else: fdtype = np.float64 angles = np.linspace(-np.pi / 4, np.pi / 4, M, endpoint=False, dtype=fdtype).reshape(1, -1) idx = bps(sig[0], angles, sig.coded_symbols, NL) ph = np.array(benchmark(select_angles, angles, idx)).reshape(1, -1) ph[:, NL:-NL] = np.unwrap(ph[:, NL:-NL] * 4) / 4 sigo = sig * np.exp(1j * ph).astype(sig.dtype) sigo = helpers.dump_edges(sigo, 100) ser = sigo.cal_ser() npt.assert_allclose(0, ser, atol=3e-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 test_pmd_phase_fails(self, method, phi, dgd, lw): theta = np.pi / phi fb = 40.e9 os = 2 fs = os * fb N = 2**16 snr = 15 beta = 0.3 mu = 2e-4 M = 4 ntaps = 15 s = signals.SignalQAMGrayCoded(M, N, nmodes=2, fb=fb) s = s.resample(fs, beta=beta, renormalise=True) s = impairments.apply_phase_noise(s, lw) s = impairments.apply_PMD(s, theta, dgd) wxy, err = equalisation.equalise_signal(s, mu, Ntaps=ntaps, method=method, adaptive_stepsize=False) sout = equalisation.apply_filter(s, wxy) sout, ph = phaserec.viterbiviterbi(sout, 11) sout = helpers.normalise_and_center(sout) sout = helpers.dump_edges(sout, 20) ser = sout.cal_ser() npt.assert_allclose(ser, 0)
def test_pmd_phase(self, method1, method2, lw): theta = np.pi / 4.5 dgd = 100e-12 fb = 40.e9 os = 2 fs = os * fb N = 2**16 snr = 15 beta = 0.9 mu1 = 2e-3 if method2 == "mddma": mu2 = 1.0e-3 else: mu2 = 2e-3 M = 32 ntaps = 21 s = signals.SignalQAMGrayCoded(M, N, nmodes=2, fb=fb) s = s.resample(fs, beta=beta, renormalise=True) s = impairments.apply_phase_noise(s, lw) s = impairments.apply_PMD(s, theta, dgd) sout, wxy, err = equalisation.dual_mode_equalisation( s, (mu1, mu2), Ntaps=ntaps, methods=(method1, method2), adaptive_stepsize=(True, True)) sout, ph = phaserec.bps(sout, M, 21) sout = helpers.normalise_and_center(sout) sout = helpers.dump_edges(sout, 50) ser = sout.cal_ser() if ser.mean() > 0.4: ser = sout[::-1].cal_ser() npt.assert_allclose(ser, 0, atol=1.01 * 3 / N) # Three wrong symbols is ok
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_dump_edges(self, nmodes): s = signals.SignalQAMGrayCoded(64, 2**12, nmodes=nmodes) s2 = helpers.dump_edges(s, 100) assert s.shape == (s2.shape[0], s2.shape[1] + 200)
def test_dump_edges(self): s = signals.SignalQAMGrayCoded(64, 2**12) s2 = helpers.dump_edges(s, 100) assert type(s) is type(s2)
fb = 40.e9 os = 1 fs = os*fb N = 3*10**5 M = 64 snr = 30 lw_LO = np.linspace(10e1, 1000e1, 4) #lw_LO = [100e3] sers = [] for lw in lw_LO: shiftN = np.random.randint(-N/2, N/2, 1) s = signals.SignalQAMGrayCoded(M, N, fb=fb) s = s.resample(fs, beta=0.1, renormaise=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, 28, s.coded_symbols, 14, method='pyx') recoverd_2, ph2 = phaserec.bps(pp, 64, s.coded_symbols, 14, method='pyx') recoverd = helpers.dump_edges(recoverd, 20) recoverd_2 = helpers.dump_edges(recoverd_2, 20) ser = recoverd.cal_ser() ser2 = recoverd_2.cal_ser() print("1 stage pyx ser=%g"%ser) print("2 stage pyx ser=%g"%ser2)
SS = impairments.apply_PMD(S, theta2, t_pmd) wxy_m, err_m = equalisation.equalise_signal(SS, mu, TrSyms=None, Ntaps=ntaps, method="mcma", adaptive_step=True) E = equalisation.apply_filter(SS, wxy) E_m = equalisation.apply_filter(SS, wxy_m) E = helpers.normalise_and_center(E) E_m = helpers.normalise_and_center(E_m) #E, ph = phaserec.viterbiviterbi(E, 11) #E_m, ph = phaserec.viterbiviterbi(E_m, 11) E = helpers.dump_edges(E, 20) E_m = helpers.dump_edges(E_m, 20) # note that because of the noise we get sync failures doing SER #ser = E.cal_ser() #ser_m = E_m.cal_ser() #print(E.cal_gmi()) #print(E_m.cal_gmi()) sys.exit() ser0 = S[:, ::2].cal_ser() plt.figure() plt.subplot(131) plt.title('Recovered CMA') plt.plot(E[0].real, E[0].imag, 'ro', label=r"$SER_x=%.1f\%%$" % (100 * ser[0])) plt.plot(E[1].real, E[1].imag, 'go', label=r"$SER=%.1f\%%$" % (ser[1] * 100)) plt.legend()
ber = np.zeros(lwdth.shape) evm1 = np.zeros(lwdth.shape) evm_known = np.zeros(lwdth.shape) gmi = np.zeros([lwdth.shape[0], 2]) i = 0 for L in lwdth: print("Linewidth = %2f Hz" % L) sig2 = impairments.apply_phase_noise(resampled_sig, L) E, BER, errs, tx_synced = equalize_synchronize_signal( resampled_sig=sig2) #Equalizing and synchronizing signal E, BER, errs, tx_synced = equalize_synchronize_signal(resampled_sig=E, mu=2e-3, ntaps=21) E, ph = phaserec.viterbiviterbi(E, 11) E = helpers.dump_edges(E, 20) evm1[i] = sig.cal_evm()[0] evm_known[i] = E.cal_evm()[0] ser[i] = E.cal_ser()[0] ber[i] = E.cal_ber()[0] gmi[i] = E.cal_gmi()[0] i += 1 ##Q_fc = special.erfcinv(ber*2)*np.sqrt(2) pdb.set_trace() Q_fc = special.erfcinv(ber * 2) * np.sqrt(2) #Calculating Q-factor plot_setup_linewidth(M, lwdth, ber, ser, evmf, evm1, evm_known, gmi, Q_fc) ############################################################################################## plt.show()