def setUp(self):
        """Called before each test."""
        root_seq_no_ext1 = RootSequence(root_index=25, Nzc=139)
        self.user_seq_no_ext1 = SrsUeSequence(
            root_seq=root_seq_no_ext1, n_cs=3)

        root_seq_no_ext2 = RootSequence(root_index=6, Nzc=31)
        self.user_seq_no_ext2 = SrsUeSequence(
            root_seq=root_seq_no_ext2, n_cs=1)
        self.user_seq_no_ext2_other = SrsUeSequence(
            root_seq=root_seq_no_ext2, n_cs=3)

        root_seq1 = RootSequence(root_index=25, size=150, Nzc=139)
        self.user_seq1 = SrsUeSequence(root_seq=root_seq1, n_cs=7)

        root_seq2 = RootSequence(root_index=12, size=150, Nzc=139)
        self.user_seq2 = SrsUeSequence(root_seq=root_seq2, n_cs=4)

        root_seq3 = RootSequence(root_index=25, size=64, Nzc=31)
        self.user_seq3 = SrsUeSequence(root_seq=root_seq3, n_cs=1)

        root_seq4 = RootSequence(root_index=6, size=64, Nzc=31)
        self.user_seq4 = SrsUeSequence(root_seq=root_seq4, n_cs=2)

        root_seq5 = RootSequence(root_index=6, size=32, Nzc=31)
        self.user_seq5 = SrsUeSequence(root_seq=root_seq5, n_cs=3)

        root_seq6 = RootSequence(root_index=6, size=256, Nzc=31)
        self.user_seq6 = SrsUeSequence(root_seq=root_seq6, n_cs=5)
Example #2
0
    def test_estimate_channel_multiple_rx(self):
        Nsc = 300  # 300 subcarriers
        size = Nsc // 2
        Nzc = 139

        user1_seq = SrsUeSequence(RootSequence(root_index=25,
                                               size=size,
                                               Nzc=Nzc),
                                  1,
                                  normalize=True)
        user2_seq = SrsUeSequence(RootSequence(root_index=25,
                                               size=size,
                                               Nzc=Nzc),
                                  4,
                                  normalize=True)

        ue1_channel_estimator = CazacBasedChannelEstimator(user1_seq)

        speed_terminal = 3 / 3.6  # Speed in m/s
        fcDbl = 2.6e9  # Central carrier frequency (in Hz)
        subcarrier_bandwidth = 15e3  # Subcarrier bandwidth (in Hz)
        wave_length = 3e8 / fcDbl  # Carrier wave length
        Fd = speed_terminal / wave_length  # Doppler Frequency
        Ts = 1. / (Nsc * subcarrier_bandwidth)  # Sampling interval
        L = 16  # Number of jakes taps

        # Create the fading generators and set multiple receive antennas
        jakes1 = JakesSampleGenerator(Fd, Ts, L, shape=(3, 1))
        jakes2 = JakesSampleGenerator(Fd, Ts, L, shape=(3, 1))

        # Create a TDL channel object for each user
        tdlchannel1 = TdlChannel(jakes1, channel_profile=COST259_TUx)
        tdlchannel2 = TdlChannel(jakes2, channel_profile=COST259_TUx)

        # Generate channel that would corrupt the transmit signal.
        tdlchannel1.generate_impulse_response(1)
        tdlchannel2.generate_impulse_response(1)

        # Get the generated impulse response
        impulse_response1 = tdlchannel1.get_last_impulse_response()
        impulse_response2 = tdlchannel2.get_last_impulse_response()

        # Get the corresponding frequency response
        freq_resp_1 = impulse_response1.get_freq_response(Nsc)
        H1 = freq_resp_1[:, :, 0, 0]
        freq_resp_2 = impulse_response2.get_freq_response(Nsc)
        H2 = freq_resp_2[:, :, 0, 0]

        # Sequence of the users
        r1 = user1_seq.seq_array()
        r2 = user2_seq.seq_array()

        # Received signal (in frequency domain) of user 1
        comb_indexes = np.arange(0, Nsc, 2)
        Y1 = H1[comb_indexes, :] * r1[:, np.newaxis]
        Y2 = H2[comb_indexes, :] * r2[:, np.newaxis]
        Y = Y1 + Y2

        # Calculate expected estimated channel for user 1
        y1 = np.fft.ifft(r1.size * np.conj(r1[:, np.newaxis]) * Y,
                         size,
                         axis=0)
        tilde_h1_espected = y1[0:16]
        tilde_H1_espected = np.fft.fft(tilde_h1_espected, Nsc, axis=0)

        # Test the CazacBasedChannelEstimator estimation
        H1_estimated = ue1_channel_estimator.estimate_channel_freq_domain(
            Y.T, 15)
        np.testing.assert_array_almost_equal(H1_estimated, tilde_H1_espected.T)

        # Test if true channel and estimated channel are similar. Since the
        # channel estimation error is higher at the first and last
        # subcarriers we will test only the inner 200 subcarriers
        error = np.abs(H1[50:-50, :] - tilde_H1_espected[50:-50, :])
        ":type: np.ndarray"

        np.testing.assert_almost_equal(error / 2.,
                                       np.zeros(error.shape),
                                       decimal=2)
