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_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_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)