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_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): 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_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 test_005_steps(self): timeslots = 5 subcarriers = 32 overlap = 2 filter_alpha = 0.35 taps = get_frequency_domain_filter('rrc', filter_alpha, timeslots, subcarriers, overlap) data = get_random_qpsk(timeslots * subcarriers) D = get_data_matrix(data, subcarriers, group_by_subcarrier=False) frame = gfdm_modulate_block(D, taps, timeslots, subcarriers, overlap, False) ref = gfdm_demodulate_block( frame, taps, subcarriers, timeslots, overlap) demod = Demodulator(timeslots, subcarriers, overlap, taps) fd_res = demod.fft_filter_downsample(frame) res = demod.transform_subcarriers_to_td(fd_res) self.assertComplexTuplesAlmostEqual(ref, res, 5) for _ in range(2): ic_res = demod.cancel_sc_interference(data, fd_res) res = demod.transform_subcarriers_to_td(ic_res) self.assertComplexTuplesAlmostEqual(data, res, 1)
def test_001_t(self): alpha = .5 M = 8 K = 4 L = 2 taps = get_frequency_domain_filter('rrc', alpha, M, K, L) taps /= np.sqrt(calculate_signal_energy(taps) / M) # data = np.repeat(np.arange(1, K + 1), M) data = get_random_qpsk(M * K) D = get_data_matrix(data, K, group_by_subcarrier=False) src = blocks.vector_source_c(data) mod = gfdm.simple_modulator_cc(M, K, L, taps) dst = blocks.vector_sink_c() self.tb.connect(src, mod, dst) # set up fg self.tb.run() # check data res = np.array(dst.data()) # res /= M * K # F = gfdm_transform_subcarriers_to_fd(D, M) # F = gfdm_upsample_subcarriers_in_fd(F, K, L) # F = gfdm_filter_subcarriers_in_fd(F, taps, M, K, L) ref = gfdm_modulate_block(D, taps, M, K, L, False) self.assertComplexTuplesAlmostEqual(ref, res, 5)
def test_002_big_data(self): print "big data test" reps = 5 alpha = .5 M = 127 K = 16 L = 4 taps = get_frequency_domain_filter('rrc', alpha, M, K, L) data = np.array([], dtype=np.complex) ref = np.array([], dtype=np.complex) for i in range(reps): d = get_random_qpsk(M * K) D = get_data_matrix(d, K, group_by_subcarrier=False) ref = np.append(ref, gfdm_modulate_block(D, taps, M, K, L, False)) data = np.append(data, d) # print data # print ref # print "MAXIMUM ref value: ", np.max(abs(ref)) src = blocks.vector_source_c(data) mod = gfdm.simple_modulator_cc(M, K, L, taps) dst = blocks.vector_sink_c() self.tb.connect(src, mod, dst) # set up fg self.tb.run() # check data res = np.array(dst.data()) # res /= M * K # print "MAXIMUM result value: ", np.max(abs(res)) self.assertComplexTuplesAlmostEqual(ref, res, 2)
def test_001_t(self): alpha = .5 M = 8 K = 4 L = 2 taps = get_frequency_domain_filter('rrc', alpha, M, K, L) # data = np.repeat(np.arange(1, K + 1), M) data = get_random_qpsk(M * K) D = get_data_matrix(data, K, group_by_subcarrier=False) # print data # print D src = blocks.vector_source_c(data) mod = gfdm.simple_modulator_cc(M, K, L, taps) dst = blocks.vector_sink_c() self.tb.connect(src, mod, dst) # set up fg self.tb.run() # check data res = np.array(dst.data()) # res /= M * K # F = gfdm_transform_subcarriers_to_fd(D, M) # F = gfdm_upsample_subcarriers_in_fd(F, K, L) # F = gfdm_filter_subcarriers_in_fd(F, taps, M, K, L) ref = gfdm_modulate_block(D, taps, M, K, L, False) self.assertComplexTuplesAlmostEqual(ref, res, 5)
def test_001_simple_receiver(self): # make sure advanced receiver works like simple receiver in case no IC iterations are applied! reps = 5 alpha = .5 M = 127 K = 16 L = 2 taps = filters.get_frequency_domain_filter('rrc', alpha, M, K, L) data = np.array([], dtype=np.complex) ref = np.array([], dtype=np.complex) for i in xrange(reps): d = utils.get_random_qpsk(M * K) ref = np.append(ref, gfdm_demodulate_block(d, taps, K, M, L)) data = np.append(data, d) # print data # print ref # print "MAXIMUM ref value: ", np.max(abs(ref)) src = blocks.vector_source_c(data) est_data = np.ones(len(data), dtype=np.complex) est_src = blocks.vector_source_c(est_data) gfdm_constellation = digital.constellation_qpsk().base() mod = gfdm.advanced_receiver_sb_cc(M, K, L, 0, taps, gfdm_constellation, np.arange(K), 0) dst = blocks.vector_sink_c() self.tb.connect(src, (mod, 0), dst) self.tb.connect(est_src, (mod, 1)) # set up fg self.tb.run() # check data res = np.array(dst.data()) self.assertComplexTuplesAlmostEqual(ref, res, 4)
def test_002_big_data(self): print("big data test") reps = 5 alpha = .5 M = 127 K = 16 L = 4 taps = get_frequency_domain_filter('rrc', alpha, M, K, L) taps /= np.sqrt(calculate_signal_energy(taps) / M) data = np.array([], dtype=complex) ref = np.array([], dtype=complex) for i in range(reps): d = get_random_qpsk(M * K) D = get_data_matrix(d, K, group_by_subcarrier=False) ref = np.append(ref, gfdm_modulate_block(D, taps, M, K, L, False)) data = np.append(data, d) src = blocks.vector_source_c(data) mod = gfdm.simple_modulator_cc(M, K, L, taps) dst = blocks.vector_sink_c() self.tb.connect(src, mod, dst) # set up fg self.tb.run() # check data res = np.array(dst.data()) # res /= M * K self.assertComplexTuplesAlmostEqual(ref, res, 2)
def test_001_simple_receiver(self): # make sure advanced receiver works like simple receiver in case no IC iterations are applied! reps = 5 alpha = .5 M = 127 K = 16 L = 2 taps = filters.get_frequency_domain_filter('rrc', alpha, M, K, L) data = np.array([], dtype=np.complex) ref = np.array([], dtype=np.complex) for i in xrange(reps): d = utils.get_random_qpsk(M * K) ref = np.append(ref, gfdm_demodulate_block(d, taps, K, M, L)) data = np.append(data, d) # print data # print ref # print "MAXIMUM ref value: ", np.max(abs(ref)) src = blocks.vector_source_c(data) est_data = np.ones(len(data), dtype=np.complex) est_src = blocks.vector_source_c(est_data) gfdm_constellation = digital.constellation_qpsk().base() mod = gfdm.advanced_receiver_sb_cc(M, K, L, 0, taps, gfdm_constellation, np.arange(K)) dst = blocks.vector_sink_c() self.tb.connect(src, (mod, 0), dst) self.tb.connect(est_src, (mod, 1)) # set up fg self.tb.run() # check data res = np.array(dst.data()) self.assertComplexTuplesAlmostEqual(ref, res, 4)
def test_002_t(self): n_frames = 1 self.gfdm_var = gfdm_var = struct({'subcarriers': 64, 'timeslots': 9, 'alpha': 0.5, 'overlap': 2,}) self.gfdm_constellation = gfdm_constellation = digital.constellation_qpsk().base() self.f_taps = f_taps = filters.get_frequency_domain_filter('rrc', 1.0, gfdm_var.timeslots, gfdm_var.subcarriers, gfdm_var.overlap) self.random_bits = blocks.vector_source_b(map(int, np.random.randint(0, len(gfdm_constellation.points()), n_frames * gfdm_var.timeslots * gfdm_var.subcarriers)), False) self.bits_to_symbols = digital.chunks_to_symbols_bc((gfdm_constellation.points()), 1) self.mod = gfdm.simple_modulator_cc(gfdm_var.timeslots, gfdm_var.subcarriers, gfdm_var.overlap, f_taps) self.demod = gfdm.advanced_receiver_sb_cc(gfdm_var.timeslots, gfdm_var.subcarriers, gfdm_var.overlap, 64, f_taps, gfdm_constellation, np.arange(gfdm_var.subcarriers)) self.tx_symbols = blocks.vector_sink_c() self.rx_symbols = blocks.vector_sink_c() self.tb.connect((self.random_bits, 0), (self.bits_to_symbols, 0)) self.tb.connect((self.bits_to_symbols, 0), (self.tx_symbols, 0)) self.tb.connect((self.bits_to_symbols, 0), (self.mod, 0)) self.tb.connect((self.mod, 0), (self.demod, 0)) self.tb.connect((self.demod, 0), (self.rx_symbols, 0)) self.tb.run() ref = np.array(self.tx_symbols.data()) res = np.array(self.rx_symbols.data()) # more or less make sure all symbols have their correct sign. self.assertComplexTuplesAlmostEqual(ref, res, 2)
def test_002_big_data(self): print("big data test") reps = 5 alpha = .5 M = 127 K = 16 L = 2 taps = get_frequency_domain_filter('rrc', alpha, M, K, L) data = np.array([], dtype=np.complex) ref = np.array([], dtype=np.complex) for i in xrange(reps): d = get_random_qpsk(M * K) ref = np.append(ref, gfdm_demodulate_block(d, taps, K, M, L)) data = np.append(data, d) # print data # print ref # print "MAXIMUM ref value: ", np.max(abs(ref)) src = blocks.vector_source_c(data) mod = gfdm.simple_receiver_cc(M, K, L, taps) dst = blocks.vector_sink_c() self.tb.connect(src, mod, dst) # set up fg self.tb.run() # check data res = np.array(dst.data()) self.assertComplexTuplesAlmostEqual(ref, res, 4)
def test_002_big_data(self): print("big data test") reps = 5 alpha = .5 M = 127 K = 16 L = 2 taps = get_frequency_domain_filter('rrc', alpha, M, K, L) data = np.array([], dtype=complex) ref = np.array([], dtype=complex) for i in range(reps): d = get_random_qpsk(M * K) ref = np.append(ref, gfdm_demodulate_block(d, taps, K, M, L)) data = np.append(data, d) src = blocks.vector_source_c(data) mod = gfdm.simple_receiver_cc(M, K, L, taps) dst = blocks.vector_sink_c() self.tb.connect(src, mod, dst) # set up fg self.tb.run() # check data res = np.array(dst.data()) self.assertComplexTuplesAlmostEqual(ref, res, 4)
def test_001_t(self): nsubcarrier = 4 ntimeslots = 16 filter_alpha = 0.35 tag_key = "frame_len" fft_length = nsubcarrier * ntimeslots taps = get_frequency_domain_filter('rrc', filter_alpha, ntimeslots, nsubcarrier, 2) data = get_random_qpsk(nsubcarrier * ntimeslots) D = get_data_matrix(data, nsubcarrier, group_by_subcarrier=False) print D md = gfdms.modulator_cc(nsubcarrier, ntimeslots, filter_alpha, fft_length, 1, tag_key) tagger = blocks.stream_to_tagged_stream(gr.sizeof_gr_complex, 1, fft_length, tag_key) src = blocks.vector_source_c(data) dst = blocks.vector_sink_c() self.tb.connect(src, tagger, md, dst) self.tb.run() res = np.array(dst.data()) print res ref = gfdm_modulate_block(D, taps, ntimeslots, nsubcarrier, 2, True) print ref self.assertComplexTuplesAlmostEqual(ref, res, 2)
def test_001_t(self): nsubcarrier = 4 ntimeslots = 16 filter_alpha = 0.35 tag_key = "frame_len" fft_length = nsubcarrier * ntimeslots taps = get_frequency_domain_filter('rrc', filter_alpha, ntimeslots, nsubcarrier, 2) data = get_random_qpsk(nsubcarrier * ntimeslots) # data = np.zeros(nsubcarrier) # data[0] = 1 # data = np.repeat(data, ntimeslots) D = get_data_matrix(data, nsubcarrier, group_by_subcarrier=False) print D md = gfdms.modulator_cc(nsubcarrier, ntimeslots, filter_alpha, fft_length, 1, tag_key) tagger = blocks.stream_to_tagged_stream(gr.sizeof_gr_complex, 1, fft_length, tag_key) src = blocks.vector_source_c(data) dst = blocks.vector_sink_c() self.tb.connect(src, tagger, md, dst) self.tb.run() res = np.array(dst.data()) print res ref = gfdm_modulate_block(D, taps, ntimeslots, nsubcarrier, 2, True) print ref self.assertComplexTuplesAlmostEqual(ref, res, 2)
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 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_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 modulator_test(): fft_len = 128 timeslots = 205 overlap = 2 taps = get_frequency_domain_filter('rrc', .5, timeslots, fft_len, overlap) kernel = cgfdm.py_modulator_kernel_cc(timeslots, fft_len, overlap, taps) N = 10 for i in range(N): data = np.random.randn(2, fft_len * timeslots) data = data[0] + 1j * data[1] data = data.astype(dtype=np.complex64) kernel.modulate(data)
def modulator_test(): fft_len = 128 timeslots = 205 overlap = 2 taps = get_frequency_domain_filter('rrc', .5, timeslots, fft_len, overlap) kernel = cgfdm.py_modulator_kernel_cc(timeslots, fft_len, overlap, taps) N = 10 for i in range(N): data = np.random.randn(2, fft_len * timeslots) data = data[0] + 1j * data[1] data = data.astype(dtype=np.complex64) kernel.modulate(data)
def test_001_t(self): np.set_printoptions(precision=2) n_frames = 3 alpha = .5 M = 8 K = 4 L = 2 cp_len = 8 ramp_len = 4 block_len = M * K window_len = get_window_len(cp_len, M, K) taps = get_frequency_domain_filter('rrc', alpha, M, K, L) 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) ref = np.array([], dtype=np.complex) data = np.array([], dtype=np.complex) for i in range(n_frames): d = get_random_qpsk(block_len) D = get_data_matrix(d, K, group_by_subcarrier=False) b = gfdm_modulate_block(D, taps, M, K, L, False) b = add_cyclic_prefix(b, cp_len) b = pinch_block(b, window_taps) ref = np.concatenate((ref, preamble, b)) data = np.concatenate((data, d)) src = blocks.vector_source_c(data) mod = gfdm.simple_modulator_cc(M, K, L, taps) prefixer = gfdm.cyclic_prefixer_cc(cp_len, ramp_len, block_len, window_taps) preambler = blocks.vector_insert_c(preamble, window_len + len(preamble), 0) dst = blocks.vector_sink_c() self.tb.connect(src, mod, prefixer, preambler, dst) self.tb.run() res = np.array(dst.data())[0:len(ref)] self.assertComplexTuplesAlmostEqual(ref, res, 5)
def modulate_gfdm_frame(tx_symbols, params): mapper = cgfdm.py_resource_mapper_kernel_cc(params['timeslots'], params['fft_len'], params['active_subcarriers'], params['subcarrier_map']) taps = get_frequency_domain_filter(params['prototype_type'], params['prototype_alpha'], params['timeslots'], params['fft_len'], params['overlap']) kernel = cgfdm.py_modulator_kernel_cc(params['timeslots'], params['fft_len'], params['overlap'], taps) win_filt = get_raised_cosine_ramp(params['filter_len'], params['timeslots'] * params['fft_len'] + params['cp_len']) cpler = cgfdm.py_add_cyclic_prefix_cc(params['timeslots'] * params['fft_len'], params['cp_len'], params['filter_len'], win_filt) syms = mapper.map_to_resources(tx_symbols) frame = kernel.modulate(syms.flatten()) frame = cpler.add_cyclic_prefix(frame) return frame
def modulate_gfdm_frame(tx_symbols, params): mapper = cgfdm.py_resource_mapper_kernel_cc(params['timeslots'], params['fft_len'], params['active_subcarriers'], params['subcarrier_map']) taps = get_frequency_domain_filter(params['prototype_type'], params['prototype_alpha'], params['timeslots'], params['fft_len'], params['overlap']) kernel = cgfdm.py_modulator_kernel_cc(params['timeslots'], params['fft_len'], params['overlap'], taps) win_filt = get_raised_cosine_ramp(params['filter_len'], params['timeslots'] * params['fft_len'] + params['cp_len']) cpler = cgfdm.py_add_cyclic_prefix_cc(params['timeslots'] * params['fft_len'], params['cp_len'], params['filter_len'], win_filt) syms = mapper.map_to_resources(tx_symbols) frame = kernel.modulate(syms.flatten()) frame = cpler.add_cyclic_prefix(frame) return frame
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_001_init(self): timeslots = 25 subcarriers = 96 overlap = 2 filter_alpha = 0.35 taps = get_frequency_domain_filter("rrc", filter_alpha, timeslots, subcarriers, overlap) demod = Demodulator(timeslots, subcarriers, overlap, taps) self.assertEqual(timeslots, demod.timeslots()) self.assertEqual(subcarriers, demod.subcarriers()) self.assertEqual(overlap, demod.overlap()) self.assertEqual(timeslots * subcarriers, demod.block_size()) self.assertComplexTuplesAlmostEqual(taps, demod.filter_taps())
def test_002_fd_filter(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.params.pulse = 'rrc' taps = vc.gfdmutil.get_transmitter_pulse(self.params) g2 = taps[::self.params.K // self.params.L] G2 = np.fft.fft(g2) freq_taps = get_frequency_domain_filter('rrc', self.params.a, self.params.M, self.params.K, self.params.L) freq_taps *= np.abs(G2[0]) / np.abs(freq_taps[0]) self.assertTrue(np.all(np.abs(freq_taps - G2) < 1e-3))
def test_002_fd_filter(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.params.pulse = 'rrc' taps = vc.gfdmutil.get_transmitter_pulse(self.params) g2 = taps[::self.params.K // self.params.L] G2 = np.fft.fft(g2) freq_taps = get_frequency_domain_filter('rrc', self.params.a, self.params.M, self.params.K, self.params.L) freq_taps *= np.abs(G2[0]) / np.abs(freq_taps[0]) self.assertTrue(np.all(np.abs(freq_taps - G2) < 1e-3))
def test_002_t(self): n_frames = 1 gfdm_var = struct({ "subcarriers": 64, "timeslots": 9, "alpha": 0.5, "overlap": 2, }) gfdm_constellation = digital.constellation_qpsk().base() self.f_taps = f_taps = filters.get_frequency_domain_filter( "rrc", 1.0, gfdm_var.timeslots, gfdm_var.subcarriers, gfdm_var.overlap) source_bits = np.random.randint( 0, len(gfdm_constellation.points()), n_frames * gfdm_var.timeslots * gfdm_var.subcarriers, ).astype(np.uint8) self.random_bits = blocks.vector_source_b(source_bits, False) self.bits_to_symbols = digital.chunks_to_symbols_bc( (gfdm_constellation.points()), 1) self.mod = gfdm.simple_modulator_cc(gfdm_var.timeslots, gfdm_var.subcarriers, gfdm_var.overlap, f_taps) self.demod = gfdm.advanced_receiver_sb_cc( gfdm_var.timeslots, gfdm_var.subcarriers, gfdm_var.overlap, 64, f_taps, gfdm_constellation, np.arange(gfdm_var.subcarriers), 0, ) self.tx_symbols = blocks.vector_sink_c() self.rx_symbols = blocks.vector_sink_c() self.tb.connect((self.random_bits, 0), (self.bits_to_symbols, 0)) self.tb.connect((self.bits_to_symbols, 0), (self.tx_symbols, 0)) self.tb.connect((self.bits_to_symbols, 0), (self.mod, 0)) self.tb.connect((self.mod, 0), (self.demod, 0)) self.tb.connect((self.demod, 0), (self.rx_symbols, 0)) self.tb.run() ref = np.array(self.tx_symbols.data()) res = np.array(self.rx_symbols.data()) # more or less make sure all symbols have their correct sign. self.assertComplexTuplesAlmostEqual(ref, res, 2)
def test_002_big(self): timeslots = 21 subcarriers = 128 overlap = 2 filter_alpha = 0.35 taps = get_frequency_domain_filter("rrc", filter_alpha, timeslots, subcarriers, overlap) data = get_random_qpsk(timeslots * subcarriers) D = get_data_matrix(data, subcarriers, group_by_subcarrier=False) ref = gfdm_modulate_block(D, taps, timeslots, subcarriers, overlap, False) mod = Modulator(timeslots, subcarriers, overlap, taps) res = mod.modulate(data) self.assertComplexTuplesAlmostEqual(ref, 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_002_small(self): timeslots = 16 subcarriers = 4 overlap = 2 filter_alpha = 0.35 taps = get_frequency_domain_filter("rrc", filter_alpha, timeslots, subcarriers, overlap) data = get_random_qpsk(timeslots * subcarriers) D = get_data_matrix(data, subcarriers, group_by_subcarrier=False) frame = gfdm_modulate_block(D, taps, timeslots, subcarriers, overlap, False) ref = gfdm_demodulate_block(frame, taps, subcarriers, timeslots, overlap) demod = Demodulator(timeslots, subcarriers, overlap, taps) res = demod.demodulate(frame) self.assertComplexTuplesAlmostEqual(ref, res, 6)
def test_001_t(self): alpha = .5 M = 8 K = 4 L = 2 taps = get_frequency_domain_filter('rrc', alpha, M, K, L) taps /= np.sqrt(calculate_signal_energy(taps) / M) data = get_random_qpsk(M * K) src = blocks.vector_source_c(data) mod = gfdm.simple_receiver_cc(M, K, L, taps) dst = blocks.vector_sink_c() self.tb.connect(src, mod, dst) self.tb.run() res = np.array(dst.data()) ref = gfdm_demodulate_block(data, taps, K, M, L) res *= np.sqrt( calculate_signal_energy(ref) / calculate_signal_energy(res)) self.assertComplexTuplesAlmostEqual(ref, res, 5)
def test_001_t(self): alpha = .5 M = 8 K = 4 L = 2 taps = get_frequency_domain_filter('rrc', alpha, M, K, L) taps /= np.sqrt(calculate_signal_energy(taps) / M) data = get_random_qpsk(M * K) src = blocks.vector_source_c(data) mod = gfdm.simple_receiver_cc(M, K, L, taps) dst = blocks.vector_sink_c() self.tb.connect(src, mod, dst) self.tb.run() res = np.array(dst.data()) ref = gfdm_demodulate_block(data, taps, K, M, L) # print calculate_signal_energy(ref), calculate_signal_energy(res) res *= np.sqrt(calculate_signal_energy(ref) / calculate_signal_energy(res)) self.assertComplexTuplesAlmostEqual(ref, res, 5)
def test_004_big_equalize(self): timeslots = 21 subcarriers = 128 overlap = 2 filter_alpha = 0.35 taps = get_frequency_domain_filter("rrc", filter_alpha, timeslots, subcarriers, overlap) data = get_random_qpsk(timeslots * subcarriers) D = get_data_matrix(data, subcarriers, group_by_subcarrier=False) frame = gfdm_modulate_block(D, taps, timeslots, subcarriers, overlap, False) ref = gfdm_demodulate_block(frame, taps, subcarriers, timeslots, overlap) eq_vals = np.ones(ref.size, ref.dtype) * np.exp(1.0j) demod = Demodulator(timeslots, subcarriers, overlap, taps) res = demod.demodulate_equalize(frame * np.exp(1.0j), eq_vals) self.assertComplexTuplesAlmostEqual(ref, res, 5)
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 test_006_steps_equalize(self): timeslots = 5 subcarriers = 32 overlap = 2 filter_alpha = 0.35 taps = get_frequency_domain_filter('rrc', filter_alpha, timeslots, subcarriers, overlap) data = get_random_qpsk(timeslots * subcarriers) D = get_data_matrix(data, subcarriers, group_by_subcarrier=False) frame = gfdm_modulate_block(D, taps, timeslots, subcarriers, overlap, False) ref = gfdm_demodulate_block( frame, taps, subcarriers, timeslots, overlap) eq_vals = np.ones(ref.size, ref.dtype) * np.exp(1.j) demod = Demodulator(timeslots, subcarriers, overlap, taps) fd_res = demod.fft_equalize_filter_downsample( frame * np.exp(1.j), eq_vals) res = demod.transform_subcarriers_to_td(fd_res) self.assertComplexTuplesAlmostEqual(ref, res, 5)