Example #3
0
    def test_estimate_channel_without_comb_pattern(self):
        Nsc = 300  # 300 subcarriers
        size = Nsc  # The size is also 300, since there is no comb pattern
        Nzc = 139

        user1_seq = SrsUeSequence(
            RootSequence(root_index=25, size=size, Nzc=Nzc), 1)
        user2_seq = SrsUeSequence(
            RootSequence(root_index=25, size=size, Nzc=Nzc), 4)

        # Set size_multiplier to 1, since we won't use the comb pattern
        ue1_channel_estimator = CazacBasedChannelEstimator(user1_seq,
                                                           size_multiplier=1)

        speed_terminal = 3 / 3.6  # Speed in m/s
        fcDbl = 2.6e9  # Central carrier frequency (in Hz)
        subcarrier_bandwidth = 15e3  # Subcarrier bandwidth (in Hz)
        wave_length = 3e8 / fcDbl  # Carrier wave length
        Fd = speed_terminal / wave_length  # Doppler Frequency
        Ts = 1. / (Nsc * subcarrier_bandwidth)  # Sampling interval
        L = 16  # Number of jakes taps

        jakes1 = JakesSampleGenerator(Fd, Ts, L)
        jakes2 = JakesSampleGenerator(Fd, Ts, L)

        # Create a TDL channel object for each user
        tdlchannel1 = TdlChannel(jakes1, channel_profile=COST259_TUx)
        tdlchannel2 = TdlChannel(jakes2, channel_profile=COST259_TUx)

        # Generate channel that would corrupt the transmit signal.
        tdlchannel1.generate_impulse_response(1)
        tdlchannel2.generate_impulse_response(1)

        # Get the generated impulse response
        impulse_response1 = tdlchannel1.get_last_impulse_response()
        impulse_response2 = tdlchannel2.get_last_impulse_response()

        # Get the corresponding frequency response
        freq_resp_1 = impulse_response1.get_freq_response(Nsc)
        H1 = freq_resp_1[:, 0]
        freq_resp_2 = impulse_response2.get_freq_response(Nsc)
        H2 = freq_resp_2[:, 0]

        # Sequence of the users
        r1 = user1_seq.seq_array()
        r2 = user2_seq.seq_array()

        # Received signal (in frequency domain) of user 1
        Y1 = H1 * r1
        Y2 = H2 * r2
        Y = Y1 + Y2

        # Calculate expected estimated channel for user 1
        y1 = np.fft.ifft(np.conj(r1) * Y, size)
        tilde_h1 = y1[0:16]
        tilde_H1 = np.fft.fft(tilde_h1, Nsc)

        # Test the CazacBasedChannelEstimator estimation
        np.testing.assert_array_almost_equal(
            ue1_channel_estimator.estimate_channel_freq_domain(Y, 15),
            tilde_H1)

        # Test if true channel and estimated channel are similar. Since the
        # channel estimation error is higher at the first and last
        # subcarriers we will test only the inner 200 subcarriers
        error = np.abs(H1[50:-50] - tilde_H1[50:-50])
        ":type: np.ndarray"

        np.testing.assert_almost_equal(error / 2.,
                                       np.zeros(error.size),
                                       decimal=2)
