def test_pilot_based_nframe_ber(self, frames ):
mysig = signals.SignalWithPilots(64,2**16,2**10,32,nmodes=2,Mpilots=4,nframes=4,fb=24e9)
mysig2 = mysig.resample(mysig.fb*2,beta=0.1)
mysig3 = impairments.simulate_transmission(mysig2,snr=25, modal_delay=(4000, 4000))
mysig3.sync2frame()
wxy, eq_sig,_ = equalisation.pilot_equaliser_nframes(mysig3, (1e-3, 1e-3), 45, foe_comp=False, frames=frames)
assert np.all(eq_sig.cal_ber(frames=frames) < 5e-3)
def test_simulate_transmission(self):
s2 = impairments.simulate_transmission(self.s,
snr=20,
freq_off=1e-4,
lwdth=1e-4,
dgd=1e-2)
assert type(self.s) is type(s2)
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_pilot_based_nframe_len(self, frames ):
mysig = signals.SignalWithPilots(64,2**16,2**10,32,nmodes=2,Mpilots=4,nframes=4,fb=24e9)
mysig2 = mysig.resample(mysig.fb*2,beta=0.01)
mysig3 = impairments.simulate_transmission(mysig2,snr=25)
mysig3.sync2frame()
wxy, eq_sig,_ = equalisation.pilot_equaliser_nframes(mysig3, (1e-3, 1e-3), 45, foe_comp=False, frames=frames)
assert eq_sig.shape[-1] == eq_sig.frame_len*len(frames)
def test_framesync_noshift(self, snr):
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, snr)
assert s3.sync2frame()
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 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_data_aided(self, modes, method, ps_sym):
from qampy import helpers
ntaps = 21
sig = signals.SignalQAMGrayCoded(64, 10**5, nmodes=2, fb=25e9)
sig2 = sig.resample(2*sig.fb, beta=0.02)
sig2 = helpers.normalise_and_center(sig2)
sig2 = np.roll(sig2, ntaps//2)
sig3 = impairments.simulate_transmission(sig2, dgd=150e-12, theta=np.pi/3., snr=35)
sig3 = helpers.normalise_and_center(sig3)
if ps_sym:
symbs = sig3.symbols
else:
symbs = None
sigout, wxy, err = equalisation.equalise_signal(sig3, 1e-3, Ntaps=ntaps, adaptive_stepsize=True,
symbols=symbs, apply=True, method=method, TrSyms=20000, modes=modes)
sigout = helpers.normalise_and_center(sigout)
gmi = np.mean(sigout.cal_gmi(llr_minmax=True)[0])
assert gmi > 5.9
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 sim_pilot_txrx(sig_snr,
Ntaps=45,
beta=0.1,
M=256,
freq_off=None,
cpe_avg=3,
frame_length=2**16,
pilot_seq_len=512,
pilot_ins_rat=32,
num_frames=3,
modal_delay=None,
laser_lw=None,
fb=20e9,
resBits_tx=None,
resBits_rx=None):
npols = 2
signal = signals.SignalWithPilots(M,
frame_length,
pilot_seq_len,
pilot_ins_rat,
nframes=num_frames,
nmodes=npols,
fb=fb)
signal2 = signal.resample(signal.fb * 2, beta=beta, renormalise=True)
# Simulate transmission
#sig_tx = pilotbased_transmitter.sim_tx(signal2, 2, snr=sig_snr, modal_delay=[800, 200], freqoff=freq_off,
#resBits_rx=resBits_rx)
#sig_tx = impairments.simulate_transmission(signal2, snr=sig_snr, modal_delay=[5000,3000], lwdth=laser_lw, freq_off=freq_off, dgd=70e-12, theta=np.pi/6)
sig_tx = impairments.simulate_transmission(signal2,
snr=sig_snr,
modal_delay=[5000, 3000],
lwdth=laser_lw,
freq_off=freq_off,
dgd=70e-12,
theta=np.pi / 6)
#sig_tx = signal2.recreate_from_np_array(sig_tx)
# Run DSP
dsp_out, phase, dsp_out2, tall1 = run_pilot_receiver2(
sig_tx,
os=int(sig_tx.fs / sig_tx.fb),
M=M,
Numtaps=(17, Ntaps),
frame_length=sig_tx.frame_len,
method=("cma", "sbd"),
pilot_seq_len=sig_tx.pilot_seq.shape[-1],
pilot_ins_ratio=sig_tx._pilot_ins_rat,
mu=(1e-3, 1e-3),
cpe_average=cpe_avg,
foe_comp=True)
dsp_out0, phase0, dsp_out20, tall2 = run_pilot_receiver(
sig_tx,
os=int(sig_tx.fs / sig_tx.fb),
M=M,
Numtaps=(17, Ntaps),
frame_length=sig_tx.frame_len,
method=("cma", "sbd"),
pilot_seq_len=sig_tx.pilot_seq.shape[-1],
pilot_ins_ratio=sig_tx._pilot_ins_rat,
mu=(1e-3, 1e-3),
cpe_average=cpe_avg,
foe_comp=True)
# Calculate GMI and BER
#ber_res = np.zeros(npols)
#sout = signal.recreate_from_np_array(np.array(dsp_out[1]))
#for l in range(npols):
#gmi_res[l] = signal.cal_gmi(dsp_out[1][:])[0][0]
#ber_res[l] = signal.cal_ber(np.vstackdsp_out[1][l])
#gmi_res = sout.cal_gmi()[0]
#ber_res = sout.cal_ber()
#dsp_out0 = dsp_out
return dsp_out, dsp_out0, sig_tx, phase, phase0, signal, dsp_out2, dsp_out20, tall1, tall2
from matplotlib import pylab as plt
from qampy import signals, impairments, equalisation, 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=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)