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_dual_mode_64qam(self):
sig = signals.SignalQAMGrayCoded(64, 10**5, nmodes=2)
sig = impairments.change_snr(sig, 30)
sig = sig.resample(sig.fb*2, beta=0.1)
E, wx, e = equalisation.dual_mode_equalisation(sig, (1e-3, 1e-3), 19, adaptive_stepsize=(True, True))
ser = np.mean(E.cal_ser())
assert ser < 1e-5
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_pol_rot(self, method1, method2, phi):
phi = np.pi / phi
fb = 40.e9
os = 2
fs = os * fb
N = 2**16
beta = 0.9
mu1 = 0.1e-2
mu2 = 0.1e-2
M = 32
s = signals.SignalQAMGrayCoded(M, N, nmodes=2, fb=fb)
s = s.resample(fs, beta=beta, renormalise=True)
s = impairments.rotate_field(s, phi)
sout, wxy, err = equalisation.dual_mode_equalisation(
s, (mu1, mu2),
Ntaps=5,
Niter=(3, 3),
methods=(method1, method2),
adaptive_stepsize=(True, True))
sout = helpers.normalise_and_center(sout)
ser = sout.cal_ser()
#plt.plot(sout[0].real, sout[0].imag, 'r.')
#plt.plot(sout[1].real, sout[1].imag, 'b.')
#plt.show()
if ser.mean() > 0.5:
ser = sout[::-1].cal_ser()
npt.assert_allclose(ser, 0)
def test_nd_dualmode(self, N):
import numpy as np
from qampy import impairments
s = signals.ResampledQAM(16, 2**16, fb=20e9, fs=40e9, nmodes=N)
s2 = impairments.change_snr(s, 25)
E, wx, err = equalisation.dual_mode_equalisation(
s2, (1e-3, 1e-3), 11, apply=True, adaptive_stepsize=(True, True))
assert np.mean(E.cal_ber() < 1e-3)
def test_eq_applykw_dual(self):
s2 = impairments.simulate_transmission(self.s,
self.s.fb,
self.s.fs,
snr=20,
dgd=100e-12)
s3, wx, err = equalisation.dual_mode_equalisation(s2, (1e-3, 1e-3),
11,
apply=True)
assert type(s3) is type(self.s)
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),
ntaps,
TrSyms=(Ncma, Nrde),
methods=("mcma", "mddma"),
adaptive_stepsize=(True, True))
"data/20GBaud_SRRC0P05_64QAM_PRBS15.mat",
64, (("X_Symbs", ), ),
fb=20e9,
normalise=True,
fake_polmux=True)
sig = io.create_signal_from_matlab(
symbs, "data/OSNRLoading_IdealRxLaser_1544p91_Att_1_OSNR_38_1.mat", 50e9,
(("CH1", "CH2"), ("CH3", "CH4")))
sig = sig[:, :10**6]
sig = helpers.normalise_and_center(sig)
sig = sig.resample(2 * symbs.fb, beta=0.05, renormalise=True)
#sig = analog_frontend.comp_IQ_inbalance(sig)
E, wxy, err_both = equalisation.dual_mode_equalisation(
sig, (muCMA, muRDE),
ntaps,
Niter=(niter, niter),
methods=("mcma", "sbd"),
adaptive_stepsize=(True, True))
#E, wxy, err = equalisation.equalise_signal(sig, muCMA, Ntaps=33, apply=True)
E = helpers.normalise_and_center(E)
gmi = E.cal_gmi()
print(gmi)
#sys.exit()
plt.figure()
plt.subplot(211)
plt.hexbin(E[0].real, E[0].imag)
plt.subplot(212)
plt.hexbin(E[1].real, E[1].imag)
plt.show()
ntaps = 11
t_pmd = 20.e-12
#Ncma = N//4//os -int(1.5*ntaps)
Ncma = 10000
Nrde = N // 2 // os - int(1.5 * ntaps)
#S, symbols, bits = QAM.generate_signal(N, snr, baudrate=fb, samplingrate=fs, PRBSorder=(15,23))
sig = signals.SignalQAMGrayCoded(M, N, fb=fb, nmodes=2)
S = sig.resample(fs, beta=0.1, renormalise=True)
S = impairments.change_snr(S, snr)
SS = impairments.apply_PMD(S, theta, t_pmd)
E, wx, (err,
err_rde) = equalisation.dual_mode_equalisation(SS, (muCMA, muRDE),
ntaps,
methods=("mcma", "sbd"),
adaptive=(True, True))
E = helpers.normalise_and_center(E)
evm = E.cal_evm()
evm_s = S[:, ::2].cal_evm()
#sys.exit()
plt.figure()
plt.subplot(121)
plt.title('Recovered MCMA/MDDMA')
plt.plot(E[0].real, E[0].imag, 'r.', label=r"$EVM_x=%.1f\%%$" % (evm[0] * 100))
plt.plot(E[1].real, E[1].imag, 'g.', label=r"$EVM_y=%.1f\%%$" % (100 * evm[1]))
plt.legend()
plt.subplot(122)
plt.title('Original')
plt.plot(S[0, ::2].real,
os = 2
fs = os*fb
N = 2**18
theta = np.pi/2.35
M = 16
snr = 24
muCMA = 1e-3
muRDE = 0.5e-3
ntaps = 30
t_pmd = 50e-12
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_s, wxy_s, (err_s, err_rde_s) = equalisation.dual_mode_equalisation(SS, (muCMA, muRDE), ntaps,
methods=("mcma", "mrde"))
E_s = helpers.normalise_and_center(E_s)
evm = sig[:, ::2].cal_evm()
evmE_s = E_s.cal_evm()
gmiE = E_s.cal_gmi()
print(gmiE)
plt.figure()
plt.subplot(221)
plt.hexbin(E_s[0].real, E_s[0].imag)
plt.text(0.999, 0.9, r"$EVM_x={:.1f}\%$".format(100*evmE_s[0]), color='w', horizontalalignment="right", fontsize=14)
plt.subplot(222)
plt.title('Recovered MCMA/MRDE')
plt.hexbin(E_s[1].real, E_s[1].imag)
plt.text(0.999, 0.9, r"$EVM_y={:.1f}\%$".format(100*evmE_s[1]), color='w', horizontalalignment="right", fontsize=14)
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_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_s = helpers.normalise_and_center(E_s)
evm = sig[:, ::2].cal_evm()
evmE_s = E_s.cal_evm()
gmiE = E_s.cal_gmi()
print(gmiE)
plt.figure()
plt.subplot(221)
plt.hexbin(E_s[0].real, E_s[0].imag)
plt.text(0.999,
0.9,
r"$EVM_x={:.1f}\%$".format(100 * evmE_s[0]),
snr = 24
muCMA = 1e-3
muRDE = 0.5e-3
ntaps = 30
t_pmd = 50e-12
Ncma = N // 6 // os - int(1.5 * ntaps)
Nrde = 5 * N // 6 // os - int(1.5 * ntaps)
S, symbols, bits = QAM.generate_signal(N,
snr,
baudrate=fb,
samplingrate=fs,
PRBSorder=(15, 23))
SS = impairments.apply_PMD_to_field(S, theta, t_pmd, fs)
E_m, (wx_m, wy_m), (err_m, err_rde_m) = equalisation.dual_mode_equalisation(
SS, os, M, ntaps, methods=("mcma", "mrde"), TrSyms=(Ncma, Nrde))
evmX = QAM.cal_evm(S[0, ::2])
evmY = QAM.cal_evm(S[1, ::2])
evmEx_m = QAM.cal_evm(E_m[0])
evmEy_m = QAM.cal_evm(E_m[1])
#sys.exit()
plt.figure()
plt.subplot(121)
plt.title('Recovered MCMA/MRDE')
plt.plot(E_m[0].real,
E_m[0].imag,
'r.',
label=r"$EVM_x=%.1f\%%$" % (evmEx_m * 100))
plt.plot(E_m[1].real,
E_m[1].imag,
#X = utils.pre_filter(X, 2*3.9)
#Y = utils.pre_filter(Y, 2*3.9)
#X = utils.resample(X, 2.5, 2)
#Y = utils.resample(Y, 2.5, 2)
X = qampy.resample.rrcos_resample(X, 2.5, 2, beta=0.05, Ts=1)
Y = qampy.resample.rrcos_resample(Y, 2.5, 2, beta=0.05, Ts=1)
X = analog_frontend.comp_IQ_inbalance(X)
Y = analog_frontend.comp_IQbalance(Y)
print(X.shape)
print(Y.shape)
SS = np.vstack([X[5000:-5000],Y[5000:-5000]])
SS = SS[:,:int(2e5)]
E, wxy, err_both = equalisation.dual_mode_equalisation(SS, os, M, ntaps, Niter=(5, 5), methods=("mcma", "sbd"),
adaptive_stepsize=(True, True))
X = signal_quality.norm_to_s0(E[0, :], M)
Y = signal_quality.norm_to_s0(E[1, :], M)
E = np.vstack([X,Y])
foe = phaserecovery.find_freq_offset(E, fft_size =2 ** 10)
E = phaserecovery.comp_freq_offset(E, foe)
#Ec = E[:,2e4:-2e4]
wx, err_both = equalisation.equalise_signal(E, 1, M, Ntaps=ntaps, Niter=4, method="sbd", adaptive_stepsize=False)
Ec = equalisation.apply_filter(E, 1, wx)
E = Ec
N = 10**6
theta = np.pi/2.35
M = 16
QAM = signals.QAMModulator(16)
snr = 24
muCMA = 3e-4
muRDE = 3e-4
ntaps = 30
trsyms = N//os//2-(ntaps+5) # use full width for training
methods = ("mcma", "sbd")
S, symbols, bits = QAM.generate_signal(N, snr, baudrate=fb, samplingrate=fs, PRBSorder=(15,23))
t_pmd = 50e-12
SS = impairments.apply_PMD_to_field(S, theta, t_pmd, fs)
t1 = timer()
E, (wx, wy), (err, err_rde) = equalisation.dual_mode_equalisation(SS, os, M, ntaps, methods=methods, beta=4)
t2 = timer()
print("EQ time: %.1f"%(t2-t1))
evmX = QAM.cal_evm(S[0, ::2])
evmY = QAM.cal_evm(S[1, ::2])
evmEx = QAM.cal_evm(E[0])
evmEy = QAM.cal_evm(E[1])
print(evmEx)
print(evmY)
#sys.exit()