Example #4
0
    def test_estimate_channel_with_srs(self):
        Nsc = 300  # 300 subcarriers
        size = Nsc // 2
        Nzc = 139

        user1_seq = SrsUeSequence(RootSequence(root_index=25,
                                               size=size,
                                               Nzc=Nzc),
                                  1,
                                  normalize=True)
        user2_seq = SrsUeSequence(RootSequence(root_index=25,
                                               size=size,
                                               Nzc=Nzc),
                                  4,
                                  normalize=True)

        ue1_channel_estimator = CazacBasedChannelEstimator(user1_seq)
        ue2_channel_estimator = CazacBasedChannelEstimator(user2_seq)

        speed_terminal = 3 / 3.6  # Speed in m/s
        fcDbl = 2.6e9  # Central carrier frequency (in Hz)
        subcarrier_bandwidth = 15e3  # Subcarrier bandwidth (in Hz)
        wave_length = 3e8 / fcDbl  # Carrier wave length
        Fd = speed_terminal / wave_length  # Doppler Frequency
        Ts = 1. / (Nsc * subcarrier_bandwidth)  # Sampling interval
        L = 16  # Number of jakes taps

        jakes1 = JakesSampleGenerator(Fd, Ts, L)
        jakes2 = JakesSampleGenerator(Fd, Ts, L)

        # Create a TDL channel object for each user
        tdlchannel1 = TdlChannel(jakes1, channel_profile=COST259_TUx)
        tdlchannel2 = TdlChannel(jakes2, channel_profile=COST259_TUx)

        # Generate channel that would corrupt the transmit signal.
        tdlchannel1.generate_impulse_response(1)
        tdlchannel2.generate_impulse_response(1)

        # Get the generated impulse response
        impulse_response1 = tdlchannel1.get_last_impulse_response()
        impulse_response2 = tdlchannel2.get_last_impulse_response()

        # Get the corresponding frequency response
        freq_resp_1 = impulse_response1.get_freq_response(Nsc)
        H1 = freq_resp_1[:, 0]
        freq_resp_2 = impulse_response2.get_freq_response(Nsc)
        H2 = freq_resp_2[:, 0]

        # Sequence of the users
        r1 = user1_seq.seq_array()
        r2 = user2_seq.seq_array()

        # Received signal (in frequency domain) of user 1
        comb_indexes = np.arange(0, Nsc, 2)
        Y1 = H1[comb_indexes] * r1
        Y2 = H2[comb_indexes] * r2
        Y = Y1 + Y2

        # xxxxxxxxxx USER 1 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
        # Calculate expected estimated channel for user 1
        y1 = np.fft.ifft(r1.size * np.conj(r1) * Y, size)
        tilde_h1 = y1[0:16]
        tilde_H1 = np.fft.fft(tilde_h1, Nsc)

        # Test the CazacBasedChannelEstimator estimation
        np.testing.assert_array_almost_equal(
            ue1_channel_estimator.estimate_channel_freq_domain(Y, 15),
            tilde_H1)

        # Check that the estimated channel and the True channel have similar
        # norms
        self.assertAlmostEqual(np.linalg.norm(
            ue1_channel_estimator.estimate_channel_freq_domain(Y, 15)),
                               np.linalg.norm(H1),
                               delta=0.5)

        # Test if true channel and estimated channel are similar. Since the
        # channel estimation error is higher at the first and last
        # subcarriers we will test only the inner 200 subcarriers
        error = np.abs(H1[50:-50] - tilde_H1[50:-50])
        ":type: np.ndarray"

        np.testing.assert_almost_equal(error / 2.,
                                       np.zeros(error.size),
                                       decimal=2)
        # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

        # xxxxxxxxxx USER 2 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
        # Calculate expected estimated channel for user 2
        y2 = np.fft.ifft(r2.size * np.conj(r2) * Y, size)
        tilde_h2 = y2[0:16]
        tilde_H2 = np.fft.fft(tilde_h2, Nsc)

        # Test the CazacBasedChannelEstimator estimation
        np.testing.assert_array_almost_equal(
            ue2_channel_estimator.estimate_channel_freq_domain(Y, 15),
            tilde_H2)

        # Check that the estimated channel and the True channel have similar
        # norms
        self.assertAlmostEqual(np.linalg.norm(
            ue2_channel_estimator.estimate_channel_freq_domain(Y, 15)),
                               np.linalg.norm(H2),
                               delta=0.5)

        # Test if true channel and estimated channel are similar. Since the
        # channel estimation error is higher at the first and last
        # subcarriers we will test only the inner 200 subcarriers
        error = np.abs(H2[50:-50] - tilde_H2[50:-50])
        ":type: np.ndarray"

        np.testing.assert_almost_equal(error / 2.,
                                       np.zeros(error.size),
                                       decimal=2)
