def equalize_synchronize_signal(resampled_sig,
mu=None,
ntaps=None,
method=None,
adaptive_step=None,
avoid_cma_sing=None):
#Equalize and synchronize the signal and calculate the bit error rate
if mu is None:
mu = 2e-3
if ntaps is None:
ntaps = 21
if method is None:
method = "cma"
if adaptive_step is None:
adaptive_step = True
if avoid_cma_sing is None:
avoid_cma_sing = False
wxy, err = equalisation.equalise_signal(resampled_sig,
mu,
Ntaps=ntaps,
method=method,
adaptive_step=adaptive_step,
avoid_cma_sing=avoid_cma_sing)
E = equalisation.apply_filter(resampled_sig, wxy)
E = helpers.normalise_and_center(E)
ber, errs, tx_synced = E.cal_ber(
E, verbose=True
) #Synchronize the signal with the data and calculates the bit error rate
return E, ber, errs, tx_synced
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_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_method(self, dtype, method):
fb = 40.e9
os = 2
fs = os * fb
N = 2**13
beta = 0.1
mu = 0.2e-1
M = 16
taps = 7
s = signals.SignalQAMGrayCoded(M, N, nmodes=2, fb=fb, dtype=dtype)
s = s.resample(fs, beta=beta, renormalise=True)
#s = impairments.change_snr(s, 20)
#wxy, err = equalisation.equalise_signal(s, mu, Ntaps=taps, method=method, adaptive_stepsize=True)
wxy, err = equalisation.equalise_signal(s,
mu,
Ntaps=taps,
method=method,
adaptive_stepsize=True)
sout = equalisation.apply_filter(s, wxy)
ser = sout.cal_ser()
#plt.plot(sout[0].real, sout[0].imag, 'r.')
#plt.plot(sout[1].real, sout[1].imag, 'b.')
#plt.show()
npt.assert_allclose(ser, 0, atol=3. / N)
assert np.dtype(dtype) is sout.dtype
def test_pol_rot(self, method, phi):
phi = np.pi / phi
fb = 40.e9
os = 2
fs = os * fb
N = 2**16
beta = 0.1
mu = 0.1e-2
M = 4
ntaps = 3
s = signals.SignalQAMGrayCoded(M, N, nmodes=2, fb=fb)
s = s.resample(fs, beta=beta, renormalise=True)
s = impairments.rotate_field(s, phi)
wxy, err = equalisation.equalise_signal(s,
mu,
Ntaps=ntaps,
method=method,
adaptive_stepsize=True,
avoid_cma_sing=False)
sout = equalisation.apply_filter(s, wxy)
#plt.plot(sout[0].real, sout[0].imag, '.r')
#plt.show()
ser = sout.cal_ser()
#if ser.mean() > 0.5:
#ser = sout[::-1].cal_ser
npt.assert_allclose(ser, 0)
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 = 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)
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_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_real_valued_single_mode(self, method):
s = signals.SignalQAMGrayCoded(4, 10**5, nmodes=1, fb=25e9)
s2 = s.resample(s.fb*2, beta=0.1)
s2 = impairments.sim_mod_response(s*0.2, dcbias=1.1)
s3 = helpers.normalise_and_center(s2)
s4 = impairments.change_snr(s3, 15)
s5, wx, err = equalisation.equalise_signal(s4, 1e-3, Ntaps=17, method=method, adaptive_stepsize=True, apply=True)
assert s5.cal_ser() < 1e5
def test_apply_filter_basic(self):
s2 = impairments.simulate_transmission(self.s,
self.s.fb,
self.s.fs,
snr=20,
dgd=100e-12)
wx, err = equalisation.equalise_signal(s2, 1e-3, Ntaps=11)
s3 = equalisation.apply_filter(s2, wx)
assert type(s3) is type(self.s)
def test_eq_applykw(self):
s2 = impairments.simulate_transmission(self.s,
self.s.fb,
self.s.fs,
snr=20,
dgd=100e-12)
s3, wx, err = equalisation.equalise_signal(s2,
1e-3,
Ntaps=11,
apply=True)
assert type(s3) is type(self.s)
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_single_mode(self, M, nmodes, rmodes, method):
Ntaps=19
sig = signals.SignalQAMGrayCoded(M, 10**5, nmodes=nmodes)
sig = impairments.change_snr(sig, 30)
sig = sig.resample(sig.fb*2, beta=0.1)
if method in cequalisation.DATA_AIDED:
sig = np.roll(sig, Ntaps//2, axis=-1)
if rmodes is None:
modes = None
else:
if nmodes == 1 and rmodes == -1:
modes = np.array([0])
else:
modes = np.arange(nmodes+rmodes)
if modes.size > 1:
np.random.shuffle(modes)
E, wx, e = equalisation.equalise_signal(sig, 0.5e-2, Niter=3, Ntaps=Ntaps, adaptive_stepsize=True, apply=True, modes=modes)
ser = E.cal_ser()
if rmodes is None:
assert ser.size == nmodes
else:
assert ser.size == modes.size
assert np.all(ser < 1e-4)
io.save_inputs(h5f, id, symbols=syms, bits=bits)
h5f.close()
hf = io.tb.open_file(hdfn, "a")
hf = io.create_recvd_data_group(hf, oversampling_dflt=os)
meas_table = hf.root.measurements.oscilloscope.signal
inp_table = hf.root.input.signal
ids = meas_table.cols.id[:]
m_arrays = io.get_from_table(meas_table, ids, "data")
syms = list(io.get_from_table(inp_table, ids, "symbols"))
bits = list(io.get_from_table(inp_table, ids, "bits"))
i = 0
for d_array in m_arrays:
wx, er = equalisation.equalise_signal(d_array,
os,
M,
Ntaps=ntaps,
method=method[0],
adaptive_step=astep)
signalafter = equalisation.apply_filter(d_array, os, wx)
evm_x = modulator.cal_EVM(signalafter[0], syms[ids[i]][0])
evm_y = modulator.cal_EVM(signalafter[1], syms[ids[i]][1])
ser_x, tmp, data_demod_x = modulator.calculate_SER(
signalafter[0], symbol_tx=syms[ids[i]][0])
ser_y, tmp, data_demod_y = modulator.calculate_SER(
signalafter[1], symbol_tx=syms[ids[i]][1])
ber_x = modulator.cal_BER(signalafter[0], bits[ids[i]][0])[0]
ber_y = modulator.cal_BER(signalafter[1], bits[ids[i]][1])[0]
io.save_recvd(hf,
signalafter,
ids[i],
wx,
mu = 1e-3
ntaps = 30
S, symbols, bits = QAM.generate_signal(N,
snr,
PRBSorder=(15, 23),
baudrate=fb,
samplingrate=fs)
t_pmd = 75e-12
SS = impairments.apply_PMD_to_field(S, theta, t_pmd, fs)
#pr.enable()
wx, err = equalisation.equalise_signal(SS,
os,
M,
Ntaps=ntaps,
method="mcma",
adaptive_stepsize=True)
E = equalisation.apply_filter(SS, os, wx)
#E, wx, wy, err = equalisation.FS_MCMA(SS, N-40, ntaps, os, mu, M)
E = E[:, 1000:-1000]
try:
berx = QAM.cal_ber(E[0], bits_tx=bits[0])
except:
berx = QAM.cal_ber(E[1], bits_tx=bits[0])
try:
bery = QAM.cal_ber(E[1], bits_tx=bits[1])
except:
bery = QAM.cal_ber(E[0], bits_tx=bits[1])
t_conv = N - 50000
t_stop = N - 1000
movavg_taps = 1000
resample = False
err_Rx = mlab.movavg(abs(calculate_radius_directed_error(sig[1], R2)),
movavg_taps)
plot_request_Rx = MimoPlotRequest(err_Rx,
sig.copy()[1], np.zeros(lb * 2), "Recieved")
## Equalisation
taps_QAMPY, err = equalisation.equalise_signal(sig,
mu_Qampy,
Ntaps=61,
method="cma")
sig_QAMPY = equalisation.apply_filter(sig, taps_QAMPY)
sig_QAMPY, ph = phaserec.viterbiviterbi(sig_QAMPY, 11)
if resample:
settings = MIMOSettings(lb=lb, mu=mu_Martin, ovsmpl=2, R2=np.sqrt(R2))
sig_Martin, taps_Martin = fd_cma_mimo_Martin(sig.copy(), settings)
else:
settings = MIMOSettings(lb=lb, mu=mu_Martin, ovsmpl=1, R2=np.sqrt(R2))
sig_Martin, taps_Martin = fd_cma_mimo_Martin(sig.copy(), settings)
sig_Martin, ph = phaserec.viterbiviterbi(sig_Martin, 11)
theta2 = np.pi / 4
M = 4
QAM = signals.QAMModulator(M)
snr = 14
mu = 1e-3
S, symbols, bits = QAM.generate_signal(N,
snr,
PRBSorder=(15, 23),
baudrate=fb,
samplingrate=fs)
t_pmd = 75e-12
SS = impairments.apply_PMD_to_field(S, theta, t_pmd, fs)
wxy, err = equalisation.equalise_signal(SS, os, M, Ntaps=30)
E = equalisation.apply_filter(SS, os, wxy)
E = E[:, 1000:-1000]
try:
berx = QAM.cal_ber(E[0], bits_tx=bits[0])
bery = QAM.cal_ber(E[1], bits_tx=bits[1])
except:
berx = QAM.cal_ber(E[1], bits_tx=bits[0])
bery = QAM.cal_ber(E[0], bits_tx=bits[1])
print("X BER %f dB" % (10 * np.log10(berx[0])))
print("Y BER %f dB" % (10 * np.log10(bery[0])))
evmX = QAM.cal_evm(S[0, ::os])
evmY = QAM.cal_evm(S[1, ::os])
evmEx = QAM.cal_evm(E[0])
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)
# note that because of the noise we get sync failures doing SER
#ser = E.cal_ser()
#ser_m = E_m.cal_ser()
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
print("X pol phase")
Ex, phx = phaserecovery.bps(E[0], 32, QAM.symbols, 8)
print("X pol phase done")
print("Y pol phase")
Ey, phy = phaserecovery.bps(E[1], 32, QAM.symbols, 8)
print("Y pol phase done")
Ec = np.vstack([Ex,Ey])
evmX = QAM.cal_evm(X[::2])
evmY = QAM.cal_evm(Y[::2])
evmEx = QAM.cal_evm(E[0])
for M in Mqams:
print("%d-QAM" % M)
ser = np.zeros(snr.shape)
ber = np.zeros(snr.shape)
evm1 = np.zeros(snr.shape)
evm_known = np.zeros(snr.shape)
i = 0
for sr in snr:
print("SNR = %2f.0 dB" % sr)
signal = signals.SignalQAMGrayCoded(M, N, nmodes=1, fb=fb)
signal = signal.resample(fnew=fs, beta=beta, renormalise=True)
signal_s = impairments.change_snr(signal, sr)
#signalx = np.atleast_2d(filtering.rrcos_pulseshaping(signal_s, beta))
wx, er = equalisation.equalise_signal(signal_s,
3e-4,
Ntaps=ntaps,
method="mcma",
adaptive_step=True)
signalafter = equalisation.apply_filter(signal_s, wx)
signalafter = helpers.normalise_and_center(signalafter)
evm1[i] = signal.cal_evm()[0]
evm_known[i] = signalafter.cal_evm()
# check to see that we can recovery timing delay
#signalafter = np.roll(signalafter * 1.j**np.random.randint(0,4), np.random.randint(4, 3000))
ser[i] = signalafter.cal_ser()
ber[i] = signalafter.cal_ber()
i += 1
ax1.plot(snrf,
theory.ber_vs_es_over_n0_qam(10**(snrf / 10), M),
color=c[j],
label="%d-QAM theory" % M)
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)
sig_qampy, ph = phaserec.viterbiviterbi(sig_qampy, 11)
err_qampy = []
for i_mode in range(2):
err_qampy.append(
mlab.movavg(abs(err[i_mode]), movavg_taps))
try:
ber_qampy = calculate_BER(sig_qampy,
range(t_conv, t_stop))
except:
ber_qampy = [1, 1]
if produce_plots:
title = "Qampy_mu" + str(mu_q) + "_taps" + str(ntaps)
ntaps = 13
beta = 0.1
for M in Mqams:
print("%d-QAM"%M)
ser = np.zeros(snr.shape)
ber = np.zeros(snr.shape)
evm1 = np.zeros(snr.shape)
evm_known = np.zeros(snr.shape)
i = 0
for sr in snr:
print("SNR = %2f.0 dB"%sr)
signal = signals.SignalQAMGrayCoded(M, N, nmodes=1, fb=fb)
signal = signal.resample(fnew=fs, beta=beta, renormalise=True)
signal_s = impairments.change_snr(signal, sr)
#signalx = np.atleast_2d(filtering.rrcos_pulseshaping(signal_s, beta))
wx, er = equalisation.equalise_signal(signal_s, 3e-4, Ntaps=ntaps, method="mcma", adaptive_step=True, avoid_cma_sing=False)
signalafter = equalisation.apply_filter(signal_s, wx )
signalafter = helpers.normalise_and_center(signalafter)
evm1[i] = signal.cal_evm()[0]
evm_known[i] = signalafter.cal_evm()
# check to see that we can recovery timing delay
#signalafter = np.roll(signalafter * 1.j**np.random.randint(0,4), np.random.randint(4, 3000))
ser[i] = signalafter.cal_ser()
ber[i] = signalafter.cal_ber()
i += 1
ax1.plot(snrf, theory.ber_vs_es_over_n0_qam(10 ** (snrf / 10), M), color=c[j], label="%d-QAM theory" % M)
ax1.plot(snr, ber, color=c[j], marker=s[j], lw=0, label="%d-QAM"%M)
ax2.plot(snrf, theory.ser_vs_es_over_n0_qam(10 ** (snrf / 10), M), color=c[j], label="%d-QAM theory" % M)
ax2.plot(snr, ser, color=c[j], marker=s[j], lw=0, label="%d-QAM"%M)
ax3.plot(evmf, theory.ber_vs_evm_qam(evmf, M), color=c[j], label="%d-QAM theory" % M)
ax3.plot(qampy.helpers.lin2dB(evm1 ** 2), ber, color=c[j], marker=s[j], lw=0, label="%d-QAM" % M)
