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_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_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 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_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) 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) benchmark(equalisation.apply_filter, SS, wxy, method) 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_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(self, method1, method2): theta = np.pi / 5 dgd = 120e-12 fb = 40.e9 os = 2 fs = os * fb N = 2**16 snr = 15 beta = 0.9 mu1 = 4e-4 mu2 = 4e-4 M = 32 ntaps = 21 s = signals.SignalQAMGrayCoded(M, N, nmodes=2, fb=fb) s = s.resample(fs, beta=beta, renormalise=True) 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 = helpers.normalise_and_center(sout) ser = sout.cal_ser() if ser.mean() > 0.4: ser = sout[::-1].cal_ser() npt.assert_allclose(ser, 0, atol=1.01 * 2 / N) # can tolerate 1-2 errors
def test_pmd_2(self, method, dgd): phi = 6.5 theta = np.pi / phi fb = 40.e9 os = 2 fs = os * fb N = 2**16 snr = 15 beta = 0.1 mu = 0.9e-3 M = 4 ntaps = 7 s = signals.SignalQAMGrayCoded(M, N, nmodes=2, fb=fb) s = s.resample(fs, beta=beta, renormalise=True) s = impairments.apply_PMD(s, theta, dgd) wxy, err = equalisation.equalise_signal(s, mu, Ntaps=ntaps, method=method, adaptive_stepsize=True, avoid_cma_sing=True) sout = equalisation.apply_filter(s, wxy) sout = helpers.normalise_and_center(sout) 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 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_PMD_attr(self, attr): s2 = impairments.apply_PMD(self.s, np.pi / 3, 1e-3) assert getattr(self.s, attr) is getattr(s2, attr)
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( SS, (muCMA, muRDE), ntaps, TrSyms=(Ncma, Nrde), methods=("mcma", "sbd"), adaptive_stepsize=(True, True)) E, wxy, (err, err_rde) = equalisation.dual_mode_equalisation( SS, (muCMA, muRDE),
sig_Martin = sig.copy() trainingSyms = sig.copy() if ovsmpl > 1: sig = sig.resample(2 * sig.fb, beta=0.1, renormalise=True) if apply_impulse: sig = apply_impulse_response_impairment(sig) if apply_matrix: if delay_after_matrix: sig[:, :] = apply_2chnl_delayed_matrix_impairment( sig, 1e-9, 25e9) else: sig[:, :] = apply_2chnl_delayed_after_mix_matrix_impairment( sig, 1e-9, 25e9) sig = impairments.apply_PMD(sig, np.pi / 5.6, pmd) sig = impairments.change_snr(sig, snr) sig = impairments.apply_phase_noise(sig, phase_noise) plot_constellation(sig[:, t_conv:t_stop], "Recieved", True, sigdir) filename = sigdir + "/_rep" + str(r) + ".txt" file = open(filename, 'wb') pickle.dump(sig, file) for mu_q in list_mu_q: for ntaps in list_ntaps: mimodir = create_dir_for_mimo_result( sigdir, mu_q, ntaps, "Qampy") taps_qampy, err = equalisation.equalise_signal( sig, mu_q, Ntaps=ntaps, method="cma") sig_qampy = equalisation.apply_filter(sig, taps_qampy)
print("Adding artificial signal impairments...") if USE_AGWN: sig = impairments.change_snr(sig, SNR) if PLOT_PICTURES: plot_constellation( sig, "Signal constellation after pulseshaping\n and quantum noise, $SNR={:d}$" .format(SNR), "sig_agwn") plot_time( sig, "X-polarization over time after pulseshaping\n and quantum noise, $SNR={:d}$" .format(SNR), "sig_agwn_time") if USE_PMD: sig = impairments.apply_PMD(sig, THETA, TDGD) if PLOT_PICTURES: plot_constellation( sig, "Signal constellation after pulseshaping, AGWN\n and PMD," + r"$\theta=\pi/{:d}$, $\Delta\tau ={:d}ps$".format( int((THETA / np.pi)**-1), int(TDGD * 1e12)), "sig_agwn_pmd") plot_time( sig, "X-polarization over time after pulseshaping,\n AGWN and PMD," + r"$\theta=\pi/{:d}$, $\Delta\tau ={:d}ps$".format( int((THETA / np.pi)**-1), int(TDGD * 1e12)), "sig_agwn_pmd_time") if USE_PHASE_NOISE:
def test_apply_PMD(self, dtype): s = signals.ResampledQAM(16, 2**14, fs=2, nmodes=2, dtype=dtype) s2 = impairments.apply_PMD(s, np.pi / 3, 1e-3) assert np.dtype(dtype) is s2.dtype
def test_apply_PMD(self): s2 = impairments.apply_PMD(self.s, np.pi / 3, 1e-3) assert type(self.s) is type(s2)
fs = os * fb N = 4 * 10**5 mu = 4e-4 theta = np.pi / 5.45 theta2 = np.pi / 2.1 t_pmd = 75e-12 M = 4 ntaps = 40 snr = 5 sig = signals.SignalQAMGrayCoded(M, N, fb=fb, nmodes=2, dtype=np.complex128) 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, 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)