Example #5
0
    def setUp(self):
        """Called before each test."""
        root_seq_no_ext1 = RootSequence(root_index=25, Nzc=139)
        self.user_seq_no_ext1 = SrsUeSequence(root_seq=root_seq_no_ext1,
                                              n_cs=3)

        root_seq_no_ext2 = RootSequence(root_index=6, Nzc=31)
        self.user_seq_no_ext2 = SrsUeSequence(root_seq=root_seq_no_ext2,
                                              n_cs=1)
        self.user_seq_no_ext2_other = SrsUeSequence(root_seq=root_seq_no_ext2,
                                                    n_cs=3)

        root_seq1 = RootSequence(root_index=25, size=150, Nzc=139)
        self.user_seq1 = SrsUeSequence(root_seq=root_seq1, n_cs=7)

        root_seq2 = RootSequence(root_index=12, size=150, Nzc=139)
        self.user_seq2 = SrsUeSequence(root_seq=root_seq2, n_cs=4)

        root_seq3 = RootSequence(root_index=25, size=64, Nzc=31)
        self.user_seq3 = SrsUeSequence(root_seq=root_seq3, n_cs=1)

        root_seq4 = RootSequence(root_index=6, size=64, Nzc=31)
        self.user_seq4 = SrsUeSequence(root_seq=root_seq4, n_cs=2)

        root_seq5 = RootSequence(root_index=6, size=32, Nzc=31)
        self.user_seq5 = SrsUeSequence(root_seq=root_seq5, n_cs=3)

        root_seq6 = RootSequence(root_index=6, size=256, Nzc=31)
        self.user_seq6 = SrsUeSequence(root_seq=root_seq6, n_cs=5)
