A Discrete-Event Network Simulator
API
lte-test-cqi-generation.cc
Go to the documentation of this file.
1 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2014 Piotr Gawlowicz
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation;
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  *
18  * Author: Piotr Gawlowicz <gawlowicz.p@gmail.com>
19  *
20  */
21 
22 #include <ns3/simulator.h>
23 #include <ns3/log.h>
24 #include <ns3/callback.h>
25 #include <ns3/config.h>
26 #include <ns3/string.h>
27 #include <ns3/double.h>
28 #include <ns3/enum.h>
29 #include <ns3/boolean.h>
30 #include <ns3/pointer.h>
31 #include "ns3/ff-mac-scheduler.h"
32 #include "ns3/mobility-helper.h"
33 #include "ns3/lte-helper.h"
34 
35 #include "lte-ffr-simple.h"
36 #include "ns3/lte-rrc-sap.h"
37 #include <ns3/lte-ue-net-device.h>
38 #include <ns3/lte-ue-mac.h>
39 
40 #include "lte-test-cqi-generation.h"
41 
42 using namespace ns3;
43 
44 NS_LOG_COMPONENT_DEFINE ("LteCqiGenerationTest");
45 
46 void
47 LteTestDlSchedulingCallback (LteCqiGenerationTestCase *testcase, std::string path, DlSchedulingCallbackInfo dlInfo)
48 {
49  testcase->DlScheduling (dlInfo);
50 }
51 
52 void
53 LteTestUlSchedulingCallback (LteCqiGenerationTestCase *testcase, std::string path,
54  uint32_t frameNo, uint32_t subframeNo, uint16_t rnti,
55  uint8_t mcs, uint16_t sizeTb, uint8_t ccId)
56 {
57  testcase->UlScheduling (frameNo, subframeNo, rnti, mcs, sizeTb);
58 }
59 
60 void
61 LteTestDlSchedulingCallback2 (LteCqiGenerationDlPowerControlTestCase *testcase, std::string path,
62  DlSchedulingCallbackInfo dlInfo)
63 {
64  testcase->DlScheduling (dlInfo);
65 }
66 
67 void
68 LteTestUlSchedulingCallback2 (LteCqiGenerationDlPowerControlTestCase *testcase, std::string path,
69  uint32_t frameNo, uint32_t subframeNo, uint16_t rnti,
70  uint8_t mcs, uint16_t sizeTb, uint8_t componentCarrierId)
71 {
72  testcase->UlScheduling (frameNo, subframeNo, rnti, mcs, sizeTb);
73 }
74 
75 
80 LteCqiGenerationTestSuite::LteCqiGenerationTestSuite ()
81  : TestSuite ("lte-cqi-generation", SYSTEM)
82 {
83 // LogLevel logLevel = (LogLevel)(LOG_PREFIX_FUNC | LOG_PREFIX_TIME | LOG_LEVEL_DEBUG);
84 // LogComponentEnable ("LteCqiGenerationTest", logLevel);
85  NS_LOG_INFO ("Creating LteCqiGenerationTestSuite");
86 
87  AddTestCase (new LteCqiGenerationTestCase ("UsePdcchForCqiGeneration", false, 4, 2), TestCase::QUICK);
88  AddTestCase (new LteCqiGenerationTestCase ("UsePdschForCqiGeneration", true, 28, 2), TestCase::QUICK);
89 
90  AddTestCase (new LteCqiGenerationDlPowerControlTestCase ("CqiGenerationWithDlPowerControl",
91  LteRrcSap::PdschConfigDedicated::dB0, LteRrcSap::PdschConfigDedicated::dB0, 4, 2), TestCase::QUICK);
92  AddTestCase (new LteCqiGenerationDlPowerControlTestCase ("CqiGenerationWithDlPowerControl",
93  LteRrcSap::PdschConfigDedicated::dB0, LteRrcSap::PdschConfigDedicated::dB_3, 8, 2), TestCase::QUICK);
94  AddTestCase (new LteCqiGenerationDlPowerControlTestCase ("CqiGenerationWithDlPowerControl",
95  LteRrcSap::PdschConfigDedicated::dB0, LteRrcSap::PdschConfigDedicated::dB_6, 10, 2), TestCase::QUICK);
96  AddTestCase (new LteCqiGenerationDlPowerControlTestCase ("CqiGenerationWithDlPowerControl",
97  LteRrcSap::PdschConfigDedicated::dB1, LteRrcSap::PdschConfigDedicated::dB_6, 12, 2), TestCase::QUICK);
98  AddTestCase (new LteCqiGenerationDlPowerControlTestCase ("CqiGenerationWithDlPowerControl",
99  LteRrcSap::PdschConfigDedicated::dB2, LteRrcSap::PdschConfigDedicated::dB_6, 14, 2), TestCase::QUICK);
100  AddTestCase (new LteCqiGenerationDlPowerControlTestCase ("CqiGenerationWithDlPowerControl",
101  LteRrcSap::PdschConfigDedicated::dB3, LteRrcSap::PdschConfigDedicated::dB_6, 14, 2), TestCase::QUICK);
102  AddTestCase (new LteCqiGenerationDlPowerControlTestCase ("CqiGenerationWithDlPowerControl",
103  LteRrcSap::PdschConfigDedicated::dB3, LteRrcSap::PdschConfigDedicated::dB0, 8, 2), TestCase::QUICK);
104 }
105 
106 static LteCqiGenerationTestSuite lteCqiGenerationTestSuite;
107 
108 
109 LteCqiGenerationTestCase::LteCqiGenerationTestCase (std::string name, bool usePdcchForCqiGeneration,
110  uint16_t dlMcs, uint16_t ulMcs)
111  : TestCase ("Downlink Power Control: " + name),
112  m_dlMcs (dlMcs),
113  m_ulMcs (ulMcs)
114 {
115  m_usePdschForCqiGeneration = usePdcchForCqiGeneration;
116  NS_LOG_INFO ("Creating LteCqiGenerationTestCase");
117 }
118 
119 LteCqiGenerationTestCase::~LteCqiGenerationTestCase ()
120 {
121 }
122 
123 void
124 LteCqiGenerationTestCase::DlScheduling (DlSchedulingCallbackInfo dlInfo)
125 {
126  // need to allow for RRC connection establishment + CQI feedback reception
127  if (Simulator::Now () > MilliSeconds (35))
128  {
129 // NS_LOG_UNCOND("DL MSC: " << (uint32_t)mcsTb1 << " expected DL MCS: " << (uint32_t)m_dlMcs);
130  NS_TEST_ASSERT_MSG_EQ ((uint32_t)dlInfo.mcsTb1, (uint32_t)m_dlMcs, "Wrong DL MCS ");
131  }
132 }
133 
134 void
135 LteCqiGenerationTestCase::UlScheduling (uint32_t frameNo, uint32_t subframeNo, uint16_t rnti,
136  uint8_t mcs, uint16_t sizeTb)
137 {
138  // need to allow for RRC connection establishment + SRS transmission
139  if (Simulator::Now () > MilliSeconds (50))
140  {
141 // NS_LOG_UNCOND("UL MSC: " << (uint32_t)mcs << " expected UL MCS: " << (uint32_t)m_ulMcs);
142  NS_TEST_ASSERT_MSG_EQ ((uint32_t)mcs, (uint32_t)m_ulMcs, "Wrong UL MCS");
143  }
144 }
145 
146 void
147 LteCqiGenerationTestCase::DoRun (void)
148 {
149  NS_LOG_DEBUG ("LteCqiGenerationTestCase");
150 
151  Config::Reset ();
152  Config::SetDefault ("ns3::LteHelper::UseIdealRrc", BooleanValue (true));
153  Config::SetDefault ("ns3::LteHelper::UsePdschForCqiGeneration", BooleanValue (m_usePdschForCqiGeneration));
154 
155  Config::SetDefault ("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue (true));
156  Config::SetDefault ("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue (true));
157 
158  Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();
159 
160  // Create Nodes: eNodeB and UE
161  NodeContainer enbNodes;
162  NodeContainer ueNodes1;
163  NodeContainer ueNodes2;
164  enbNodes.Create (2);
165  ueNodes1.Create (1);
166  ueNodes2.Create (1);
167  NodeContainer allNodes = NodeContainer ( enbNodes, ueNodes1, ueNodes2);
168 
169  /*
170  * The topology is the following:
171  *
172  * eNB1 UE1 UE2 eNB2
173  * | | |
174  * x -------------------------- x -------------------------- x
175  * 500 m 500 m
176  *
177  */
178 
179  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();
180  positionAlloc->Add (Vector (0.0, 0.0, 0.0)); // eNB1
181  positionAlloc->Add (Vector (1000, 0.0, 0.0)); // eNB2
182  positionAlloc->Add (Vector (500.0, 0.0, 0.0)); // UE1
183  positionAlloc->Add (Vector (500, 0.0, 0.0)); // UE2
184  MobilityHelper mobility;
185  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
186  mobility.SetPositionAllocator (positionAlloc);
187  mobility.Install (allNodes);
188 
189  // Create Devices and install them in the Nodes (eNB and UE)
190  NetDeviceContainer enbDevs;
191  NetDeviceContainer ueDevs1;
192  NetDeviceContainer ueDevs2;
193  lteHelper->SetSchedulerType ("ns3::PfFfMacScheduler");
194  lteHelper->SetSchedulerAttribute ("UlCqiFilter", EnumValue (FfMacScheduler::PUSCH_UL_CQI));
195 
196  lteHelper->SetFfrAlgorithmType ("ns3::LteFrHardAlgorithm");
197 
198  lteHelper->SetFfrAlgorithmAttribute ("DlSubBandOffset", UintegerValue (0));
199  lteHelper->SetFfrAlgorithmAttribute ("DlSubBandwidth", UintegerValue (12));
200  lteHelper->SetFfrAlgorithmAttribute ("UlSubBandOffset", UintegerValue (0));
201  lteHelper->SetFfrAlgorithmAttribute ("UlSubBandwidth", UintegerValue (25));
202  enbDevs.Add (lteHelper->InstallEnbDevice (enbNodes.Get (0)));
203 
204  lteHelper->SetFfrAlgorithmAttribute ("DlSubBandOffset", UintegerValue (12));
205  lteHelper->SetFfrAlgorithmAttribute ("DlSubBandwidth", UintegerValue (12));
206  lteHelper->SetFfrAlgorithmAttribute ("UlSubBandOffset", UintegerValue (0));
207  lteHelper->SetFfrAlgorithmAttribute ("UlSubBandwidth", UintegerValue (25));
208  enbDevs.Add (lteHelper->InstallEnbDevice (enbNodes.Get (1)));
209 
210  ueDevs1 = lteHelper->InstallUeDevice (ueNodes1);
211  ueDevs2 = lteHelper->InstallUeDevice (ueNodes2);
212 
213  // Attach a UE to a eNB
214  lteHelper->Attach (ueDevs1, enbDevs.Get (0));
215  lteHelper->Attach (ueDevs2, enbDevs.Get (1));
216 
217  // Activate an EPS bearer
218  enum EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
219  EpsBearer bearer (q);
220  lteHelper->ActivateDataRadioBearer (ueDevs1, bearer);
221  lteHelper->ActivateDataRadioBearer (ueDevs2, bearer);
222 
223  Config::Connect ("/NodeList/0/DeviceList/0/ComponentCarrierMap/*/LteEnbMac/DlScheduling",
224  MakeBoundCallback (&LteTestDlSchedulingCallback, this));
225 
226  Config::Connect ("/NodeList/0/DeviceList/0/ComponentCarrierMap/*/LteEnbMac/UlScheduling",
227  MakeBoundCallback (&LteTestUlSchedulingCallback, this));
228 
229  Config::Connect ("/NodeList/1/DeviceList/0/ComponentCarrierMap/*/LteEnbMac/DlScheduling",
230  MakeBoundCallback (&LteTestDlSchedulingCallback, this));
231 
232  Config::Connect ("/NodeList/1/DeviceList/0/ComponentCarrierMap/*/LteEnbMac/UlScheduling",
233  MakeBoundCallback (&LteTestUlSchedulingCallback, this));
234 
235  Simulator::Stop (Seconds (1.100));
236  Simulator::Run ();
237 
238  Simulator::Destroy ();
239 }
240 
241 LteCqiGenerationDlPowerControlTestCase::LteCqiGenerationDlPowerControlTestCase (std::string name,
242  uint8_t cell0Pa, uint8_t cell1Pa, uint16_t dlMcs, uint16_t ulMcs)
243  : TestCase ("Downlink Power Control: " + name),
244  m_cell0Pa (cell0Pa),
245  m_cell1Pa (cell1Pa),
246  m_dlMcs (dlMcs),
247  m_ulMcs (ulMcs)
248 {
249  NS_LOG_INFO ("Creating LteCqiGenerationTestCase");
250 }
251 
252 LteCqiGenerationDlPowerControlTestCase::~LteCqiGenerationDlPowerControlTestCase ()
253 {
254 }
255 
256 void
257 LteCqiGenerationDlPowerControlTestCase::DlScheduling (DlSchedulingCallbackInfo dlInfo)
258 {
259  // need to allow for RRC connection establishment + CQI feedback reception
260  if (Simulator::Now () > MilliSeconds (500))
261  {
262 // NS_LOG_UNCOND("DL MSC: " << (uint32_t)mcsTb1 << " expected DL MCS: " << (uint32_t)m_dlMcs);
263  NS_TEST_ASSERT_MSG_EQ ((uint32_t)dlInfo.mcsTb1, (uint32_t)m_dlMcs, "Wrong DL MCS ");
264  }
265 }
266 
267 void
268 LteCqiGenerationDlPowerControlTestCase::UlScheduling (uint32_t frameNo, uint32_t subframeNo, uint16_t rnti,
269  uint8_t mcs, uint16_t sizeTb)
270 {
271  // need to allow for RRC connection establishment + SRS transmission
272  if (Simulator::Now () > MilliSeconds (500))
273  {
274 // NS_LOG_UNCOND("UL MSC: " << (uint32_t)mcs << " expected UL MCS: " << (uint32_t)m_ulMcs);
275  NS_TEST_ASSERT_MSG_EQ ((uint32_t)mcs, (uint32_t)m_ulMcs, "Wrong UL MCS");
276  }
277 }
278 
279 void
280 LteCqiGenerationDlPowerControlTestCase::DoRun (void)
281 {
282  NS_LOG_DEBUG ("LteCqiGenerationTestCase");
283 
284  Config::Reset ();
285  Config::SetDefault ("ns3::LteHelper::UseIdealRrc", BooleanValue (true));
286  Config::SetDefault ("ns3::LteHelper::UsePdschForCqiGeneration", BooleanValue (true));
287 
288  Config::SetDefault ("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue (true));
289  Config::SetDefault ("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue (true));
290 
291  Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();
292  lteHelper->SetFfrAlgorithmType ("ns3::LteFfrSimple");
293 
294  // Create Nodes: eNodeB and UE
295  NodeContainer enbNodes;
296  NodeContainer ueNodes1;
297  NodeContainer ueNodes2;
298  enbNodes.Create (2);
299  ueNodes1.Create (1);
300  ueNodes2.Create (2);
301  NodeContainer allNodes = NodeContainer ( enbNodes, ueNodes1, ueNodes2);
302 
303  /*
304  * The topology is the following:
305  *
306  * eNB1 UE1 UE2 eNB2 UE3
307  * | | | |
308  * x -------------------------- x -------------------------- x----x
309  * 500 m 500 m 50m
310  *
311  * see https://www.nsnam.org/bugzilla/show_bug.cgi?id=2048#c4 for why we need UE3
312  */
313 
314  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();
315  positionAlloc->Add (Vector (0.0, 0.0, 0.0)); // eNB1
316  positionAlloc->Add (Vector (1000, 0.0, 0.0)); // eNB2
317  positionAlloc->Add (Vector (500.0, 0.0, 0.0)); // UE1
318  positionAlloc->Add (Vector (500, 0.0, 0.0)); // UE2
319  positionAlloc->Add (Vector (1050, 0.0, 0.0)); // UE3
320  MobilityHelper mobility;
321  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
322  mobility.SetPositionAllocator (positionAlloc);
323  mobility.Install (allNodes);
324 
325  // Create Devices and install them in the Nodes (eNB and UE)
326  NetDeviceContainer enbDevs;
327  NetDeviceContainer ueDevs1;
328  NetDeviceContainer ueDevs2;
329  lteHelper->SetSchedulerType ("ns3::PfFfMacScheduler");
330  //In this scenario, eNB2 with 2 UEs will assign 12 RBs to UE2.
331  //On the other hand eNB1 will assign 25 RBs to UE1. As per the new uplink power
332  //spectral density computation, UE with less RBs to Tx will have more power
333  //per RB. Therefore UE2 will harm UE1 more, thus, both the UEs will have
334  //different Uplink CQI, which will cause the test to fail.
335  //In this case, we can use SRS based CQIs, since, they are not dependent on
336  //the transmission bandwidth.
337  lteHelper->SetSchedulerAttribute ("UlCqiFilter", EnumValue (FfMacScheduler::SRS_UL_CQI));
338  enbDevs = lteHelper->InstallEnbDevice (enbNodes);
339  ueDevs1 = lteHelper->InstallUeDevice (ueNodes1);
340  ueDevs2 = lteHelper->InstallUeDevice (ueNodes2);
341  //We need to fix the stream to have control over
342  //random preamble generation by the UEs.
343  Ptr<LteUeNetDevice> lteUeDev;
344  Ptr<LteUeMac> lteUeMac;
345  lteUeDev = DynamicCast<LteUeNetDevice> (ueDevs1.Get(0));
346  lteUeMac = lteUeDev->GetMac();
347  lteUeMac->AssignStreams(1);
348  lteUeDev = DynamicCast<LteUeNetDevice> (ueDevs2.Get(0));
349  lteUeMac = lteUeDev->GetMac();
350  lteUeMac->AssignStreams(1);
351  lteUeDev = DynamicCast<LteUeNetDevice> (ueDevs2.Get(1));
352  lteUeMac = lteUeDev->GetMac();
353  lteUeMac->AssignStreams(2);
354 
355  // Attach a UE to a eNB
356  lteHelper->Attach (ueDevs1, enbDevs.Get (0));
357  lteHelper->Attach (ueDevs2, enbDevs.Get (1));
358 
359  // Activate an EPS bearer
360  enum EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
361  EpsBearer bearer (q);
362  lteHelper->ActivateDataRadioBearer (ueDevs1, bearer);
363  lteHelper->ActivateDataRadioBearer (ueDevs2, bearer);
364 
365  PointerValue tmp;
366  enbDevs.Get (0)->GetAttribute ("LteFfrAlgorithm", tmp);
367  Ptr<LteFfrSimple> simpleFfrAlgorithmEnb0 = DynamicCast<LteFfrSimple>(tmp.GetObject ());
368  simpleFfrAlgorithmEnb0->ChangePdschConfigDedicated (true);
369 
370  LteRrcSap::PdschConfigDedicated pdschConfigDedicatedEnb0;
371  pdschConfigDedicatedEnb0.pa = m_cell0Pa;
372  simpleFfrAlgorithmEnb0->SetPdschConfigDedicated (pdschConfigDedicatedEnb0);
373 
374  enbDevs.Get (1)->GetAttribute ("LteFfrAlgorithm", tmp);
375  Ptr<LteFfrSimple> simpleFfrAlgorithmEnb1 = DynamicCast<LteFfrSimple>(tmp.GetObject ());
376  simpleFfrAlgorithmEnb1->ChangePdschConfigDedicated (true);
377 
378  LteRrcSap::PdschConfigDedicated pdschConfigDedicatedEnb1;
379  pdschConfigDedicatedEnb1.pa = m_cell1Pa;
380  simpleFfrAlgorithmEnb1->SetPdschConfigDedicated (pdschConfigDedicatedEnb1);
381 
382 
383  Config::Connect ("/NodeList/0/DeviceList/0/ComponentCarrierMap/*/LteEnbMac/DlScheduling",
384  MakeBoundCallback (&LteTestDlSchedulingCallback2, this));
385 
386  Config::Connect ("/NodeList/0/DeviceList/0/ComponentCarrierMap/*/LteEnbMac/UlScheduling",
387  MakeBoundCallback (&LteTestUlSchedulingCallback2, this));
388 
389  Simulator::Stop (Seconds (1.100));
390  Simulator::Run ();
391 
392  Simulator::Destroy ();
393 }
394 
ns3::NetDeviceContainer
holds a vector of ns3::NetDevice pointers
Definition: net-device-container.h:42
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205
lteCqiGenerationTestSuite
static LteCqiGenerationTestSuite lteCqiGenerationTestSuite
Definition: lte-test-cqi-generation.cc:106
ns3::LteFfrSimple::SetPdschConfigDedicated
void SetPdschConfigDedicated(LteRrcSap::PdschConfigDedicated pdschConfigDedicated)
Set PDSCH config dedicated function.
Definition: lte-ffr-simple.cc:165
ns3::TestCase::AddTestCase
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:299
ns3::ListPositionAllocator::Add
void Add(Vector v)
Add a position to the list of positions.
Definition: position-allocator.cc:70
LteCqiGenerationDlPowerControlTestCase::~LteCqiGenerationDlPowerControlTestCase
virtual ~LteCqiGenerationDlPowerControlTestCase()
Definition: lte-test-cqi-generation.cc:252
ns3::BooleanValue
AttributeValue implementation for Boolean.
Definition: boolean.h:37
LteCqiGenerationTestCase::LteCqiGenerationTestCase
LteCqiGenerationTestCase(std::string name, bool usePdcchForCqiGeneration, uint16_t dlMcs, uint16_t ulMcs)
Constructor.
Definition: lte-test-cqi-generation.cc:109
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::LteHelper::InstallEnbDevice
NetDeviceContainer InstallEnbDevice(NodeContainer c)
Create a set of eNodeB devices.
Definition: lte-helper.cc:474
LteCqiGenerationDlPowerControlTestCase::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: lte-test-cqi-generation.cc:280
ns3::LteUeMac::AssignStreams
int64_t AssignStreams(int64_t stream)
Assign a fixed random variable stream number to the random variables used by this model.
Definition: lte-ue-mac.cc:919
ns3::LteHelper::InstallUeDevice
NetDeviceContainer InstallUeDevice(NodeContainer c)
Create a set of UE devices.
Definition: lte-helper.cc:489
LteCqiGenerationTestSuite
Lte Cqi Generation Test Suite.
Definition: lte-test-cqi-generation.h:37
ns3::LteRrcSap::PdschConfigDedicated::pa
uint8_t pa
P_A value.
Definition: lte-rrc-sap.h:171
LteCqiGenerationDlPowerControlTestCase::UlScheduling
void UlScheduling(uint32_t frameNo, uint32_t subframeNo, uint16_t rnti, uint8_t mcs, uint16_t sizeTb)
UL Scheduling function.
Definition: lte-test-cqi-generation.cc:268
ns3::LteUeNetDevice::GetMac
Ptr< LteUeMac > GetMac(void) const
Get the MAC.
Definition: lte-ue-net-device.cc:171
LteCqiGenerationDlPowerControlTestCase::DlScheduling
void DlScheduling(DlSchedulingCallbackInfo dlInfo)
DL Scheduling function.
Definition: lte-test-cqi-generation.cc:257
LteCqiGenerationDlPowerControlTestCase::m_ulMcs
uint16_t m_ulMcs
the UL MCS
Definition: lte-test-cqi-generation.h:142
ns3::Config::Reset
void Reset(void)
Reset the initial value of every attribute as well as the value of every global to what they were bef...
Definition: config.cc:820
LteTestUlSchedulingCallback2
void LteTestUlSchedulingCallback2(LteCqiGenerationDlPowerControlTestCase *testcase, std::string path, uint32_t frameNo, uint32_t subframeNo, uint16_t rnti, uint8_t mcs, uint16_t sizeTb, uint8_t componentCarrierId)
Definition: lte-test-cqi-generation.cc:68
ns3::PointerValue
Hold objects of type Ptr<T>.
Definition: pointer.h:37
LteCqiGenerationDlPowerControlTestCase::m_cell1Pa
uint8_t m_cell1Pa
cell #1 PA
Definition: lte-test-cqi-generation.h:139
ns3::EpsBearer::Qci
Qci
QoS Class Indicator.
Definition: eps-bearer.h:107
ns3::DlSchedulingCallbackInfo::mcsTb1
uint8_t mcsTb1
MCS TB1.
Definition: lte-common.h:244
ns3::NodeContainer::Create
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
Definition: node-container.cc:98
ns3::EnumValue
Hold variables of type enum.
Definition: enum.h:55
LteTestDlSchedulingCallback2
void LteTestDlSchedulingCallback2(LteCqiGenerationDlPowerControlTestCase *testcase, std::string path, DlSchedulingCallbackInfo dlInfo)
Definition: lte-test-cqi-generation.cc:61
ns3::TestCase
encapsulates test code
Definition: test.h:1154
lte-test-cqi-generation.h
LteCqiGenerationTestCase::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: lte-test-cqi-generation.cc:147
ns3::Ptr< LteHelper >
ns3::LteRrcSap::PdschConfigDedicated
PdschConfigDedicated structure.
Definition: lte-rrc-sap.h:155
LteTestDlSchedulingCallback
void LteTestDlSchedulingCallback(LteCqiGenerationTestCase *testcase, std::string path, DlSchedulingCallbackInfo dlInfo)
Definition: lte-test-cqi-generation.cc:47
ns3::Now
Time Now(void)
create an ns3::Time instance which contains the current simulation time.
Definition: simulator.cc:287
LteCqiGenerationDlPowerControlTestCase::LteCqiGenerationDlPowerControlTestCase
LteCqiGenerationDlPowerControlTestCase(std::string name, uint8_t cell0Pa, uint8_t cell1Pa, uint16_t dlMcs, uint16_t ulMcs)
Constructor.
Definition: lte-test-cqi-generation.cc:241
LteCqiGenerationTestCase::UlScheduling
void UlScheduling(uint32_t frameNo, uint32_t subframeNo, uint16_t rnti, uint8_t mcs, uint16_t sizeTb)
UL Scheduling function.
Definition: lte-test-cqi-generation.cc:135
ns3::ObjectBase::GetAttribute
void GetAttribute(std::string name, AttributeValue &value) const
Get the value of an attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:223
NS_LOG_INFO
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:281
ns3::MilliSeconds
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1297
LteCqiGenerationTestCase::m_dlMcs
uint16_t m_dlMcs
the DL MCS
Definition: lte-test-cqi-generation.h:89
LteCqiGenerationDlPowerControlTestCase::m_cell0Pa
uint8_t m_cell0Pa
cell #0 PA
Definition: lte-test-cqi-generation.h:138
ns3::NodeContainer::Get
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
Definition: node-container.cc:93
ns3::LteHelper::SetFfrAlgorithmAttribute
void SetFfrAlgorithmAttribute(std::string n, const AttributeValue &v)
Set an attribute for the FFR algorithm to be created.
Definition: lte-helper.cc:314
ns3::LteFfrSimple::ChangePdschConfigDedicated
void ChangePdschConfigDedicated(bool change)
Callback function that is used to be connected to trace ChangePdschConfigDedicated.
Definition: lte-ffr-simple.cc:159
LteCqiGenerationTestCase::m_ulMcs
uint16_t m_ulMcs
the UL MCS
Definition: lte-test-cqi-generation.h:90
LteCqiGenerationTestSuite::LteCqiGenerationTestSuite
LteCqiGenerationTestSuite()
TestSuite.
Definition: lte-test-cqi-generation.cc:80
LteCqiGenerationDlPowerControlTestCase::m_dlMcs
uint16_t m_dlMcs
the DL MCS
Definition: lte-test-cqi-generation.h:141
ns3::TestSuite
A suite of tests to run.
Definition: test.h:1344
NS_TEST_ASSERT_MSG_EQ
#define NS_TEST_ASSERT_MSG_EQ(actual, limit, msg)
Test that an actual and expected (limit) value are equal and report and abort if not.
Definition: test.h:166
ns3::Config::Connect
void Connect(std::string path, const CallbackBase &cb)
Definition: config.cc:920
ns3::EpsBearer
This class contains the specification of EPS Bearers.
Definition: eps-bearer.h:92
LteTestUlSchedulingCallback
void LteTestUlSchedulingCallback(LteCqiGenerationTestCase *testcase, std::string path, uint32_t frameNo, uint32_t subframeNo, uint16_t rnti, uint8_t mcs, uint16_t sizeTb, uint8_t ccId)
Definition: lte-test-cqi-generation.cc:53
NS_LOG_DEBUG
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:273
ns3::LteHelper::SetSchedulerAttribute
void SetSchedulerAttribute(std::string n, const AttributeValue &v)
Set an attribute for the scheduler to be created.
Definition: lte-helper.cc:293
ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1289
ns3::MakeBoundCallback
Callback< R > MakeBoundCallback(R(*fnPtr)(TX), ARG a1)
Make Callbacks with one bound argument.
Definition: callback.h:1703
ns3::LteHelper::SetFfrAlgorithmType
void SetFfrAlgorithmType(std::string type)
Set the type of FFR algorithm to be used by eNodeB devices.
Definition: lte-helper.cc:306
lte-ffr-simple.h
ns3::NodeContainer
keep track of a set of node pointers.
Definition: node-container.h:39
LteCqiGenerationTestCase::m_usePdschForCqiGeneration
bool m_usePdschForCqiGeneration
use PDCCH for CQI generation
Definition: lte-test-cqi-generation.h:88
ns3::LteHelper::Attach
void Attach(NetDeviceContainer ueDevices)
Enables automatic attachment of a set of UE devices to a suitable cell using Idle mode initial cell s...
Definition: lte-helper.cc:961
ns3::DlSchedulingCallbackInfo
DlSchedulingCallbackInfo structure.
Definition: lte-common.h:240
ns3::PointerValue::GetObject
Ptr< Object > GetObject(void) const
Get the Object referenced by the PointerValue.
Definition: pointer.cc:55
ns3::UintegerValue
Hold an unsigned integer type.
Definition: uinteger.h:44
ns3::Config::SetDefault
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:849
ns3::LteHelper::SetSchedulerType
void SetSchedulerType(std::string type)
Set the type of scheduler to be used by eNodeB devices.
Definition: lte-helper.cc:279
LteCqiGenerationDlPowerControlTestCase
This test is very similar to LteCqiGenerationTestCase.
Definition: lte-test-cqi-generation.h:103
ns3::NetDeviceContainer::Get
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr<NetDevice> stored in this container at a given index.
Definition: net-device-container.cc:62
LteCqiGenerationTestCase::DlScheduling
void DlScheduling(DlSchedulingCallbackInfo dlInfo)
DL Scheduling function.
Definition: lte-test-cqi-generation.cc:124
ns3::NetDeviceContainer::Add
void Add(NetDeviceContainer other)
Append the contents of another NetDeviceContainer to the end of this container.
Definition: net-device-container.cc:67
ns3::MobilityHelper
Helper class used to assign positions and mobility models to nodes.
Definition: mobility-helper.h:43
third.mobility
mobility
Definition: third.py:108
LteCqiGenerationTestCase
This is the test case for testing different configuration of CQI generation.
Definition: lte-test-cqi-generation.h:54
ns3::LteHelper::ActivateDataRadioBearer
void ActivateDataRadioBearer(NetDeviceContainer ueDevices, EpsBearer bearer)
Activate a Data Radio Bearer on a given UE devices (for LTE-only simulation).
Definition: lte-helper.cc:1314
LteCqiGenerationTestCase::~LteCqiGenerationTestCase
virtual ~LteCqiGenerationTestCase()
Definition: lte-test-cqi-generation.cc:119