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()