Example #6
0
class SrsUeSequenceTestCase(unittest.TestCase):
    def setUp(self):
        """Called before each test."""
        root_seq_no_ext1 = RootSequence(root_index=25, Nzc=139)
        self.user_seq_no_ext1 = SrsUeSequence(root_seq=root_seq_no_ext1,
                                              n_cs=3)

        root_seq_no_ext2 = RootSequence(root_index=6, Nzc=31)
        self.user_seq_no_ext2 = SrsUeSequence(root_seq=root_seq_no_ext2,
                                              n_cs=1)
        self.user_seq_no_ext2_other = SrsUeSequence(root_seq=root_seq_no_ext2,
                                                    n_cs=3)

        root_seq1 = RootSequence(root_index=25, size=150, Nzc=139)
        self.user_seq1 = SrsUeSequence(root_seq=root_seq1, n_cs=7)

        root_seq2 = RootSequence(root_index=12, size=150, Nzc=139)
        self.user_seq2 = SrsUeSequence(root_seq=root_seq2, n_cs=4)

        root_seq3 = RootSequence(root_index=25, size=64, Nzc=31)
        self.user_seq3 = SrsUeSequence(root_seq=root_seq3, n_cs=1)

        root_seq4 = RootSequence(root_index=6, size=64, Nzc=31)
        self.user_seq4 = SrsUeSequence(root_seq=root_seq4, n_cs=2)

        root_seq5 = RootSequence(root_index=6, size=32, Nzc=31)
        self.user_seq5 = SrsUeSequence(root_seq=root_seq5, n_cs=3)

        root_seq6 = RootSequence(root_index=6, size=256, Nzc=31)
        self.user_seq6 = SrsUeSequence(root_seq=root_seq6, n_cs=5)

    def test_size(self):
        self.assertEqual(self.user_seq_no_ext1.size, 139)
        self.assertEqual(self.user_seq_no_ext2.size, 31)
        self.assertEqual(self.user_seq1.size, 150)
        self.assertEqual(self.user_seq2.size, 150)
        self.assertEqual(self.user_seq3.size, 64)
        self.assertEqual(self.user_seq4.size, 64)
        self.assertEqual(self.user_seq5.size, 32)
        self.assertEqual(self.user_seq6.size, 256)

    def test_shape(self):
        self.assertEqual(self.user_seq_no_ext1.shape, (139, ))
        self.assertEqual(self.user_seq_no_ext2.shape, (31, ))
        self.assertEqual(self.user_seq1.shape, (150, ))
        self.assertEqual(self.user_seq2.shape, (150, ))
        self.assertEqual(self.user_seq3.shape, (64, ))
        self.assertEqual(self.user_seq4.shape, (64, ))
        self.assertEqual(self.user_seq5.shape, (32, ))
        self.assertEqual(self.user_seq6.shape, (256, ))

    def test_seq_array(self):
        # calcBaseZC, get_srs_seq, get_extended_ZF

        expected_user_seq_no_ext1 = get_srs_seq(calcBaseZC(139, 25), 3)
        np.testing.assert_array_almost_equal(expected_user_seq_no_ext1,
                                             self.user_seq_no_ext1.seq_array())
        expected_user_seq_no_ext2 = get_srs_seq(calcBaseZC(31, 6), 1)
        np.testing.assert_array_almost_equal(expected_user_seq_no_ext2,
                                             self.user_seq_no_ext2.seq_array())
        expected_user_seq_no_ext2_other_shift = get_srs_seq(
            calcBaseZC(31, 6), 3)
        np.testing.assert_array_almost_equal(
            expected_user_seq_no_ext2_other_shift,
            self.user_seq_no_ext2_other.seq_array())

        expected_user_seq1 = get_srs_seq(
            get_extended_ZF(calcBaseZC(139, 25), 150), 7)
        np.testing.assert_array_almost_equal(self.user_seq1.seq_array(),
                                             expected_user_seq1)
        expected_user_seq2 = get_srs_seq(
            get_extended_ZF(calcBaseZC(139, 12), 150), 4)
        np.testing.assert_array_almost_equal(self.user_seq2.seq_array(),
                                             expected_user_seq2)
        expected_user_seq3 = get_srs_seq(
            get_extended_ZF(calcBaseZC(31, 25), 64), 1)
        np.testing.assert_array_almost_equal(self.user_seq3.seq_array(),
                                             expected_user_seq3)
        expected_user_seq4 = get_srs_seq(
            get_extended_ZF(calcBaseZC(31, 6), 64), 2)
        np.testing.assert_array_almost_equal(self.user_seq4.seq_array(),
                                             expected_user_seq4)
        expected_user_seq5 = get_srs_seq(
            get_extended_ZF(calcBaseZC(31, 6), 32), 3)
        np.testing.assert_array_almost_equal(self.user_seq5.seq_array(),
                                             expected_user_seq5)
        expected_user_seq6 = get_srs_seq(
            get_extended_ZF(calcBaseZC(31, 6), 256), 5)
        np.testing.assert_array_almost_equal(self.user_seq6.seq_array(),
                                             expected_user_seq6)

    def test_getitem(self):
        seqs = [self.user_seq1, self.user_seq2, self.user_seq3]
        for seq in seqs:
            np.testing.assert_almost_equal(seq[4], seq.seq_array()[4])
            np.testing.assert_almost_equal(seq[3:15], seq.seq_array()[3:15])
            np.testing.assert_almost_equal(seq[3:40:2],
                                           seq.seq_array()[3:40:2])
    def test_estimate_channel_multiple_rx(self):
        Nsc = 300                            # 300 subcarriers
        size = Nsc // 2
        Nzc = 139

        user1_seq = SrsUeSequence(
            RootSequence(root_index=25, size=size, Nzc=Nzc), 1)
        user2_seq = SrsUeSequence(
            RootSequence(root_index=25, size=size, Nzc=Nzc), 4)

        ue1_channel_estimator = CazacBasedChannelEstimator(user1_seq)

        speed_terminal = 3/3.6               # Speed in m/s
        fcDbl = 2.6e9                        # Central carrier frequency (in Hz)
        subcarrier_bandwidth = 15e3          # Subcarrier bandwidth (in Hz)
        wave_length = 3e8/fcDbl              # Carrier wave length
        Fd = speed_terminal / wave_length    # Doppler Frequency
        Ts = 1./(Nsc * subcarrier_bandwidth) # Sampling interval
        L = 16                               # Number of jakes taps

        # Create the fading generators and set multiple receive antennas
        jakes1 = JakesSampleGenerator(Fd, Ts, L, shape=(3, 1))
        jakes2 = JakesSampleGenerator(Fd, Ts, L, shape=(3, 1))

        # Create a TDL channel object for each user
        tdlchannel1 = TdlChannel(jakes1, channel_profile=COST259_TUx)
        tdlchannel2 = TdlChannel(jakes2, channel_profile=COST259_TUx)

        # Generate channel that would corrupt the transmit signal.
        tdlchannel1._generate_impulse_response(1)
        tdlchannel2._generate_impulse_response(1)

        # Get the generated impulse response
        impulse_response1 = tdlchannel1.get_last_impulse_response()
        impulse_response2 = tdlchannel2.get_last_impulse_response()

        # Get the corresponding frequency response
        freq_resp_1 = impulse_response1.get_freq_response(Nsc)
        H1 = freq_resp_1[:, :, 0, 0]
        freq_resp_2 = impulse_response2.get_freq_response(Nsc)
        H2 = freq_resp_2[:, :, 0, 0]

        # Sequence of the users
        r1 = user1_seq.seq_array()
        r2 = user2_seq.seq_array()

        # Received signal (in frequency domain) of user 1
        comb_indexes = np.arange(0, Nsc, 2)
        Y1 = H1[comb_indexes, :] * r1[:, np.newaxis]
        Y2 = H2[comb_indexes, :] * r2[:, np.newaxis]
        Y = Y1 + Y2

        # Calculate expected estimated channel for user 1
        y1 = np.fft.ifft(np.conj(r1[:, np.newaxis]) * Y, size, axis=0)
        tilde_h1_espected = y1[0:16]
        tilde_H1_espected = np.fft.fft(tilde_h1_espected, Nsc, axis=0)

        # Test the CazacBasedChannelEstimator estimation
        H1_estimated = ue1_channel_estimator.estimate_channel_freq_domain(Y.T, 15)
        np.testing.assert_array_almost_equal(
            H1_estimated, tilde_H1_espected.T)

        # Test if true channel and estimated channel are similar. Since the
        # channel estimation error is higher at the first and last
        # subcarriers we will test only the inner 200 subcarriers
        error = np.abs(H1[50:-50, :] - tilde_H1_espected[50:-50, :])
        np.testing.assert_almost_equal(error/2., np.zeros(error.shape), decimal=2)
    def test_estimate_channel_without_comb_pattern(self):
        Nsc = 300   # 300 subcarriers
        size = Nsc  # The size is also 300, since there is no comb pattern
        Nzc = 139

        user1_seq = SrsUeSequence(
            RootSequence(root_index=25, size=size, Nzc=Nzc), 1)
        user2_seq = SrsUeSequence(
            RootSequence(root_index=25, size=size, Nzc=Nzc), 4)

        # Set size_multiplier to 1, since we won't use the comb pattern
        ue1_channel_estimator = CazacBasedChannelEstimator(user1_seq,
                                                           size_multiplier=1)

        speed_terminal = 3/3.6               # Speed in m/s
        fcDbl = 2.6e9                        # Central carrier frequency (in Hz)
        subcarrier_bandwidth = 15e3          # Subcarrier bandwidth (in Hz)
        wave_length = 3e8/fcDbl              # Carrier wave length
        Fd = speed_terminal / wave_length    # Doppler Frequency
        Ts = 1./(Nsc * subcarrier_bandwidth) # Sampling interval
        L = 16                               # Number of jakes taps

        jakes1 = JakesSampleGenerator(Fd, Ts, L)
        jakes2 = JakesSampleGenerator(Fd, Ts, L)

        # Create a TDL channel object for each user
        tdlchannel1 = TdlChannel(jakes1, channel_profile=COST259_TUx)
        tdlchannel2 = TdlChannel(jakes2, channel_profile=COST259_TUx)

        # Generate channel that would corrupt the transmit signal.
        tdlchannel1._generate_impulse_response(1)
        tdlchannel2._generate_impulse_response(1)

        # Get the generated impulse response
        impulse_response1 = tdlchannel1.get_last_impulse_response()
        impulse_response2 = tdlchannel2.get_last_impulse_response()

        # Get the corresponding frequency response
        freq_resp_1 = impulse_response1.get_freq_response(Nsc)
        H1 = freq_resp_1[:, 0]
        freq_resp_2 = impulse_response2.get_freq_response(Nsc)
        H2 = freq_resp_2[:, 0]

        # Sequence of the users
        r1 = user1_seq.seq_array()
        r2 = user2_seq.seq_array()

        # Received signal (in frequency domain) of user 1
        Y1 = H1 * r1
        Y2 = H2 * r2
        Y = Y1 + Y2

        # Calculate expected estimated channel for user 1
        y1 = np.fft.ifft(np.conj(r1) * Y, size)
        tilde_h1 = y1[0:16]
        tilde_H1 = np.fft.fft(tilde_h1, Nsc)

        # Test the CazacBasedChannelEstimator estimation
        np.testing.assert_array_almost_equal(
            ue1_channel_estimator.estimate_channel_freq_domain(Y, 15),
            tilde_H1)

        # Test if true channel and estimated channel are similar. Since the
        # channel estimation error is higher at the first and last
        # subcarriers we will test only the inner 200 subcarriers
        error = np.abs(H1[50:-50] - tilde_H1[50:-50])
        np.testing.assert_almost_equal(error/2., np.zeros(error.size), decimal=2)
