def test_shape(self): # Without cover code self.assertEqual(self.dmrs_seq1.shape, (12, )) self.assertEqual(self.dmrs_seq2.shape, (12, )) self.assertEqual(self.dmrs_seq3.shape, (24, )) self.assertEqual(self.dmrs_seq4.shape, (24, )) self.assertEqual(self.dmrs_seq5.shape, (48, )) self.assertEqual(self.dmrs_seq6.shape, (48, )) # With cover code root_seq1 = RootSequence(root_index=15, size=12) cover_code1 = np.array([1, 1]) dmrs_seq1 = DmrsUeSequence(root_seq=root_seq1, n_cs=3, cover_code=cover_code1) root_seq2 = RootSequence(root_index=23, size=12) cover_code2 = np.array([1, -1]) dmrs_seq2 = DmrsUeSequence(root_seq=root_seq2, n_cs=4, cover_code=cover_code2) root_seq5 = RootSequence(root_index=15, size=48) cover_code5 = np.array([1, -1, 1, -1]) dmrs_seq5 = DmrsUeSequence(root_seq=root_seq5, n_cs=3, cover_code=cover_code5) self.assertEqual(dmrs_seq1.shape, (2, 12)) self.assertEqual(dmrs_seq2.shape, (2, 12)) self.assertEqual(dmrs_seq5.shape, (4, 48))
def test_repr(self): root_seq1 = RootSequence(root_index=15, size=12) dmrs_seq1 = DmrsUeSequence(root_seq=root_seq1, n_cs=3) root_seq2 = RootSequence(root_index=23, size=12) cover_code2 = np.array([1, -1]) dmrs_seq2 = DmrsUeSequence(root_seq=root_seq2, n_cs=4, cover_code=cover_code2) self.assertEqual( "<DmrsUeSequence(root_index=15, n_cs=3, cover_code=None)>", repr(dmrs_seq1)) self.assertEqual( "<DmrsUeSequence(root_index=23, n_cs=4, cover_code=[ 1 -1])>", repr(dmrs_seq2))
def test_getitem(self): seqs = [self.dmrs_seq1, self.dmrs_seq2, self.dmrs_seq3, self.dmrs_seq4] 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]) # Now let's test with a DMRS sequence with cover codes. The first # dimension of the underlying numpy array is the cover code index root_seq = RootSequence(root_index=23, size=12) cover_code = np.array([1, -1]) dmrs_seq = DmrsUeSequence(root_seq=root_seq, n_cs=4, cover_code=cover_code) np.testing.assert_almost_equal(dmrs_seq[0, 4], dmrs_seq.seq_array()[0, 4]) np.testing.assert_almost_equal(dmrs_seq[1, 0:8:2], dmrs_seq.seq_array()[1, 0:8:2])
class DmrsUeSequenceTestCase(unittest.TestCase): def setUp(self): """Called before each test.""" root_seq1 = RootSequence(root_index=15, size=12) self.dmrs_seq1 = DmrsUeSequence( root_seq=root_seq1, n_cs=3) root_seq2 = RootSequence(root_index=23, size=12) self.dmrs_seq2 = DmrsUeSequence( root_seq=root_seq2, n_cs=4) root_seq3 = RootSequence(root_index=15, size=24) self.dmrs_seq3 = DmrsUeSequence( root_seq=root_seq3, n_cs=3) root_seq4 = RootSequence(root_index=23, size=24) self.dmrs_seq4 = DmrsUeSequence( root_seq=root_seq4, n_cs=4) root_seq5 = RootSequence(root_index=15, size=48) self.dmrs_seq5 = DmrsUeSequence( root_seq=root_seq5, n_cs=3) root_seq6 = RootSequence(root_index=23, size=48) self.dmrs_seq6 = DmrsUeSequence( root_seq=root_seq6, n_cs=4) def test_size(self): self.assertEqual(self.dmrs_seq1.size, 12) self.assertEqual(self.dmrs_seq2.size, 12) self.assertEqual(self.dmrs_seq3.size, 24) self.assertEqual(self.dmrs_seq4.size, 24) self.assertEqual(self.dmrs_seq5.size, 48) self.assertEqual(self.dmrs_seq6.size, 48) def test_seq_array(self): expected_dmrs1 = get_dmrs_seq(RootSequence(15, 12).seq_array(), 3) expected_dmrs2 = get_dmrs_seq(RootSequence(23, 12).seq_array(), 4) expected_dmrs3 = get_dmrs_seq(RootSequence(15, 24).seq_array(), 3) expected_dmrs4 = get_dmrs_seq(RootSequence(23, 24).seq_array(), 4) expected_dmrs5 = get_dmrs_seq(RootSequence(15, 48).seq_array(), 3) expected_dmrs6 = get_dmrs_seq(RootSequence(23, 48).seq_array(), 4) np.testing.assert_array_almost_equal( expected_dmrs1, self.dmrs_seq1.seq_array()) np.testing.assert_array_almost_equal( expected_dmrs2, self.dmrs_seq2.seq_array()) np.testing.assert_array_almost_equal( expected_dmrs3, self.dmrs_seq3.seq_array()) np.testing.assert_array_almost_equal( expected_dmrs4, self.dmrs_seq4.seq_array()) np.testing.assert_array_almost_equal( expected_dmrs5, self.dmrs_seq5.seq_array()) np.testing.assert_array_almost_equal( expected_dmrs6, self.dmrs_seq6.seq_array())
def setUp(self): """Called before each test.""" root_seq1 = RootSequence(root_index=15, size=12) self.dmrs_seq1 = DmrsUeSequence( root_seq=root_seq1, n_cs=3) root_seq2 = RootSequence(root_index=23, size=12) self.dmrs_seq2 = DmrsUeSequence( root_seq=root_seq2, n_cs=4) root_seq3 = RootSequence(root_index=15, size=24) self.dmrs_seq3 = DmrsUeSequence( root_seq=root_seq3, n_cs=3) root_seq4 = RootSequence(root_index=23, size=24) self.dmrs_seq4 = DmrsUeSequence( root_seq=root_seq4, n_cs=4) root_seq5 = RootSequence(root_index=15, size=48) self.dmrs_seq5 = DmrsUeSequence( root_seq=root_seq5, n_cs=3) root_seq6 = RootSequence(root_index=23, size=48) self.dmrs_seq6 = DmrsUeSequence( root_seq=root_seq6, n_cs=4)
def setUp(self): """Called before each test.""" root_seq1 = RootSequence(root_index=15, size=12) self.dmrs_seq1 = DmrsUeSequence(root_seq=root_seq1, n_cs=3, normalize=True) root_seq2 = RootSequence(root_index=23, size=12) self.dmrs_seq2 = DmrsUeSequence(root_seq=root_seq2, n_cs=4) root_seq3 = RootSequence(root_index=15, size=24) self.dmrs_seq3 = DmrsUeSequence(root_seq=root_seq3, n_cs=3) root_seq4 = RootSequence(root_index=23, size=24) self.dmrs_seq4 = DmrsUeSequence(root_seq=root_seq4, n_cs=4, normalize=True) root_seq5 = RootSequence(root_index=15, size=48) self.dmrs_seq5 = DmrsUeSequence(root_seq=root_seq5, n_cs=3) root_seq6 = RootSequence(root_index=23, size=48) self.dmrs_seq6 = DmrsUeSequence(root_seq=root_seq6, n_cs=4)
class DmrsUeSequenceTestCase(unittest.TestCase): def setUp(self): """Called before each test.""" root_seq1 = RootSequence(root_index=15, size=12) self.dmrs_seq1 = DmrsUeSequence(root_seq=root_seq1, n_cs=3, normalize=True) root_seq2 = RootSequence(root_index=23, size=12) self.dmrs_seq2 = DmrsUeSequence(root_seq=root_seq2, n_cs=4) root_seq3 = RootSequence(root_index=15, size=24) self.dmrs_seq3 = DmrsUeSequence(root_seq=root_seq3, n_cs=3) root_seq4 = RootSequence(root_index=23, size=24) self.dmrs_seq4 = DmrsUeSequence(root_seq=root_seq4, n_cs=4, normalize=True) root_seq5 = RootSequence(root_index=15, size=48) self.dmrs_seq5 = DmrsUeSequence(root_seq=root_seq5, n_cs=3) root_seq6 = RootSequence(root_index=23, size=48) self.dmrs_seq6 = DmrsUeSequence(root_seq=root_seq6, n_cs=4) def test_size(self): # Without cover code self.assertEqual(self.dmrs_seq1.size, 12) self.assertEqual(self.dmrs_seq2.size, 12) self.assertEqual(self.dmrs_seq3.size, 24) self.assertEqual(self.dmrs_seq4.size, 24) self.assertEqual(self.dmrs_seq5.size, 48) self.assertEqual(self.dmrs_seq6.size, 48) # With cover code root_seq1 = RootSequence(root_index=15, size=12) cover_code1 = np.array([1, 1]) dmrs_seq1 = DmrsUeSequence(root_seq=root_seq1, n_cs=3, cover_code=cover_code1) root_seq2 = RootSequence(root_index=23, size=12) cover_code2 = np.array([1, -1]) dmrs_seq2 = DmrsUeSequence(root_seq=root_seq2, n_cs=4, cover_code=cover_code2) root_seq5 = RootSequence(root_index=15, size=48) cover_code5 = np.array([1, -1, 1, -1]) dmrs_seq5 = DmrsUeSequence(root_seq=root_seq5, n_cs=3, cover_code=cover_code5) self.assertEqual(dmrs_seq1.size, 12) self.assertEqual(dmrs_seq2.size, 12) self.assertEqual(dmrs_seq5.size, 48) def test_shape(self): # Without cover code self.assertEqual(self.dmrs_seq1.shape, (12, )) self.assertEqual(self.dmrs_seq2.shape, (12, )) self.assertEqual(self.dmrs_seq3.shape, (24, )) self.assertEqual(self.dmrs_seq4.shape, (24, )) self.assertEqual(self.dmrs_seq5.shape, (48, )) self.assertEqual(self.dmrs_seq6.shape, (48, )) # With cover code root_seq1 = RootSequence(root_index=15, size=12) cover_code1 = np.array([1, 1]) dmrs_seq1 = DmrsUeSequence(root_seq=root_seq1, n_cs=3, cover_code=cover_code1) root_seq2 = RootSequence(root_index=23, size=12) cover_code2 = np.array([1, -1]) dmrs_seq2 = DmrsUeSequence(root_seq=root_seq2, n_cs=4, cover_code=cover_code2) root_seq5 = RootSequence(root_index=15, size=48) cover_code5 = np.array([1, -1, 1, -1]) dmrs_seq5 = DmrsUeSequence(root_seq=root_seq5, n_cs=3, cover_code=cover_code5) self.assertEqual(dmrs_seq1.shape, (2, 12)) self.assertEqual(dmrs_seq2.shape, (2, 12)) self.assertEqual(dmrs_seq5.shape, (4, 48)) def test_seq_array(self): # xxxxxxxxxx Test withoyut cover code xxxxxxxxxxxxxxxxxxxxxxxxxxxxx expected_dmrs1 = get_dmrs_seq(RootSequence(15, 12).seq_array(), 3) expected_dmrs1 /= math.sqrt(expected_dmrs1.size) expected_dmrs2 = get_dmrs_seq(RootSequence(23, 12).seq_array(), 4) expected_dmrs3 = get_dmrs_seq(RootSequence(15, 24).seq_array(), 3) expected_dmrs4 = get_dmrs_seq(RootSequence(23, 24).seq_array(), 4) expected_dmrs4 /= math.sqrt(expected_dmrs4.size) expected_dmrs5 = get_dmrs_seq(RootSequence(15, 48).seq_array(), 3) expected_dmrs6 = get_dmrs_seq(RootSequence(23, 48).seq_array(), 4) np.testing.assert_array_almost_equal(expected_dmrs1, self.dmrs_seq1.seq_array()) np.testing.assert_array_almost_equal(expected_dmrs2, self.dmrs_seq2.seq_array()) np.testing.assert_array_almost_equal(expected_dmrs3, self.dmrs_seq3.seq_array()) np.testing.assert_array_almost_equal(expected_dmrs4, self.dmrs_seq4.seq_array()) np.testing.assert_array_almost_equal(expected_dmrs5, self.dmrs_seq5.seq_array()) np.testing.assert_array_almost_equal(expected_dmrs6, self.dmrs_seq6.seq_array()) self.assertIsNone(self.dmrs_seq1.cover_code) self.assertIsNone(self.dmrs_seq2.cover_code) self.assertIsNone(self.dmrs_seq3.cover_code) self.assertIsNone(self.dmrs_seq4.cover_code) self.assertIsNone(self.dmrs_seq5.cover_code) self.assertIsNone(self.dmrs_seq6.cover_code) # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # xxxxxxxxxx Test with cover code xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx root_seq1 = RootSequence(root_index=15, size=12) cover_code1 = np.array([1, 1]) dmrs_seq1 = DmrsUeSequence(root_seq=root_seq1, n_cs=3, cover_code=cover_code1, normalize=True) root_seq2 = RootSequence(root_index=23, size=12) cover_code2 = np.array([1, -1]) dmrs_seq2 = DmrsUeSequence(root_seq=root_seq2, n_cs=4, cover_code=cover_code2) root_seq3 = RootSequence(root_index=15, size=24) cover_code3 = np.array([-1, 1]) dmrs_seq3 = DmrsUeSequence(root_seq=root_seq3, n_cs=3, cover_code=cover_code3) root_seq4 = RootSequence(root_index=23, size=24) cover_code4 = np.array([-1, -1]) dmrs_seq4 = DmrsUeSequence(root_seq=root_seq4, n_cs=4, cover_code=cover_code4, normalize=True) root_seq5 = RootSequence(root_index=15, size=48) cover_code5 = np.array([1, -1, 1, -1]) dmrs_seq5 = DmrsUeSequence(root_seq=root_seq5, n_cs=3, cover_code=cover_code5) # Test that OCC was set np.testing.assert_array_equal(np.array([1, 1]), dmrs_seq1.cover_code) np.testing.assert_array_equal(np.array([1, -1]), dmrs_seq2.cover_code) np.testing.assert_array_equal(np.array([-1, 1]), dmrs_seq3.cover_code) np.testing.assert_array_equal(np.array([-1, -1]), dmrs_seq4.cover_code) np.testing.assert_array_equal(np.array([1, -1, 1, -1]), dmrs_seq5.cover_code) # Test getting the full sequence with cover code using # `seq_array()` method expected_dmrs1_occ = np.vstack([expected_dmrs1, expected_dmrs1]) expected_dmrs2_occ = np.vstack([expected_dmrs2, -expected_dmrs2]) expected_dmrs3_occ = np.vstack([-expected_dmrs3, expected_dmrs3]) expected_dmrs4_occ = np.vstack([-expected_dmrs4, -expected_dmrs4]) expected_dmrs5_occ = np.vstack( [expected_dmrs5, -expected_dmrs5, expected_dmrs5, -expected_dmrs5]) np.testing.assert_array_almost_equal(expected_dmrs1_occ, dmrs_seq1.seq_array()) np.testing.assert_array_almost_equal(expected_dmrs2_occ, dmrs_seq2.seq_array()) np.testing.assert_array_almost_equal(expected_dmrs3_occ, dmrs_seq3.seq_array()) np.testing.assert_array_almost_equal(expected_dmrs4_occ, dmrs_seq4.seq_array()) np.testing.assert_array_almost_equal(expected_dmrs5_occ, dmrs_seq5.seq_array()) # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx def test_getitem(self): seqs = [self.dmrs_seq1, self.dmrs_seq2, self.dmrs_seq3, self.dmrs_seq4] 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]) # Now let's test with a DMRS sequence with cover codes. The first # dimension of the underlying numpy array is the cover code index root_seq = RootSequence(root_index=23, size=12) cover_code = np.array([1, -1]) dmrs_seq = DmrsUeSequence(root_seq=root_seq, n_cs=4, cover_code=cover_code) np.testing.assert_almost_equal(dmrs_seq[0, 4], dmrs_seq.seq_array()[0, 4]) np.testing.assert_almost_equal(dmrs_seq[1, 0:8:2], dmrs_seq.seq_array()[1, 0:8:2]) def test_repr(self): root_seq1 = RootSequence(root_index=15, size=12) dmrs_seq1 = DmrsUeSequence(root_seq=root_seq1, n_cs=3) root_seq2 = RootSequence(root_index=23, size=12) cover_code2 = np.array([1, -1]) dmrs_seq2 = DmrsUeSequence(root_seq=root_seq2, n_cs=4, cover_code=cover_code2) self.assertEqual( "<DmrsUeSequence(root_index=15, n_cs=3, cover_code=None)>", repr(dmrs_seq1)) self.assertEqual( "<DmrsUeSequence(root_index=23, n_cs=4, cover_code=[ 1 -1])>", repr(dmrs_seq2))
def test_estimate_channel_multiple_rx(self): Nsc = 24 size = Nsc Nr = 3 # Number of receive antennas num_taps_to_keep = 15 cover_codes = [np.array([-1, 1]), np.array([1, 1])] user1_seq = DmrsUeSequence(RootSequence(root_index=25, size=size), 1, cover_code=cover_codes[0]) user2_seq = DmrsUeSequence(RootSequence(root_index=25, size=size), 4, cover_code=cover_codes[0]) ue1_channel_estimator = CazacBasedWithOCCChannelEstimator(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=(Nr, 1)) jakes2 = JakesSampleGenerator(Fd, Ts, L, shape=(Nr, 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].T freq_resp_2 = impulse_response2.get_freq_response(Nsc) H2 = freq_resp_2[:, :, 0, 0].T # Sequence of the users r1 = user1_seq.seq_array() r2 = user2_seq.seq_array() # Received signal (in frequency domain) of user 1 Y1 = H1[:, np.newaxis, :] * r1[np.newaxis, :, :] Y2 = H2[:, np.newaxis, :] * r2[np.newaxis, :, :] Y = Y1 + Y2 # Dimension: `Nr x cover_code_size x num_elements` # Calculate expected estimated channel for user 1 cover_code1 = cover_codes[0] Y_with_cover_code = \ (cover_code1[0] * Y[:,0,:] + cover_code1[1] * Y[:,1,:]) / 2.0 ":type: np.ndarray" r1_no_cover_code = r1[0] * cover_code1[0] y1 = np.fft.ifft(np.conj(r1_no_cover_code[np.newaxis]) * Y_with_cover_code, size, axis=1) tilde_h1_espected = y1[:, 0:(num_taps_to_keep + 1)] tilde_H1_espected = np.fft.fft(tilde_h1_espected, Nsc, axis=1) # Test the CazacBasedWithOCCChannelEstimator estimation H1_estimated = ue1_channel_estimator.estimate_channel_freq_domain( Y, num_taps_to_keep, extra_dimension=True) np.testing.assert_array_almost_equal(H1_estimated, tilde_H1_espected) # 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 - tilde_H1_espected) ":type: np.ndarray" np.testing.assert_almost_equal(error / 2., np.zeros(error.shape), decimal=2)
def test_estimate_channel_with_dmrs(self): Nsc = 24 size = Nsc cover_codes = [np.array([-1, 1]), np.array([1, 1])] user1_seq = DmrsUeSequence(root_seq=RootSequence(root_index=17, size=size), n_cs=1, cover_code=cover_codes[0]) user2_seq = DmrsUeSequence(root_seq=RootSequence(root_index=17, size=size), n_cs=4, cover_code=cover_codes[1]) ue1_channel_estimator = CazacBasedWithOCCChannelEstimator(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 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 cover_code1 = cover_codes[0] Y_with_cover_code = \ (cover_code1[0] * Y[0] + cover_code1[1] * Y[1]) / 2.0 ":type: np.ndarray" r1_no_cover_code = r1[0] * cover_code1[0] y1 = np.fft.ifft(np.conj(r1_no_cover_code) * Y_with_cover_code, size) tilde_h1 = y1[0:4] tilde_H1 = np.fft.fft(tilde_h1, Nsc) # Test the CazacBasedWithOCCChannelEstimator estimation np.testing.assert_array_almost_equal( ue1_channel_estimator.estimate_channel_freq_domain( Y, 3, extra_dimension=True), 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 - tilde_H1) ":type: np.ndarray" np.testing.assert_almost_equal(error / 2., np.zeros(error.size), decimal=2)
def test_seq_array(self): # xxxxxxxxxx Test withoyut cover code xxxxxxxxxxxxxxxxxxxxxxxxxxxxx expected_dmrs1 = get_dmrs_seq(RootSequence(15, 12).seq_array(), 3) expected_dmrs1 /= math.sqrt(expected_dmrs1.size) expected_dmrs2 = get_dmrs_seq(RootSequence(23, 12).seq_array(), 4) expected_dmrs3 = get_dmrs_seq(RootSequence(15, 24).seq_array(), 3) expected_dmrs4 = get_dmrs_seq(RootSequence(23, 24).seq_array(), 4) expected_dmrs4 /= math.sqrt(expected_dmrs4.size) expected_dmrs5 = get_dmrs_seq(RootSequence(15, 48).seq_array(), 3) expected_dmrs6 = get_dmrs_seq(RootSequence(23, 48).seq_array(), 4) np.testing.assert_array_almost_equal(expected_dmrs1, self.dmrs_seq1.seq_array()) np.testing.assert_array_almost_equal(expected_dmrs2, self.dmrs_seq2.seq_array()) np.testing.assert_array_almost_equal(expected_dmrs3, self.dmrs_seq3.seq_array()) np.testing.assert_array_almost_equal(expected_dmrs4, self.dmrs_seq4.seq_array()) np.testing.assert_array_almost_equal(expected_dmrs5, self.dmrs_seq5.seq_array()) np.testing.assert_array_almost_equal(expected_dmrs6, self.dmrs_seq6.seq_array()) self.assertIsNone(self.dmrs_seq1.cover_code) self.assertIsNone(self.dmrs_seq2.cover_code) self.assertIsNone(self.dmrs_seq3.cover_code) self.assertIsNone(self.dmrs_seq4.cover_code) self.assertIsNone(self.dmrs_seq5.cover_code) self.assertIsNone(self.dmrs_seq6.cover_code) # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # xxxxxxxxxx Test with cover code xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx root_seq1 = RootSequence(root_index=15, size=12) cover_code1 = np.array([1, 1]) dmrs_seq1 = DmrsUeSequence(root_seq=root_seq1, n_cs=3, cover_code=cover_code1, normalize=True) root_seq2 = RootSequence(root_index=23, size=12) cover_code2 = np.array([1, -1]) dmrs_seq2 = DmrsUeSequence(root_seq=root_seq2, n_cs=4, cover_code=cover_code2) root_seq3 = RootSequence(root_index=15, size=24) cover_code3 = np.array([-1, 1]) dmrs_seq3 = DmrsUeSequence(root_seq=root_seq3, n_cs=3, cover_code=cover_code3) root_seq4 = RootSequence(root_index=23, size=24) cover_code4 = np.array([-1, -1]) dmrs_seq4 = DmrsUeSequence(root_seq=root_seq4, n_cs=4, cover_code=cover_code4, normalize=True) root_seq5 = RootSequence(root_index=15, size=48) cover_code5 = np.array([1, -1, 1, -1]) dmrs_seq5 = DmrsUeSequence(root_seq=root_seq5, n_cs=3, cover_code=cover_code5) # Test that OCC was set np.testing.assert_array_equal(np.array([1, 1]), dmrs_seq1.cover_code) np.testing.assert_array_equal(np.array([1, -1]), dmrs_seq2.cover_code) np.testing.assert_array_equal(np.array([-1, 1]), dmrs_seq3.cover_code) np.testing.assert_array_equal(np.array([-1, -1]), dmrs_seq4.cover_code) np.testing.assert_array_equal(np.array([1, -1, 1, -1]), dmrs_seq5.cover_code) # Test getting the full sequence with cover code using # `seq_array()` method expected_dmrs1_occ = np.vstack([expected_dmrs1, expected_dmrs1]) expected_dmrs2_occ = np.vstack([expected_dmrs2, -expected_dmrs2]) expected_dmrs3_occ = np.vstack([-expected_dmrs3, expected_dmrs3]) expected_dmrs4_occ = np.vstack([-expected_dmrs4, -expected_dmrs4]) expected_dmrs5_occ = np.vstack( [expected_dmrs5, -expected_dmrs5, expected_dmrs5, -expected_dmrs5]) np.testing.assert_array_almost_equal(expected_dmrs1_occ, dmrs_seq1.seq_array()) np.testing.assert_array_almost_equal(expected_dmrs2_occ, dmrs_seq2.seq_array()) np.testing.assert_array_almost_equal(expected_dmrs3_occ, dmrs_seq3.seq_array()) np.testing.assert_array_almost_equal(expected_dmrs4_occ, dmrs_seq4.seq_array()) np.testing.assert_array_almost_equal(expected_dmrs5_occ, dmrs_seq5.seq_array())
def test_estimate_channel_with_dmrs(self): Nsc = 24 size = Nsc user1_seq = DmrsUeSequence( RootSequence(root_index=17, size=size), 1) user2_seq = DmrsUeSequence( RootSequence(root_index=13, size=size), 4) 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:4] tilde_H1 = np.fft.fft(tilde_h1, Nsc) # xxxxxx DEBUG xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx a = y1[0:4] A = np.fft.fft(a, Nsc) import matplotlib.pyplot as plt # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # Test the CazacBasedChannelEstimator estimation np.testing.assert_array_almost_equal( ue1_channel_estimator.estimate_channel_freq_domain(Y, 3), 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[5:-5] - tilde_H1[5:-5]) np.testing.assert_almost_equal( error/2., np.zeros(error.size), decimal=2)