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, 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)
if mset['errorcalc'] == 'lms': print('LMS Enabled') unit = np.sqrt(2) * 0.5 constellation = [ unit + 1j * unit, unit - 1j * unit, -unit + 1j * unit, -unit - 1j * unit ] errorcalc = TrainedLMS(trainingSyms, constellation, mset['n_training_syms'], mset['lb']) else: errorcalc = CMAErrorCalculator() mimo = FrequencyDomainBlockwizeMimo(set['nmodes'], mset['lb'], ovsmpl, mset['mu'], errorcalc) sig_Martin[:, :], taps_Martin = mimo.equalize_signal(sig) sig_Martin, ph = phaserec.viterbiviterbi(sig_Martin, 11) err_Martin = [] for i_mode in range(set['nmodes']): err_Martin_ = calculate_radius_directed_error( sig_Martin[i_mode, 0:t_stop], 1) err_Martin.append(mlab.movavg(abs(err_Martin_), movavg_taps)) try: ber_martin = calculate_BER(sig_Martin, range(t_conv, t_stop)) except: ber_martin = np.ones(nmodes) title = "Martin_mu" + str(mset['mu']) + "_lb" + str(mset['lb']) plot_constellation(sig_Martin[:, t_conv:t_stop], title, True, mimodir) plot_error(err_Martin, title, True, mimodir) plot_taps(taps_Martin[:, :, 0, :], True, mimodir) final_error_Martin = calculate_final_error(err_Martin, t_conv, t_stop)
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) sig_qampy, ph = phaserec.viterbiviterbi(sig_qampy, 11) err_qampy = [] for i_mode in range(2): err_qampy.append( mlab.movavg(abs(err[i_mode]), movavg_taps)) try: ber_qampy = calculate_BER(sig_qampy, range(t_conv, t_stop)) except: ber_qampy = [1, 1] if produce_plots: title = "Qampy_mu" + str(mu_q) + "_taps" + str(ntaps) plot_constellation(sig_qampy[:, t_conv:t_stop], title,
def test_viterbi(self, ndim): s = signals.SignalQAMGrayCoded(4, 2 ** 16, fb=20e9, nmodes=ndim) s2, ph = phaserec.viterbiviterbi(s, 10) assert type(s2) is type(s)
err_Rx = mlab.movavg(abs(calculate_radius_directed_error(sig[1], R2)), movavg_taps) plot_request_Rx = MimoPlotRequest(err_Rx, sig.copy()[1], np.zeros(lb * 2), "Recieved") ## Equalisation taps_QAMPY, err = equalisation.equalise_signal(sig, mu_Qampy, Ntaps=61, method="cma") sig_QAMPY = equalisation.apply_filter(sig, taps_QAMPY) sig_QAMPY, ph = phaserec.viterbiviterbi(sig_QAMPY, 11) if resample: settings = MIMOSettings(lb=lb, mu=mu_Martin, ovsmpl=2, R2=np.sqrt(R2)) sig_Martin, taps_Martin = fd_cma_mimo_Martin(sig.copy(), settings) else: settings = MIMOSettings(lb=lb, mu=mu_Martin, ovsmpl=1, R2=np.sqrt(R2)) sig_Martin, taps_Martin = fd_cma_mimo_Martin(sig.copy(), settings) sig_Martin, ph = phaserec.viterbiviterbi(sig_Martin, 11) err_Martin = calculate_radius_directed_error(sig_Martin[1][0:t_stop], np.sqrt(R2)) err_Martin = mlab.movavg(abs(err_Martin), movavg_taps) err_Qampy = mlab.movavg(abs(err[1]), movavg_taps)
ser = np.zeros(lwdth.shape) 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()
mu, Ntaps=ntaps, TrSyms=None, method="mcma", adaptive_step=True) 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() 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() plt.subplot(132)
#sig = impairments.change_snr(sig,SNR) #sig = impairments.apply_phase_noise(sig,phase_noise) err_Rx = calculate_radius_directed_error(sig[1], 1) err_Rx = mlab.movavg(abs(err_Rx), movavg_taps) plot_request_Rx = MimoPlotRequest(err_Rx, sig.copy()[1], np.zeros(lb * 2), "Recieved") ## Equalisation taps_QAMPY, err = equalisation.equalise_signal(sig, mu_Qampy, Ntaps=61, method="cma") sig_QAMPY = equalisation.apply_filter(sig, taps_QAMPY) sig_QAMPY, ph = phaserec.viterbiviterbi(sig_QAMPY, 11) #if resample: # sig_Martin = sig[:,:] # even_samples = range(0,N*2,2) # sig_Martin = sig_Martin[:,even_samples] # sig_Martin,taps_Martin = mimo_cma_fd_ba(sig_Martin) #else: sig_Martin = sig.copy() mimo = FrequencyDomainBlockwizeMimo(2, lb, 1, mu_Martin, CMAErrorCalculator()) sig_Martin[:, :], taps_Martin = mimo.equalize_signal(sig) #sig_Martin ,ph = phaserec.viterbiviterbi(sig_Martin, 11) err_Martin = calculate_radius_directed_error(sig_Martin[0][0:t_stop], 1) err_Martin = mlab.movavg(abs(err_Martin), movavg_taps)