class SrsUeSequenceTestCase(unittest.TestCase):
    def setUp(self):
        """Called before each test."""
        root_seq_no_ext1 = RootSequence(root_index=25, Nzc=139)
        self.user_seq_no_ext1 = SrsUeSequence(
            root_seq=root_seq_no_ext1, n_cs=3)

        root_seq_no_ext2 = RootSequence(root_index=6, Nzc=31)
        self.user_seq_no_ext2 = SrsUeSequence(
            root_seq=root_seq_no_ext2, n_cs=1)
        self.user_seq_no_ext2_other = SrsUeSequence(
            root_seq=root_seq_no_ext2, n_cs=3)

        root_seq1 = RootSequence(root_index=25, size=150, Nzc=139)
        self.user_seq1 = SrsUeSequence(root_seq=root_seq1, n_cs=7)

        root_seq2 = RootSequence(root_index=12, size=150, Nzc=139)
        self.user_seq2 = SrsUeSequence(root_seq=root_seq2, n_cs=4)

        root_seq3 = RootSequence(root_index=25, size=64, Nzc=31)
        self.user_seq3 = SrsUeSequence(root_seq=root_seq3, n_cs=1)

        root_seq4 = RootSequence(root_index=6, size=64, Nzc=31)
        self.user_seq4 = SrsUeSequence(root_seq=root_seq4, n_cs=2)

        root_seq5 = RootSequence(root_index=6, size=32, Nzc=31)
        self.user_seq5 = SrsUeSequence(root_seq=root_seq5, n_cs=3)

        root_seq6 = RootSequence(root_index=6, size=256, Nzc=31)
        self.user_seq6 = SrsUeSequence(root_seq=root_seq6, n_cs=5)

    def test_size(self):
        self.assertEqual(self.user_seq_no_ext1.size, 139)
        self.assertEqual(self.user_seq_no_ext2.size, 31)
        self.assertEqual(self.user_seq1.size, 150)
        self.assertEqual(self.user_seq2.size, 150)
        self.assertEqual(self.user_seq3.size, 64)
        self.assertEqual(self.user_seq4.size, 64)
        self.assertEqual(self.user_seq5.size, 32)
        self.assertEqual(self.user_seq6.size, 256)

    def test_seq_array(self):
        # calcBaseZC, get_srs_seq, get_extended_ZF

        expected_user_seq_no_ext1 = get_srs_seq(calcBaseZC(139, 25), 3)
        np.testing.assert_array_almost_equal(expected_user_seq_no_ext1,
                                             self.user_seq_no_ext1.seq_array())
        expected_user_seq_no_ext2 = get_srs_seq(calcBaseZC(31, 6), 1)
        np.testing.assert_array_almost_equal(expected_user_seq_no_ext2,
                                             self.user_seq_no_ext2.seq_array())
        expected_user_seq_no_ext2_other_shift = get_srs_seq(calcBaseZC(31, 6), 3)
        np.testing.assert_array_almost_equal(
            expected_user_seq_no_ext2_other_shift,
            self.user_seq_no_ext2_other.seq_array())

        expected_user_seq1 = get_srs_seq(get_extended_ZF(calcBaseZC(139, 25), 150), 7)
        np.testing.assert_array_almost_equal(self.user_seq1.seq_array(),
                                             expected_user_seq1)
        expected_user_seq2 = get_srs_seq(get_extended_ZF(calcBaseZC(139, 12), 150), 4)
        np.testing.assert_array_almost_equal(self.user_seq2.seq_array(),
                                             expected_user_seq2)
        expected_user_seq3 = get_srs_seq(get_extended_ZF(calcBaseZC(31, 25), 64), 1)
        np.testing.assert_array_almost_equal(self.user_seq3.seq_array(),
                                             expected_user_seq3)
        expected_user_seq4 = get_srs_seq(get_extended_ZF(calcBaseZC(31, 6), 64), 2)
        np.testing.assert_array_almost_equal(self.user_seq4.seq_array(),
                                             expected_user_seq4)
        expected_user_seq5 = get_srs_seq(get_extended_ZF(calcBaseZC(31, 6), 32), 3)
        np.testing.assert_array_almost_equal(self.user_seq5.seq_array(),
                                             expected_user_seq5)
        expected_user_seq6 = get_srs_seq(get_extended_ZF(calcBaseZC(31, 6), 256), 5)
        np.testing.assert_array_almost_equal(self.user_seq6.seq_array(),
                                             expected_user_seq6)