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)