Example #1
0
    def test_003_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)
        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, 5)
Example #2
0
    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)
Example #3
0
    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.j)

        demod = Demodulator(timeslots, subcarriers, overlap, taps)
        res = demod.demodulate_equalize(frame * np.exp(1.j), eq_vals)

        self.assertComplexTuplesAlmostEqual(ref, res, 5)
Example #4
0
    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.0j)

        demod = Demodulator(timeslots, subcarriers, overlap, taps)
        fd_res = demod.fft_equalize_filter_downsample(frame * np.exp(1.0j),
                                                      eq_vals)
        res = demod.transform_subcarriers_to_td(fd_res)

        self.assertComplexTuplesAlmostEqual(ref, res, 5)
Example #5
0
    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())