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