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)
