def test_003_demap_timeslots(self):
timeslots = 15
subcarriers = 32
active_subcarriers = 24
subcarrier_map = get_subcarrier_map(subcarriers,
active_subcarriers,
True)
# subcarrier_map = np.arange(4, 28, dtype=np.int)
mapper = Resource_mapper(timeslots, subcarriers,
active_subcarriers,
subcarrier_map,
True)
self.assertEqual(mapper.block_size(),
timeslots * active_subcarriers)
self.assertEqual(mapper.frame_size(),
timeslots * subcarriers)
d = np.arange(timeslots * active_subcarriers,
dtype=np.complex64) + 1
ref = map_to_waveform_resources(d, active_subcarriers,
subcarriers,
subcarrier_map,
True)
f = mapper.demap_from_resources(ref)
self.assertComplexTuplesAlmostEqual(f, d)
def test_003_active_subcarriers(self):
n_frames = 1
timeslots = 9
subcarriers = 32
active_subcarriers = 20
overlap = 2
f_taps = filters.get_frequency_domain_filter('rrc', .5, timeslots,
subcarriers, overlap)
gfdm_constellation = digital.constellation_qpsk().base()
subcarrier_map = get_subcarrier_map(subcarriers, active_subcarriers)
data = get_random_qpsk(n_frames * timeslots * active_subcarriers)
src = blocks.vector_source_c(data)
mapper = gfdm.resource_mapper_cc(timeslots, subcarriers,
active_subcarriers, subcarrier_map,
True)
mod = gfdm.simple_modulator_cc(timeslots, subcarriers, overlap, f_taps)
demod = gfdm.advanced_receiver_sb_cc(timeslots, subcarriers, overlap,
64, f_taps, gfdm_constellation,
subcarrier_map, 0)
demapper = gfdm.resource_demapper_cc(timeslots, subcarriers,
active_subcarriers,
subcarrier_map, True)
snk = blocks.vector_sink_c()
self.tb.connect(src, mapper, mod, demod, demapper, snk)
self.tb.run()
res = np.array(snk.data())
self.assertComplexTuplesAlmostEqual(data, res, 2)
def validate_parameter_set(self, K, Kon, M, tolerance=5e-4):
self.params.K = K
self.params.Kon = Kon
self.params.M = self.params.Mon = M
self.params.Non = self.params.Kon * self.params.Mon
self.params.N = self.params.K * self.params.M
self.params.pulse = 'rc_fd'
self.subcarrier_map = get_subcarrier_map(self.params.K,
self.params.Kon, dc_free=True)
self.params.Kset = self.subcarrier_map
# vtaps = vc.gfdmutil.get_transmitter_pulse(self.params)
# vtaps = vtaps[::self.params.K // self.params.L]
# taps = np.fft.fft(vtaps)
# taps = get_frequency_domain_filter(self.params.pulse, self.params.a,
# self.params.M, self.params.K,
# self.params.L)
taps = vc.gfdmutil.get_transmitter_pulse(self.params)
g2 = taps[::self.params.K // self.params.L]
taps = np.fft.fft(g2)
mod = vc.DefaultModulator(self.params)
d = np.random.randn(self.params.Non) + 1.j * np.random.randn(self.params.Non)
dframe = map_to_waveform_resource_grid(d, self.params.Kon,
self.params.K,
self.subcarrier_map, True)
vdata = mod.modulate(dframe)
vdata *= 1. / np.linalg.norm(vdata)
gdata = gfdm_modulate_block(dframe.T, taps, self.params.M,
self.params.K, self.params.L, False)
gdata *= 1. / np.linalg.norm(gdata)
print(np.max(np.abs(vdata - gdata)))
self.assertTrue(np.all(np.abs(vdata - gdata) < tolerance))
def test_001_t(self):
np.set_printoptions(precision=2)
n_frames = 7
active_subcarriers = 52
timeslots = 9
subcarriers = 64
cp_len = subcarriers // 4
cs_len = cp_len // 2
taps = get_frequency_domain_filter(self.filter_type, self.alpha,
timeslots, subcarriers,
self.overlap)
window_taps = get_raised_cosine_ramp(
cs_len, get_window_len(cp_len, timeslots, subcarriers, cs_len))
smap = get_subcarrier_map(subcarriers, active_subcarriers, True)
preambles = get_full_preambles(self.filter_type, self.alpha,
active_subcarriers, subcarriers, smap,
self.overlap, cp_len, cs_len, [
0,
])
frame_size = preambles[
0].size + cp_len + timeslots * subcarriers + cs_len
ref = np.array([], dtype=np.complex)
data = np.array([], dtype=np.complex)
for i in range(n_frames):
d = get_random_qpsk(active_subcarriers * timeslots)
frame = generate_reference_frame(d, timeslots, subcarriers,
active_subcarriers, smap, taps,
self.overlap, cp_len, cs_len,
window_taps, [
0,
], preambles)
ref = np.concatenate((ref, frame[0]))
data = np.concatenate((data, d))
src = blocks.vector_source_c(data)
dut = gfdm.transmitter_cc(timeslots, subcarriers, active_subcarriers,
cp_len, cs_len, cs_len, smap, True,
self.overlap, taps, window_taps, [
0,
], preambles, "packet_len")
dst = blocks.vector_sink_c()
self.tb.connect(src, dut, dst)
self.tb.run()
res = np.array(dst.data())[0:len(ref)]
self.assertComplexTuplesAlmostEqual(ref, res, 5)
tags = dst.tags()
for i, t in enumerate(tags):
print(f't={i}, offset={t.offset}, value={pmt.to_python(t.value)}')
self.assertEqual(t.offset, i * frame_size)
self.assertEqual(pmt.to_python(t.value), frame_size)
def generate_preamble(self, subcarriers, active_subcarriers, cp_len,
ramp_len, cyclic_shift):
subcarrier_map = get_subcarrier_map(subcarriers, active_subcarriers,
dc_free=True)
return mapped_preamble(self.seed, self.filtertype, self.filteralpha,
active_subcarriers, subcarriers,
subcarrier_map, self.overlap, cp_len, ramp_len,
use_zadoff_chu=True, cyclic_shift=cyclic_shift)
def test_002_cyclic_delay_diversity(self):
np.set_printoptions(precision=2)
n_frames = 7
active_subcarriers = 52
timeslots = 9
subcarriers = 64
cp_len = subcarriers // 4
cs_len = cp_len // 2
cyclic_shifts = [0, 3, 7, 8]
taps = get_frequency_domain_filter(self.filter_type, self.alpha, timeslots,
subcarriers, self.overlap)
window_taps = get_raised_cosine_ramp(
cs_len, get_window_len(cp_len, timeslots, subcarriers, cs_len))
smap = get_subcarrier_map(subcarriers, active_subcarriers, True)
preambles = get_full_preambles(self.filter_type, self.alpha, active_subcarriers,
subcarriers, smap, self.overlap, cp_len, cs_len, cyclic_shifts)
frame_size = preambles[0].size + cp_len + timeslots * subcarriers + cs_len
ref = [np.array([], dtype=complex) for _ in cyclic_shifts]
data = np.array([], dtype=complex)
for i in range(n_frames):
d = get_random_qpsk(active_subcarriers * timeslots)
frame = generate_reference_frame(d, timeslots, subcarriers, active_subcarriers, smap,
taps, self.overlap, cp_len, cs_len, window_taps,
cyclic_shifts, preambles)
ref = [np.concatenate((r, f)) for r, f in zip(ref, frame)]
data = np.concatenate((data, d))
src = blocks.vector_source_c(data)
dut = gfdm.transmitter_cc(timeslots, subcarriers, active_subcarriers,
cp_len, cs_len, cs_len, smap, True,
self.overlap, taps, window_taps, cyclic_shifts, preambles, "packet_len")
snks = [blocks.vector_sink_c() for _ in cyclic_shifts]
self.tb.connect(src, dut)
for i, s in enumerate(snks):
self.tb.connect((dut, i), s)
self.tb.run()
for snk, refport in zip(snks, ref):
res = np.array(snk.data())[0:refport.size]
self.assertComplexTuplesAlmostEqual(refport, res, 5)
for j, snk in enumerate(snks):
tags = snk.tags()
for i, t in enumerate(tags):
print(f'p={j}, t={i}, offset={t.offset}, value={pmt.to_python(t.value)}')
self.assertEqual(t.offset, i * frame_size)
self.assertEqual(pmt.to_python(t.value), frame_size)
def test_003_snr(self):
nframes = 30
timeslots = 5
subcarriers = 1024
active_subcarriers = 936
overlap = 2
cp_len = subcarriers // 2
ramp_len = cp_len // 2
active_ratio = subcarriers / active_subcarriers
subcarrier_map = get_subcarrier_map(subcarriers, active_subcarriers,
dc_free=True)
preambles = mapped_preamble(self.seed, self.filtertype, self.filteralpha,
active_subcarriers, subcarriers,
subcarrier_map, overlap, cp_len, ramp_len)
core_preamble = preambles[1]
sigenergy = calculate_energy(core_preamble)
data = np.copy(core_preamble)
snrs = np.arange(3, 3 * nframes, 3, dtype=np.float)
snrs_lin = 10. ** (snrs / 10.)
expected_snrs_lin = np.concatenate(((np.inf,), snrs_lin))
for i, snr_lin in enumerate(snrs_lin):
nscale = calculate_noise_scale(
snr_lin, sigenergy, active_ratio, core_preamble.size)
noise = get_noise_vector(core_preamble.size, nscale)
d = core_preamble + noise
data = np.concatenate((data, d))
dut = gfdm.channel_estimator_cc(
timeslots, subcarriers, active_subcarriers, True, 1, core_preamble)
src = blocks.vector_source_c(data)
snk = blocks.vector_sink_c()
self.tb.connect(src, dut, snk)
self.tb.run()
res = np.array(snk.data())
self.assertEqual(res.size, nframes * timeslots * subcarriers)
tags = snk.tags()
snr_tags = [t for t in tags if pmt.eq(t.key, pmt.mp("snr_lin"))]
for i, t in enumerate(snr_tags):
self.assertEqual(t.offset, i * timeslots * subcarriers)
res_lin = pmt.to_float(t.value)
res_db = 10. * np.log10(res_lin)
ref_db = 10. * np.log10(expected_snrs_lin[i])
# print(f"Reference: {ref_db:6.3f}dB\t{res_db:6.3f}dB")
if np.isfinite(ref_db):
self.assertTrue(np.abs(res_db - ref_db) < 1.)
def test_001_t(self):
np.set_printoptions(precision=2)
n_frames = 3
alpha = .5
active = 8
M = 8
K = 16
L = 2
cp_len = 8
cs_len = 4
ramp_len = 4
block_len = M * K
window_len = get_window_len(cp_len, M, K, cs_len)
taps = get_frequency_domain_filter('rrc', alpha, M, K, L)
taps /= np.sqrt(calculate_signal_energy(taps) / M)
window_taps = get_raised_cosine_ramp(ramp_len, window_len)
pn_symbols = get_random_qpsk(K)
H_preamble = get_frequency_domain_filter('rrc', alpha, 2, K, L)
preamble = get_sync_symbol(pn_symbols, H_preamble, K, L, cp_len,
ramp_len)[0]
smap = get_subcarrier_map(K, active, dc_free=True)
ref = np.array([], dtype=complex)
data = np.array([], dtype=complex)
frame_len = window_len + len(preamble)
frame_gap = np.zeros(frame_len)
for i in range(n_frames):
d = get_random_qpsk(active * M)
dd = map_to_waveform_resources(d, active, K, smap)
D = get_data_matrix(dd, K, group_by_subcarrier=False)
b = gfdm_modulate_block(D, taps, M, K, L, False)
b = add_cyclic_starfix(b, cp_len, cs_len)
b = pinch_block(b, window_taps)
ref = np.concatenate((ref, frame_gap, preamble, b))
data = np.concatenate((data, d))
src = blocks.vector_source_c(data)
mapper = gfdm.resource_mapper_cc(active, K, M, smap, True)
mod = gfdm.simple_modulator_cc(M, K, L, taps)
prefixer = gfdm.cyclic_prefixer_cc(block_len, cp_len, cs_len, ramp_len,
window_taps)
preambler = blocks.vector_insert_c(preamble,
window_len + len(preamble), 0)
gapper = blocks.vector_insert_c(frame_gap, frame_len + len(frame_gap),
0)
dst = blocks.vector_sink_c()
self.tb.connect(src, mapper, mod, prefixer, preambler, gapper, dst)
# self.tb.connect(src, mapper, dst)
self.tb.run()
res = np.array(dst.data())[0:len(ref)]
self.assertComplexTuplesAlmostEqual(ref, res, 5)
def test_004_setIC(self):
ic = 2
timeslots = 9
subcarriers = 32
active_subcarriers = 20
overlap = 2
f_taps = filters.get_frequency_domain_filter('rrc', .5, timeslots, subcarriers, overlap)
gfdm_constellation = digital.constellation_qpsk().base()
subcarrier_map = get_subcarrier_map(subcarriers, active_subcarriers)
demod = gfdm.advanced_receiver_sb_cc(timeslots, subcarriers, overlap, 64, f_taps, gfdm_constellation, subcarrier_map)
demod.set_ic(ic)
self.assertEqual(ic, demod.get_ic())
def test_001_t(self):
np.set_printoptions(precision=2)
n_frames = 7
alpha = .5
active_subcarriers = 52
timeslots = 9
subcarriers = 64
overlap = 2
cp_len = 8
cs_len = 4
ramp_len = 4
window_len = get_window_len(cp_len, timeslots, subcarriers, cs_len)
taps = get_frequency_domain_filter('rrc', alpha, timeslots,
subcarriers, overlap)
# taps /= np.sqrt(calculate_signal_energy(taps) / time)
window_taps = get_raised_cosine_ramp(ramp_len, window_len)
pn_symbols = get_random_qpsk(subcarriers)
H_preamble = get_frequency_domain_filter('rrc', alpha, 2,
subcarriers, overlap)
preamble = get_sync_symbol(pn_symbols, H_preamble, subcarriers,
overlap, cp_len, ramp_len)[0]
smap = get_subcarrier_map(subcarriers, active_subcarriers, True)
ref = np.array([], dtype=np.complex)
data = np.array([], dtype=np.complex)
for i in range(n_frames):
d = get_random_qpsk(active_subcarriers * timeslots)
dd = map_to_waveform_resources(d, active_subcarriers,
subcarriers, smap)
D = get_data_matrix(dd, subcarriers, group_by_subcarrier=False)
b = gfdm_modulate_block(D, taps, timeslots, subcarriers,
overlap, False)
b = add_cyclic_starfix(b, cp_len, cs_len)
b = pinch_block(b, window_taps)
ref = np.concatenate((ref, preamble, b))
data = np.concatenate((data, d))
src = blocks.vector_source_c(data)
dut = gfdm.transmitter_cc(timeslots, subcarriers, active_subcarriers,
cp_len, cs_len, ramp_len, smap, True,
overlap, taps, window_taps, preamble, "packet_len")
dst = blocks.vector_sink_c()
self.tb.connect(src, dut, dst)
self.tb.run()
res = np.array(dst.data())[0:len(ref)]
self.assertComplexTuplesAlmostEqual(ref, res, 5)
tags = dst.tags()
for t in tags:
print(t.offset, t.value)
def test_001_t(self):
n_frames = 20
timeslots = 9
subcarriers = 128
active_subcarriers = 110
cp_len = subcarriers // 2
smap = get_subcarrier_map(subcarriers, active_subcarriers)
seed = 4711
ftype = 'rrc'
falpha = .5
preamble, x_preamble = mapped_preamble(seed, ftype, falpha,
active_subcarriers, subcarriers,
smap, 2, cp_len, cp_len // 2)
frame_len = len(preamble) + timeslots * subcarriers + cp_len
frame_gap = np.zeros(frame_len, dtype=np.complex)
data = frame_gap
ref = np.array([], dtype=np.complex)
for i in range(n_frames):
d_block = modulate_mapped_gfdm_block(
get_random_qpsk(timeslots * active_subcarriers), timeslots,
subcarriers, active_subcarriers, 2, falpha)
frame = pinch_cp_add_block(d_block, timeslots, subcarriers, cp_len,
cp_len // 2)
frame = np.concatenate((preamble, frame))
ref = np.concatenate((ref, frame))
data = np.concatenate((data, frame, frame_gap))
# print np.sum(np.abs(x_preamble) ** 2)
# import matplotlib.pyplot as plt
# plt.plot(data.real)
# plt.plot(data.imag)
# plt.show()
backoff = 80
src = blocks.vector_source_c(data)
e_detector = gfdm.frame_energy_detector_cc(10., 32, frame_len, backoff,
'energy')
detector = gfdm.simple_preamble_sync_cc(frame_len, subcarriers, cp_len,
x_preamble, 'energy', 'frame')
snk = blocks.vector_sink_c()
self.tb.connect(src, e_detector, detector, snk)
self.tb.run()
# check data
res = np.array(snk.data())
tags = snk.tags()
for t in tags:
print 'srcid {}, key {}, offset {}, value {}'.format(
t.srcid, t.key, t.offset, t.value)
self.assertComplexTuplesAlmostEqual(res, ref[0:len(res)], 5)
def test_001_t(self):
n_frames = 20
timeslots = 9
subcarriers = 128
active_subcarriers = 110
cp_len = subcarriers // 2
smap = get_subcarrier_map(subcarriers, active_subcarriers)
seed = 4711
ftype = 'rrc'
falpha = .5
tag_key = 'frame_start'
preamble, x_preamble = mapped_preamble(seed, ftype, falpha,
active_subcarriers, subcarriers,
smap, 2, cp_len, cp_len // 2)
block_len = timeslots * subcarriers
offset = len(preamble) + cp_len
frame_len = len(preamble) + timeslots * subcarriers + cp_len
data = np.array([], dtype=np.complex)
ref = np.array([], dtype=np.complex)
tags = []
print 'frame_len: ', frame_len
for i in range(n_frames):
d_block = modulate_mapped_gfdm_block(
get_random_qpsk(timeslots * active_subcarriers), timeslots,
subcarriers, active_subcarriers, 2, falpha)
frame = pinch_cp_add_block(d_block, timeslots, subcarriers, cp_len,
cp_len // 2)
frame = np.concatenate((preamble, frame))
r = frame[offset:offset + block_len]
ref = np.concatenate((ref, r))
tag = gr.tag_t()
tag.key = pmt.string_to_symbol(tag_key)
tag.offset = len(data)
tag.srcid = pmt.string_to_symbol('qa')
tag.value = pmt.from_long(block_len)
tags.append(tag)
data = np.concatenate((data, frame))
src = blocks.vector_source_c(data, False, 1, tags)
cp_rm = gfdm.remove_prefix_cc(frame_len, block_len, offset, tag_key)
snk = blocks.vector_sink_c()
self.tb.connect(src, cp_rm, snk)
self.tb.run()
# # check data
res = np.array(snk.data())
tags = snk.tags()
self.assertTrue(len(tags) == 0) # propagation policy is TPP_DONT
self.assertComplexTuplesAlmostEqual(res, ref, 5)
def test_001_selective(self):
timeslots = 5
subcarriers = 64
active_subcarriers = 52
overlap = 2
cp_len = subcarriers // 2
ramp_len = cp_len // 2
active_symbols = timeslots * active_subcarriers
subcarrier_map = get_subcarrier_map(subcarriers,
active_subcarriers,
dc_free=True)
preambles = mapped_preamble(
self.seed,
self.filtertype,
self.filteralpha,
active_subcarriers,
subcarriers,
subcarrier_map,
overlap,
cp_len,
ramp_len,
)
full_preamble = preambles[0]
core_preamble = preambles[1]
h = np.array([1.0, 0.5, 0.1j, 0.1 + 0.05j], dtype=complex)
data = np.convolve(full_preamble, h, "full")[0:full_preamble.size]
data = data[cp_len:-ramp_len]
self.assertEqual(data.size, core_preamble.size)
estimator = Preamble_channel_estimator(timeslots, subcarriers,
active_subcarriers, True, 1,
core_preamble)
self.assertEqual(estimator.timeslots(), timeslots)
self.assertEqual(estimator.subcarriers(), subcarriers)
self.assertEqual(estimator.active_subcarriers(), active_subcarriers)
self.assertEqual(estimator.frame_len(), timeslots * subcarriers)
self.assertEqual(estimator.is_dc_free(), True)
res = estimator.estimate_frame(data)
lowres = res[0:active_symbols // 2]
hires = res[-active_symbols // 2:]
fh = np.fft.fft(h, timeslots * subcarriers)
lowfh = fh[0:active_symbols // 2]
hifh = fh[-active_symbols // 2:]
self.assertComplexTuplesAlmostEqual(lowres, lowfh, 1)
self.assertComplexTuplesAlmostEqual(hires, hifh, 1)
def test_001_t(self):
np.set_printoptions(precision=2)
n_frames = 3
alpha = .5
active = 8
M = 8
K = 16
L = 2
cp_len = 8
cs_len = 4
ramp_len = 4
block_len = M * K
window_len = get_window_len(cp_len, M, K, cs_len)
taps = get_frequency_domain_filter('rrc', alpha, M, K, L)
taps /= np.sqrt(calculate_signal_energy(taps) / M)
window_taps = get_raised_cosine_ramp(ramp_len, window_len)
pn_symbols = get_random_qpsk(K)
H_preamble = get_frequency_domain_filter('rrc', alpha, 2, K, L)
preamble = get_sync_symbol(pn_symbols, H_preamble, K, L, cp_len, ramp_len)[0]
smap = get_subcarrier_map(K, active, dc_free=True)
ref = np.array([], dtype=np.complex)
data = np.array([], dtype=np.complex)
frame_len = window_len + len(preamble)
frame_gap = np.zeros(frame_len)
for i in range(n_frames):
d = get_random_qpsk(active * M)
dd = map_to_waveform_resources(d, active, K, smap)
D = get_data_matrix(dd, K, group_by_subcarrier=False)
b = gfdm_modulate_block(D, taps, M, K, L, False)
b = add_cyclic_starfix(b, cp_len, cs_len)
b = pinch_block(b, window_taps)
ref = np.concatenate((ref, frame_gap, preamble, b))
data = np.concatenate((data, d))
src = blocks.vector_source_c(data)
mapper = gfdm.resource_mapper_cc(active, K, M, smap, True)
mod = gfdm.simple_modulator_cc(M, K, L, taps)
prefixer = gfdm.cyclic_prefixer_cc(block_len, cp_len, cs_len, ramp_len, window_taps)
preambler = blocks.vector_insert_c(preamble, window_len + len(preamble), 0)
gapper = blocks.vector_insert_c(frame_gap, frame_len + len(frame_gap), 0)
dst = blocks.vector_sink_c()
self.tb.connect(src, mapper, mod, prefixer, preambler, gapper, dst)
# self.tb.connect(src, mapper, dst)
self.tb.run()
res = np.array(dst.data())[0:len(ref)]
self.assertComplexTuplesAlmostEqual(ref, res, 5)
def test_004_setIC(self):
ic = 2
timeslots = 9
subcarriers = 32
active_subcarriers = 20
overlap = 2
f_taps = filters.get_frequency_domain_filter('rrc', .5, timeslots,
subcarriers, overlap)
gfdm_constellation = digital.constellation_qpsk().base()
subcarrier_map = get_subcarrier_map(subcarriers, active_subcarriers)
demod = gfdm.advanced_receiver_sb_cc(timeslots, subcarriers, overlap,
64, f_taps, gfdm_constellation,
subcarrier_map, 0)
demod.set_ic(ic)
self.assertEqual(ic, demod.get_ic())
def test_002_selective(self):
timeslots = 5
subcarriers = 64
active_subcarriers = 52
overlap = 2
cp_len = subcarriers // 2
ramp_len = cp_len // 2
active_symbols = timeslots * active_subcarriers
subcarrier_map = get_subcarrier_map(subcarriers,
active_subcarriers,
dc_free=True)
preambles = mapped_preamble(
self.seed,
self.filtertype,
self.filteralpha,
active_subcarriers,
subcarriers,
subcarrier_map,
overlap,
cp_len,
ramp_len,
)
full_preamble = preambles[0]
core_preamble = preambles[1]
h = np.array([1.0, 0.5, 0.1j, 0.1 + 0.05j], dtype=complex)
data = np.convolve(full_preamble, h, "full")[0:full_preamble.size]
data = data[cp_len:-ramp_len]
self.assertEqual(data.size, core_preamble.size)
dut = gfdm.channel_estimator_cc(timeslots, subcarriers,
active_subcarriers, True, 1,
core_preamble)
src = blocks.vector_source_c(data)
snk = blocks.vector_sink_c()
self.tb.connect(src, dut, snk)
self.tb.run()
res = np.array(snk.data())
lowres = res[0:active_symbols // 2]
hires = res[-active_symbols // 2:]
fh = np.fft.fft(h, timeslots * subcarriers)
lowfh = fh[0:active_symbols // 2]
hifh = fh[-active_symbols // 2:]
self.assertComplexTuplesAlmostEqual(lowres, lowfh, 1)
self.assertComplexTuplesAlmostEqual(hires, hifh, 1)
def test_002_snr(self):
timeslots = 5
subcarriers = 1024
active_subcarriers = 936
overlap = 2
cp_len = subcarriers // 2
ramp_len = cp_len // 2
active_ratio = subcarriers / active_subcarriers
subcarrier_map = get_subcarrier_map(subcarriers,
active_subcarriers,
dc_free=True)
preambles = mapped_preamble(
self.seed,
self.filtertype,
self.filteralpha,
active_subcarriers,
subcarriers,
subcarrier_map,
overlap,
cp_len,
ramp_len,
)
core_preamble = preambles[1]
sigenergy = calculate_energy(core_preamble)
data = np.copy(core_preamble)
snr = 4.0
snr_lin = 10.0**(snr / 10.0)
nscale = calculate_noise_scale(snr_lin, sigenergy, active_ratio,
core_preamble.size)
noise = get_noise_vector(core_preamble.size, nscale)
data = core_preamble + noise
estimator = Preamble_channel_estimator(timeslots, subcarriers,
active_subcarriers, True, 1,
core_preamble)
res = estimator.estimate_snr(data)
res_db = 10.0 * np.log10(res)
print(res, snr_lin)
print(res_db, snr)
self.assertTrue(np.abs(res_db - snr) < 1.0)
def test_002_subcarrier_first(self):
timeslots = 9
subcarriers = 32
active_subcarriers = 20
subcarrier_map = get_subcarrier_map(subcarriers, active_subcarriers)
data = get_random_qpsk(10 * timeslots * active_subcarriers)
src = blocks.vector_source_c(data)
mapper = gfdm.resource_mapper_cc(timeslots, subcarriers, active_subcarriers, subcarrier_map, False)
demapper = gfdm.resource_demapper_cc(timeslots, subcarriers, active_subcarriers, subcarrier_map, False)
snk = blocks.vector_sink_c()
self.tb.connect(src, mapper, demapper, snk)
self.tb.run()
# check data
res = np.array(snk.data())
self.assertComplexTuplesAlmostEqual(data, res)
def test_001_t(self):
n_frames = 20
timeslots = 9
subcarriers = 128
active_subcarriers = 110
cp_len = subcarriers // 2
smap = get_subcarrier_map(subcarriers, active_subcarriers)
seed = 4711
ftype = 'rrc'
falpha = .5
tag_key = 'frame_start'
preamble, x_preamble = mapped_preamble(seed, ftype, falpha, active_subcarriers, subcarriers, smap, 2, cp_len, cp_len // 2)
block_len = timeslots * subcarriers
offset = len(preamble) + cp_len
frame_len = len(preamble) + timeslots * subcarriers + cp_len
data = np.array([], dtype=np.complex)
ref = np.array([], dtype=np.complex)
tags = []
print 'frame_len: ', frame_len
for i in range(n_frames):
d_block = modulate_mapped_gfdm_block(get_random_qpsk(timeslots * active_subcarriers), timeslots, subcarriers, active_subcarriers, 2, falpha)
frame = pinch_cp_add_block(d_block, timeslots, subcarriers, cp_len, cp_len // 2)
frame = np.concatenate((preamble, frame))
r = frame[offset:offset + block_len]
ref = np.concatenate((ref, r))
tag = gr.tag_t()
tag.key = pmt.string_to_symbol(tag_key)
tag.offset = len(data)
tag.srcid = pmt.string_to_symbol('qa')
tag.value = pmt.from_long(block_len)
tags.append(tag)
data = np.concatenate((data, frame))
src = blocks.vector_source_c(data, False, 1, tags)
cp_rm = gfdm.remove_prefix_cc(frame_len, block_len, offset, tag_key)
snk = blocks.vector_sink_c()
self.tb.connect(src, cp_rm, snk)
self.tb.run()
# # check data
res = np.array(snk.data())
tags = snk.tags()
self.assertTrue(len(tags) == 0) # propagation policy is TPP_DONT
self.assertComplexTuplesAlmostEqual(res, ref, 5)
def test_003_map_complex_config(self):
self.params.K = 64
self.params.Kon = 52
self.params.Non = self.params.Kon * self.params.Mon
self.params.N = self.params.K * self.params.M
self.subcarrier_map = get_subcarrier_map(self.params.K,
self.params.Kon, dc_free=True)
self.params.Kset = self.subcarrier_map
mapper = vc.mapping.Mapper(self.params)
d = np.arange(self.params.Non, dtype=np.complex64) + 1
f = mapper.doMap(d)
ref = map_to_waveform_resource_grid(d, self.params.Kon, self.params.K,
self.subcarrier_map, True)
self.assertTrue(np.all(f == ref))
def test_001_t(self):
n_frames = 20
timeslots = 9
subcarriers = 128
active_subcarriers = 110
cp_len = subcarriers // 2
smap = get_subcarrier_map(subcarriers, active_subcarriers)
seed = 4711
ftype = 'rrc'
falpha = .5
preamble, x_preamble = mapped_preamble(seed, ftype, falpha, active_subcarriers, subcarriers, smap, 2, cp_len, cp_len // 2)
frame_len = len(preamble) + timeslots * subcarriers + cp_len
frame_gap = np.zeros(frame_len, dtype=np.complex)
data = frame_gap
ref = np.array([], dtype=np.complex)
for i in range(n_frames):
d_block = modulate_mapped_gfdm_block(get_random_qpsk(timeslots * active_subcarriers), timeslots, subcarriers, active_subcarriers, 2, falpha)
frame = pinch_cp_add_block(d_block, timeslots, subcarriers, cp_len, cp_len // 2)
frame = np.concatenate((preamble, frame))
ref = np.concatenate((ref, frame))
data = np.concatenate((data, frame, frame_gap))
# print np.sum(np.abs(x_preamble) ** 2)
# import matplotlib.pyplot as plt
# plt.plot(data.real)
# plt.plot(data.imag)
# plt.show()
backoff = 80
src = blocks.vector_source_c(data)
e_detector = gfdm.frame_energy_detector_cc(10., 32, frame_len, backoff, 'energy')
detector = gfdm.simple_preamble_sync_cc(frame_len, subcarriers, cp_len, x_preamble, 'energy', 'frame')
snk = blocks.vector_sink_c()
self.tb.connect(src, e_detector, detector, snk)
self.tb.run()
# check data
res = np.array(snk.data())
tags = snk.tags()
for t in tags:
print 'srcid {}, key {}, offset {}, value {}'.format(t.srcid, t.key, t.offset, t.value)
self.assertComplexTuplesAlmostEqual(res, ref[0:len(res)], 5)
def test_003_map_complex_config(self):
self.params.K = 64
self.params.Kon = 52
self.params.Non = self.params.Kon * self.params.Mon
self.params.N = self.params.K * self.params.M
self.subcarrier_map = get_subcarrier_map(self.params.K,
self.params.Kon,
dc_free=True)
self.params.Kset = self.subcarrier_map
mapper = vc.mapping.Mapper(self.params)
d = np.arange(self.params.Non, dtype=np.complex64) + 1
f = mapper.doMap(d)
ref = map_to_waveform_resource_grid(d, self.params.Kon, self.params.K,
self.subcarrier_map, True)
self.assertTrue(np.all(f == ref))
def test_004_active_subcarriers(self):
n_frames = 1
timeslots = 9
subcarriers = 32
active_subcarriers = 20
overlap = 2
ic_iterations = 64
f_taps = filters.get_frequency_domain_filter("rrc", 0.5, timeslots,
subcarriers, overlap)
gfdm_constellation = digital.constellation_qpsk().base()
print(gfdm_constellation.points())
subcarrier_map = get_subcarrier_map(subcarriers, active_subcarriers)
data = get_random_qpsk(n_frames * timeslots * active_subcarriers)
data *= 2.0
src = blocks.vector_source_c(data)
mapper = gfdm.resource_mapper_cc(timeslots, subcarriers,
active_subcarriers, subcarrier_map,
True)
mod = gfdm.simple_modulator_cc(timeslots, subcarriers, overlap, f_taps)
demod = gfdm.advanced_receiver_sb_cc(
timeslots,
subcarriers,
overlap,
ic_iterations,
f_taps,
gfdm_constellation,
subcarrier_map,
0,
)
demod.set_ic(64)
demapper = gfdm.resource_demapper_cc(timeslots, subcarriers,
active_subcarriers,
subcarrier_map, True)
snk = blocks.vector_sink_c()
self.tb.connect(src, mapper, mod, demod, demapper, snk)
self.tb.run()
res = np.array(snk.data())
print(data[0:10])
print(res[0:10])
self.assertComplexTuplesAlmostEqual(data, res, 1)
def test_002_subcarrier_first(self):
timeslots = 9
subcarriers = 32
active_subcarriers = 20
subcarrier_map = get_subcarrier_map(subcarriers, active_subcarriers)
data = get_random_qpsk(10 * timeslots * active_subcarriers)
src = blocks.vector_source_c(data)
mapper = gfdm.resource_mapper_cc(timeslots, subcarriers,
active_subcarriers, subcarrier_map,
False)
demapper = gfdm.resource_demapper_cc(timeslots, subcarriers,
active_subcarriers,
subcarrier_map, False)
snk = blocks.vector_sink_c()
self.tb.connect(src, mapper, demapper, snk)
self.tb.run()
# check data
res = np.array(snk.data())
self.assertComplexTuplesAlmostEqual(data, res)
def test_003_active_subcarriers(self):
n_frames = 1
timeslots = 9
subcarriers = 32
active_subcarriers = 20
overlap = 2
f_taps = filters.get_frequency_domain_filter('rrc', .5, timeslots, subcarriers, overlap)
gfdm_constellation = digital.constellation_qpsk().base()
subcarrier_map = get_subcarrier_map(subcarriers, active_subcarriers)
data = get_random_qpsk(n_frames * timeslots * active_subcarriers)
src = blocks.vector_source_c(data)
mapper = gfdm.resource_mapper_cc(timeslots, subcarriers, active_subcarriers, subcarrier_map, True)
mod = gfdm.simple_modulator_cc(timeslots, subcarriers, overlap, f_taps)
demod = gfdm.advanced_receiver_sb_cc(timeslots, subcarriers, overlap, 64, f_taps, gfdm_constellation, subcarrier_map)
demapper = gfdm.resource_demapper_cc(timeslots, subcarriers, active_subcarriers, subcarrier_map, True)
snk = blocks.vector_sink_c()
self.tb.connect(src, mapper, mod, demod, demapper, snk)
self.tb.run()
res = np.array(snk.data())
self.assertComplexTuplesAlmostEqual(data, res, 2)
def validate_parameter_set(self, K, Kon, M, tolerance=5e-4):
self.params.K = K
self.params.Kon = Kon
self.params.M = self.params.Mon = M
self.params.Non = self.params.Kon * self.params.Mon
self.params.N = self.params.K * self.params.M
self.params.pulse = 'rc_fd'
self.subcarrier_map = get_subcarrier_map(self.params.K,
self.params.Kon,
dc_free=True)
self.params.Kset = self.subcarrier_map
# vtaps = vc.gfdmutil.get_transmitter_pulse(self.params)
# vtaps = vtaps[::self.params.K // self.params.L]
# taps = np.fft.fft(vtaps)
# taps = get_frequency_domain_filter(self.params.pulse, self.params.a,
# self.params.M, self.params.K,
# self.params.L)
taps = vc.gfdmutil.get_transmitter_pulse(self.params)
g2 = taps[::self.params.K // self.params.L]
taps = np.fft.fft(g2)
mod = vc.DefaultModulator(self.params)
d = np.random.randn(
self.params.Non) + 1.j * np.random.randn(self.params.Non)
dframe = map_to_waveform_resource_grid(d, self.params.Kon,
self.params.K,
self.subcarrier_map, True)
vdata = mod.modulate(dframe)
vdata *= 1. / np.linalg.norm(vdata)
gdata = gfdm_modulate_block(dframe.T, taps, self.params.M,
self.params.K, self.params.L, False)
gdata *= 1. / np.linalg.norm(gdata)
print(np.max(np.abs(vdata - gdata)))
self.assertTrue(np.all(np.abs(vdata - gdata) < tolerance))
def test_001_simple(self):
timeslots = 3
subcarriers = 32
active_subcarriers = 24
overlap = 2
cp_len = subcarriers // 2
ramp_len = cp_len // 2
subcarrier_map = get_subcarrier_map(subcarriers,
active_subcarriers,
dc_free=True)
preambles = mapped_preamble(
self.seed,
self.filtertype,
self.filteralpha,
active_subcarriers,
subcarriers,
subcarrier_map,
overlap,
cp_len,
ramp_len,
)
core_preamble = preambles[1]
dut = gfdm.channel_estimator_cc(timeslots, subcarriers,
active_subcarriers, True, 1,
core_preamble)
src = blocks.vector_source_c(core_preamble)
snk = blocks.vector_sink_c()
self.tb.connect(src, dut, snk)
self.tb.run()
res = np.array(snk.data())
self.assertComplexTuplesAlmostEqual(res,
np.ones(res.size, dtype=res.dtype),
6)
