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_coarse_freq_offset(self, fo, mode_offset):
snr = 37
ntaps = 19
sig = signals.SignalWithPilots(64,
2**16,
1024,
32,
nframes=3,
nmodes=2,
fb=24e9)
sig2 = sig.resample(2 * sig.fb, beta=0.01, renormalise=True)
sig3 = impairments.simulate_transmission(sig2,
snr,
freq_off=fo,
modal_delay=[0, mode_offset])
sig4 = helpers.normalise_and_center(sig3)
sig4 = sig4[:, 2000:]
sig4.sync2frame(corr_coarse_foe=True)
s1, s2 = equalisation.pilot_equaliser(sig4, [1e-3, 1e-3],
ntaps,
True,
adaptive_stepsize=True,
foe_comp=True)
d, ph = phaserec.pilot_cpe(s2, nframes=1)
assert np.mean(d.cal_ber()) < 1e-5
def test_data_mix_realandcomplexmethods(self, method):
# currently we do not support to mix real-valued and complex equaliser methods
sig = signals.SignalWithPilots(64,
2**16,
1024,
32,
nframes=2,
nmodes=2,
fb=20e9)
s2 = sig.resample(sig.fb * 2, beta=0.1)
s3 = impairments.simulate_transmission(s2,
25,
modal_delay=[10000, 10000])
s3.sync2frame()
with pytest.raises(ValueError):
equalisation.pilot_equaliser(s3, (1e-3, 1e-3),
11,
methods=(method, "sbd"))
def test_pilot_based(self, rollframe, modal_delay, method):
from qampy import phaserec
mysig = signals.SignalWithPilots(64,2**16,2**10,32,nmodes=2,Mpilots=4,nframes=3,fb=24e9)
mysig2 = mysig.resample(mysig.fb*2,beta=0.01)
mysig3 = impairments.simulate_transmission(mysig2,snr=25,dgd=10e-12, freq_off=100e6,lwdth=100e3,roll_frame_sync=rollframe, modal_delay=modal_delay)
mysig3.sync2frame()
mysig3.corr_foe()
wxy, eq_sig = equalisation.pilot_equaliser(mysig3, (1e-3, 1e-3), 45, foe_comp=False, methods=method)
cpe_sig, ph = phaserec.pilot_cpe(eq_sig,N=5,use_seq=False)
gmi = np.mean(cpe_sig.cal_gmi()[0])
assert gmi > 5.5
def run_pilot_receiver2(rec_signal,
process_frame_id=0,
foe_comp=True,
os=2,
M=128,
Numtaps=(17, 45),
frame_length=2**16,
method=('cma', 'cma'),
pilot_seq_len=512,
pilot_ins_ratio=32,
Niter=(10, 30),
mu=(1e-3, 1e-3),
adap_step=(True, True),
cpe_average=5,
use_cpe_pilot_ratio=1,
remove_inital_cpe_output=True,
remove_phase_pilots=True,
nframes=1):
rec_signal.sync2frame(Ntaps=Numtaps[0],
mu=mu[0],
method=method[0],
adaptive_stepsize=adap_step[0])
#shift_factor = pilotbased_receiver.correct_shifts(rec_signal.shiftfctrs, Numtaps, rec_signal.os)
#signal = np.roll(signal, -shift_factor[shift_factor>=0].min(), axis=-1)
#shift_factors -= shift_factors[shift_factors>=0].min()
#signal.shiftfctrs = shift_factors
taps_all, eq_mode_sig = pilot_equaliser(rec_signal,
mu,
Numtaps[1],
apply=True,
foe_comp=foe_comp,
adaptive_stepsize=adap_step[1],
Niter=Niter[1],
methods=method)
#symbs, trace = pilotbased_receiver.pilot_based_cpe(eq_mode_sig[:, eq_mode_sig._pilot_seq_len:eq_mode_sig.frame_len],
#eq_mode_sig.ph_pilots, eq_mode_sig._pilot_ins_rat,
#use_pilot_ratio=use_cpe_pilot_ratio, num_average=cpe_average,
#remove_phase_pilots=True)
symbs, trace = phaserec.pilot_cpe(eq_mode_sig,
N=cpe_average,
pilot_rat=use_cpe_pilot_ratio,
nframes=1,
use_seq=True)
#symbs = eq_mode_sig
return symbs, trace, eq_mode_sig, taps_all
def test_apply_filter_frames(self, frames, modal_delay):
Ntaps = 45
s = signals.SignalWithPilots(64,
2**16,
1024,
32,
nframes=4,
nmodes=2,
fb=24e9)
s2 = s.resample(2 * s.fb, beta=0.1, renormalise=True)
s3 = impairments.simulate_transmission(
s2, 30, modal_delay=[2000, 2000 + modal_delay])
s3.sync2frame(Ntaps=Ntaps - 14 * 2)
wx = equalisation.pilot_equaliser(s3,
1e-3,
Ntaps,
apply=False,
foe_comp=False)
sout = equalisation.apply_filter(s3, wx, frames=frames)
assert sout.shape[-1] == s.frame_len * len(frames)
for ber in sout.cal_ber():
assert ber < 1e-3
def test_cpe(self, lw):
snr = 37
ntaps = 17
sig = signals.SignalWithPilots(64,
2**16,
1024,
32,
nframes=3,
nmodes=2,
fb=24e9)
sig2 = sig.resample(2 * sig.fb, beta=0.01, renormalise=True)
sig2 = impairments.apply_phase_noise(sig2, 100e3)
sig3 = impairments.change_snr(sig2, snr)
sig4 = sig3[:, 20000:]
sig4.sync2frame(corr_coarse_foe=False)
s1, s2 = equalisation.pilot_equaliser(sig4, [1e-3, 1e-3],
ntaps,
True,
adaptive_stepsize=True,
foe_comp=False)
d, ph = phaserec.pilot_cpe(s2, nframes=1)
assert np.mean(d.cal_ber()) < 1e-5
def test_oversampling_ratios(self, os, taps):
snr = 30.
sig = signals.SignalWithPilots(64,
2**16,
1024,
32,
nframes=3,
nmodes=2,
fb=24e9)
sig2 = sig.resample(os * sig.fb, beta=0.1, renormalise=True)
sig2 = impairments.change_snr(sig2, snr)
#sig3 = sig2[::-1]
#sig4 = sig3[:, 20000:]
sig2.sync2frame(corr_coarse_foe=False)
s1, s2 = equalisation.pilot_equaliser(sig2, [1e-3, 1e-3],
17 + taps * 2,
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_ber(synced=True)
assert np.mean(ser) < 1e-3
sig2 = sig.resample(2 * sig.fb, beta=0.01, renormalise=True)
sig2 = impairments.apply_phase_noise(sig2, 100e3)
sig3 = impairments.change_snr(sig2, snr)
sig3 = core.impairments.rotate_field(sig3, np.pi / 0.1)
#sig4 = sig3[::-1, 20000:]
#sig4[0,:] = sig3[1,20000:]
#sig4[1,:] = sig3[0,20000:]
sig4 = sig3[:, 20000:]
#sig4 = impairments.apply_PMD(sig4, theta, dgd)
#sig4 = impairments.apply_PMD(sig4, theta, dgd)
#sig4[0,:] = sig3[1, 20000:]
#sig4[1,:] = sig3[0, 20000:]
sig4.sync2frame(Ntaps=ntaps)
wx, s1 = equalisation.pilot_equaliser(sig4, [1e-3, 1e-3],
ntaps,
True,
adaptive_stepsize=True)
s2, ph = phaserec.pilot_cpe(s1, nframes=1)
gmi = s2.cal_gmi()
evm = s2.cal_evm()
ber = s2.cal_ber()
ser = s2.cal_ser()
ksnr = s2.est_snr()
print("gmi {}".format(gmi))
print("ber {}".format(ber))
print("evm {}".format(evm))
print("snr {}".format(snr))
print("ser {}".format(ser))
plt.figure()
plt.subplot(121)
plt.title("Without CPE")
Mpilots=4,
nframes=3,
fb=24e9)
mysig2 = mysig.resample(mysig.fb * 2, beta=0.01)
mysig3 = impairments.simulate_transmission(mysig2,
snr=20,
dgd=10e-12,
freq_off=00e6,
lwdth=000e3,
roll_frame_sync=True,
modal_delay=[2000, 3000])
mysig3.sync2frame()
print(mysig3.shiftfctrs)
mysig3.corr_foe()
wxy, eq_sig = equalisation.pilot_equaliser(mysig3, (1e-3, 1e-3),
45,
foe_comp=False,
methods=("cma", "sbd_data"))
cpe_sig, ph = phaserec.pilot_cpe(eq_sig, N=5, use_seq=False)
#cpe_sig = eq_sig
print(cpe_sig.cal_gmi())
plt.figure()
plt.subplot(121)
plt.hist2d(cpe_sig[0].real, cpe_sig[0].imag, bins=200)
#plt.plot(wxy[0][0].real, '-k')
#plt.plot(wxy[0][1].real, '--k')
#plt.plot(wxy[0][0].imag, '-c')
#plt.plot(wxy[0][1].imag, '--c')
plt.subplot(122)
plt.hist2d(cpe_sig[1].real, cpe_sig[1].imag, bins=200)
#plt.plot(wxy[1][0].real, '-k')
#plt.plot(wxy[1][1].real, '--k')
