A Discrete-Event Network Simulator
API
lte-test-frequency-reuse.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 
32 #include "ns3/mobility-helper.h"
33 #include "ns3/lte-helper.h"
34 #include "ns3/point-to-point-epc-helper.h"
35 #include "ns3/internet-module.h"
36 #include "ns3/point-to-point-module.h"
37 #include "ns3/applications-module.h"
38 
39 #include <ns3/ff-mac-scheduler.h>
40 #include <ns3/lte-enb-net-device.h>
41 #include <ns3/lte-enb-phy.h>
42 #include <ns3/lte-enb-rrc.h>
43 #include <ns3/lte-ue-net-device.h>
44 #include <ns3/lte-ue-phy.h>
45 #include <ns3/lte-ue-rrc.h>
46 
47 #include "lte-ffr-simple.h"
48 #include "lte-simple-spectrum-phy.h"
49 #include <ns3/lte-common.h>
50 
51 #include "lte-test-frequency-reuse.h"
52 
53 
54 using namespace ns3;
55 
56 NS_LOG_COMPONENT_DEFINE ("LteFrequencyReuseTest");
57 
62 LteFrequencyReuseTestSuite::LteFrequencyReuseTestSuite ()
63  : TestSuite ("lte-frequency-reuse", SYSTEM)
64 {
65 // LogLevel logLevel = (LogLevel)(LOG_PREFIX_FUNC | LOG_PREFIX_TIME | LOG_LEVEL_DEBUG);
66 // LogComponentEnable ("LteFrequencyReuseTest", logLevel);
67 
68  std::vector<bool> availableDlRb;
69  std::vector<bool> availableUlRb;
70  for (uint32_t i = 0; i < 12; i++)
71  {
72  availableDlRb.push_back (true);
73  availableUlRb.push_back (true);
74  }
75  for (uint32_t i = 12; i < 25; i++)
76  {
77  availableDlRb.push_back (false);
78  availableUlRb.push_back (false);
79  }
80 
81  AddTestCase (new LteHardFrTestCase ("DownlinkHardFrPf1", 1, "ns3::PfFfMacScheduler", 25, 25, 0, 12, 0, 12, availableDlRb, availableUlRb), TestCase::QUICK);
82  AddTestCase (new LteHardFrTestCase ("DownlinkHardFrPf2", 5, "ns3::PfFfMacScheduler", 25, 25, 0, 12, 0, 12, availableDlRb, availableUlRb), TestCase::QUICK);
83  AddTestCase (new LteHardFrTestCase ("DownlinkHardFrPss1", 1, "ns3::PssFfMacScheduler", 25, 25, 0, 12, 0, 12, availableDlRb, availableUlRb), TestCase::QUICK);
84  AddTestCase (new LteHardFrTestCase ("DownlinkHardFrPss2", 5, "ns3::PssFfMacScheduler", 25, 25, 0, 12, 0, 12, availableDlRb, availableUlRb), TestCase::QUICK);
85  AddTestCase (new LteHardFrTestCase ("DownlinkHardFrCqa1", 1, "ns3::CqaFfMacScheduler", 25, 25, 0, 12, 0, 12, availableDlRb, availableUlRb), TestCase::QUICK);
86  AddTestCase (new LteHardFrTestCase ("DownlinkHardFrCqa2", 5, "ns3::CqaFfMacScheduler", 25, 25, 0, 12, 0, 12, availableDlRb, availableUlRb), TestCase::QUICK);
87  AddTestCase (new LteHardFrTestCase ("DownlinkHardFrFdTbfq1", 1, "ns3::FdTbfqFfMacScheduler", 25, 25, 0, 12, 0, 12, availableDlRb, availableUlRb), TestCase::QUICK);
88  AddTestCase (new LteHardFrTestCase ("DownlinkHardFrFdTbfq2", 5, "ns3::FdTbfqFfMacScheduler", 25, 25, 0, 12, 0, 12, availableDlRb, availableUlRb), TestCase::QUICK);
89  AddTestCase (new LteHardFrTestCase ("DownlinkHardFrTdTbfq1", 1, "ns3::TdTbfqFfMacScheduler", 25, 25, 0, 12, 0, 12, availableDlRb, availableUlRb), TestCase::QUICK);
90  AddTestCase (new LteHardFrTestCase ("DownlinkHardFrTdTbfq2", 5, "ns3::TdTbfqFfMacScheduler", 25, 25, 0, 12, 0, 12, availableDlRb, availableUlRb), TestCase::QUICK);
91 
92  availableDlRb.clear ();
93  availableUlRb.clear ();
94  for (uint32_t i = 0; i < 6; i++)
95  {
96  availableDlRb.push_back (true);
97  availableUlRb.push_back (true);
98  }
99  for (uint32_t i = 6; i < 12; i++)
100  {
101  availableDlRb.push_back (false);
102  availableUlRb.push_back (false);
103  }
104  for (uint32_t i = 12; i < 18; i++)
105  {
106  availableDlRb.push_back (true);
107  availableUlRb.push_back (true);
108  }
109  for (uint32_t i = 18; i < 25; i++)
110  {
111  availableDlRb.push_back (false);
112  availableUlRb.push_back (false);
113  }
114 
115  AddTestCase (new LteStrictFrTestCase ("DownlinkStrictFrPf1", 1, "ns3::PfFfMacScheduler", 25, 25, 6, 6, 6, 6, 6, 6, availableDlRb, availableUlRb), TestCase::QUICK);
116  AddTestCase (new LteStrictFrTestCase ("DownlinkStrictFrPf2", 5, "ns3::PfFfMacScheduler", 25, 25, 6, 6, 6, 6, 6, 6, availableDlRb, availableUlRb), TestCase::QUICK);
117  AddTestCase (new LteStrictFrTestCase ("DownlinkStrictFrPss1", 1, "ns3::PssFfMacScheduler", 25, 25, 6, 6, 6, 6, 6, 6, availableDlRb, availableUlRb), TestCase::QUICK);
118  AddTestCase (new LteStrictFrTestCase ("DownlinkStrictFrPss2", 5, "ns3::PssFfMacScheduler", 25, 25, 6, 6, 6, 6, 6, 6, availableDlRb, availableUlRb), TestCase::QUICK);
119  AddTestCase (new LteStrictFrTestCase ("DownlinkStrictFrCqa1", 1, "ns3::CqaFfMacScheduler", 25, 25, 6, 6, 6, 6, 6, 6, availableDlRb, availableUlRb), TestCase::QUICK);
120  AddTestCase (new LteStrictFrTestCase ("DownlinkStrictFrCqa2", 5, "ns3::CqaFfMacScheduler", 25, 25, 6, 6, 6, 6, 6, 6, availableDlRb, availableUlRb), TestCase::QUICK);
121  AddTestCase (new LteStrictFrTestCase ("DownlinkStrictFrCqaFdTbfq1", 1, "ns3::FdTbfqFfMacScheduler", 25, 25, 6, 6, 6, 6, 6, 6, availableDlRb, availableUlRb), TestCase::QUICK);
122  AddTestCase (new LteStrictFrTestCase ("DownlinkStrictFrCqaFdTbfq2", 5, "ns3::FdTbfqFfMacScheduler", 25, 25, 6, 6, 6, 6, 6, 6, availableDlRb, availableUlRb), TestCase::QUICK);
123  AddTestCase (new LteStrictFrTestCase ("DownlinkStrictFrCqaTdTbfq1", 1, "ns3::TdTbfqFfMacScheduler", 25, 25, 6, 6, 6, 6, 6, 6, availableDlRb, availableUlRb), TestCase::QUICK);
124  AddTestCase (new LteStrictFrTestCase ("DownlinkStrictFrCqaTdTbfq2", 5, "ns3::TdTbfqFfMacScheduler", 25, 25, 6, 6, 6, 6, 6, 6, availableDlRb, availableUlRb), TestCase::QUICK);
125 
126  AddTestCase (new LteStrictFrAreaTestCase ("LteStrictFrAreaTestCasePf1", "ns3::PfFfMacScheduler"), TestCase::QUICK);
127  AddTestCase (new LteStrictFrAreaTestCase ("LteStrictFrAreaTestCasePss1", "ns3::PssFfMacScheduler"), TestCase::QUICK);
128  AddTestCase (new LteStrictFrAreaTestCase ("LteStrictFrAreaTestCaseCqa1", "ns3::CqaFfMacScheduler"), TestCase::QUICK);
129  AddTestCase (new LteStrictFrAreaTestCase ("LteStrictFrAreaTestCaseFdTbfq1", "ns3::FdTbfqFfMacScheduler"), TestCase::QUICK);
130  AddTestCase (new LteStrictFrAreaTestCase ("LteStrictFrAreaTestCaseTdTbfq1", "ns3::TdTbfqFfMacScheduler"), TestCase::QUICK);
131 
132  AddTestCase (new LteSoftFrAreaTestCase ("LteSoftFrAreaTestCasePf1", "ns3::PfFfMacScheduler"), TestCase::QUICK);
133  AddTestCase (new LteSoftFrAreaTestCase ("LteSoftFrAreaTestCasePss1", "ns3::PssFfMacScheduler"), TestCase::QUICK);
134  AddTestCase (new LteSoftFrAreaTestCase ("LteSoftFrAreaTestCaseCqa1", "ns3::CqaFfMacScheduler"), TestCase::QUICK);
135  AddTestCase (new LteSoftFrAreaTestCase ("LteSoftFrAreaTestCaseFdTbfq1", "ns3::FdTbfqFfMacScheduler"), TestCase::QUICK);
136  AddTestCase (new LteSoftFrAreaTestCase ("LteSoftFrAreaTestCaseTdTbfq1", "ns3::TdTbfqFfMacScheduler"), TestCase::QUICK);
137 
138  AddTestCase (new LteSoftFfrAreaTestCase ("LteSoftFfrAreaTestCasePf1", "ns3::PfFfMacScheduler"), TestCase::QUICK);
139  AddTestCase (new LteSoftFfrAreaTestCase ("LteSoftFfrAreaTestCasePss1", "ns3::PssFfMacScheduler"), TestCase::QUICK);
140  AddTestCase (new LteSoftFfrAreaTestCase ("LteSoftFfrAreaTestCaseCqa1", "ns3::CqaFfMacScheduler"), TestCase::QUICK);
141  AddTestCase (new LteSoftFfrAreaTestCase ("LteSoftFfrAreaTestCaseFdTbfq1", "ns3::FdTbfqFfMacScheduler"), TestCase::QUICK);
142  AddTestCase (new LteSoftFfrAreaTestCase ("LteSoftFfrAreaTestCaseTdTbfq1", "ns3::TdTbfqFfMacScheduler"), TestCase::QUICK);
143 
144  AddTestCase (new LteEnhancedFfrAreaTestCase ("LteEnhancedFfrAreaTestCasePf1", "ns3::PfFfMacScheduler"), TestCase::QUICK);
145  AddTestCase (new LteEnhancedFfrAreaTestCase ("LteEnhancedFfrAreaTestCasePss1", "ns3::PssFfMacScheduler"), TestCase::QUICK);
146  AddTestCase (new LteEnhancedFfrAreaTestCase ("LteEnhancedFfrAreaTestCaseCqa1", "ns3::CqaFfMacScheduler"), TestCase::QUICK);
147  AddTestCase (new LteEnhancedFfrAreaTestCase ("LteEnhancedFfrAreaTestCaseFdTbfq1", "ns3::FdTbfqFfMacScheduler"), TestCase::QUICK);
148  AddTestCase (new LteEnhancedFfrAreaTestCase ("LteEnhancedFfrAreaTestCaseTdTbfq1", "ns3::TdTbfqFfMacScheduler"), TestCase::QUICK);
149 
150  AddTestCase (new LteDistributedFfrAreaTestCase ("LteDistributedFfrAreaTestCasePf1", "ns3::PfFfMacScheduler"), TestCase::QUICK);
151  AddTestCase (new LteDistributedFfrAreaTestCase ("LteDistributedFfrAreaTestCasePss1", "ns3::PssFfMacScheduler"), TestCase::QUICK);
152  AddTestCase (new LteDistributedFfrAreaTestCase ("LteDistributedFfrAreaTestCaseCqa1", "ns3::CqaFfMacScheduler"), TestCase::QUICK);
153  AddTestCase (new LteDistributedFfrAreaTestCase ("LteDistributedFfrAreaTestCaseFdTbfq1", "ns3::FdTbfqFfMacScheduler"), TestCase::QUICK);
154  AddTestCase (new LteDistributedFfrAreaTestCase ("LteDistributedFfrAreaTestCaseTdTbfq1", "ns3::TdTbfqFfMacScheduler"), TestCase::QUICK);
155 }
156 
157 static LteFrequencyReuseTestSuite lteFrequencyReuseTestSuite;
158 
159 
163 void
164 DlDataRxStartNofitication (LteFrTestCase *testcase,
165  Ptr<const SpectrumValue> spectrumValue)
166 {
167  testcase->DlDataRxStart (spectrumValue);
168 }
169 
170 void
171 UlDataRxStartNofitication (LteFrTestCase *testcase,
172  Ptr<const SpectrumValue> spectrumValue)
173 {
174  testcase->UlDataRxStart (spectrumValue);
175 }
176 
177 LteFrTestCase::LteFrTestCase (std::string name,
178  uint32_t userNum,uint8_t dlBandwidth,uint8_t ulBandwidth,
179  std::vector<bool> availableDlRb, std::vector<bool> availableUlRb)
180  : TestCase ("Test: " + name),
181  m_userNum (userNum),
182  m_dlBandwidth (dlBandwidth),
183  m_ulBandwidth (ulBandwidth),
184  m_availableDlRb (availableDlRb),
185  m_usedMutedDlRbg (false),
186  m_availableUlRb (availableUlRb),
187  m_usedMutedUlRbg (false)
188 {
189 }
190 
191 LteFrTestCase::~LteFrTestCase ()
192 {
193 }
194 
195 
196 
197 void
198 LteFrTestCase::DlDataRxStart (Ptr<const SpectrumValue> spectrumValue)
199 {
200  NS_LOG_DEBUG ("DL DATA Power allocation :");
201  Values::const_iterator it;
202  uint32_t i = 0;
203  for (it = spectrumValue->ConstValuesBegin (); it != spectrumValue->ConstValuesEnd (); it++)
204  {
205  double power = (*it) * (m_dlBandwidth * 180000);
206  NS_LOG_DEBUG ("RB " << i << " POWER: " << " " << power << " isAvailable: " << m_availableDlRb[i]);
207 
208  if (m_availableDlRb[i] == false && power > 0)
209  {
210  m_usedMutedDlRbg = true;
211  }
212  i++;
213  }
214 }
215 
216 void
217 LteFrTestCase::UlDataRxStart (Ptr<const SpectrumValue> spectrumValue)
218 {
219  NS_LOG_DEBUG ("UL DATA Power allocation :");
220  Values::const_iterator it;
221  uint32_t i = 0;
222  for (it = spectrumValue->ConstValuesBegin (); it != spectrumValue->ConstValuesEnd (); it++)
223  {
224  double power = (*it) * (m_ulBandwidth * 180000);
225  NS_LOG_DEBUG ("RB " << i << " POWER: " << " " << power << " isAvailable: " << m_availableUlRb[i]);
226 
227  if (m_availableUlRb[i] == false && power > 0)
228  {
229  m_usedMutedUlRbg = true;
230  }
231  i++;
232  }
233 }
234 
235 
236 void
237 LteFrTestCase::DoRun (void)
238 {
239 
240 }
241 
242 
243 LteHardFrTestCase::LteHardFrTestCase (std::string name, uint32_t userNum,
244  std::string schedulerType,
245  uint8_t dlBandwidth, uint8_t ulBandwidth,
246  uint8_t dlSubBandOffset, uint8_t dlSubBandwidth,
247  uint8_t ulSubBandOffset, uint8_t ulSubBandwidth,
248  std::vector<bool> availableDlRb, std::vector<bool> availableUlRb)
249  : LteFrTestCase (name, userNum, dlBandwidth, ulBandwidth, availableDlRb, availableUlRb),
250  m_schedulerType (schedulerType),
251  m_dlSubBandOffset (dlSubBandOffset),
252  m_dlSubBandwidth (dlSubBandwidth),
253  m_ulSubBandOffset (ulSubBandOffset),
254  m_ulSubBandwidth (ulSubBandwidth)
255 {
256  NS_LOG_INFO ("Creating LteDownlinkFrTestCase");
257 }
258 
259 LteHardFrTestCase::~LteHardFrTestCase ()
260 {
261 }
262 
263 void
264 LteHardFrTestCase::DoRun (void)
265 {
266  NS_LOG_DEBUG ("LteFrTestCase");
267 
268  Config::Reset ();
269  Config::SetDefault ("ns3::LteHelper::UseIdealRrc", BooleanValue (false));
270 
275  Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();
276  lteHelper->SetFfrAlgorithmType ("ns3::LteFrHardAlgorithm");
277 
278  lteHelper->SetFfrAlgorithmAttribute ("DlSubBandOffset", UintegerValue (m_dlSubBandOffset));
279  lteHelper->SetFfrAlgorithmAttribute ("DlSubBandwidth", UintegerValue (m_dlSubBandwidth));
280 
281  lteHelper->SetFfrAlgorithmAttribute ("UlSubBandOffset", UintegerValue (m_ulSubBandOffset));
282  lteHelper->SetFfrAlgorithmAttribute ("UlSubBandwidth", UintegerValue (m_ulSubBandwidth));
283 
284 
285  // Create Nodes: eNodeB and UE
286  NodeContainer enbNodes;
287  NodeContainer ueNodes;
288  enbNodes.Create (1);
289  ueNodes.Create (m_userNum);
290  NodeContainer allNodes = NodeContainer ( enbNodes, ueNodes );
291 
292  // Install Mobility Model
293  MobilityHelper mobility;
294  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
295  mobility.Install (allNodes);
296 
297  // Create Devices and install them in the Nodes (eNB and UE)
298  NetDeviceContainer enbDevs;
299  NetDeviceContainer ueDevs;
300  lteHelper->SetSchedulerType (m_schedulerType);
301  enbDevs = lteHelper->InstallEnbDevice (enbNodes);
302  ueDevs = lteHelper->InstallUeDevice (ueNodes);
303 
304  // Attach a UE to a eNB
305  lteHelper->Attach (ueDevs, enbDevs.Get (0));
306 
307  // Activate the default EPS bearer
308  enum EpsBearer::Qci q = EpsBearer::NGBR_VIDEO_TCP_DEFAULT;
309  EpsBearer bearer (q);
310  lteHelper->ActivateDataRadioBearer (ueDevs, bearer);
311 
312  //Test SpectrumPhy to get signals form DL channel
313  Ptr<LteSpectrumPhy> enbDlSpectrumPhy = enbDevs.Get (0)->GetObject<LteEnbNetDevice> ()->GetPhy ()->GetDownlinkSpectrumPhy ()->GetObject<LteSpectrumPhy> ();
314  Ptr<SpectrumChannel> dlChannel = enbDlSpectrumPhy->GetChannel ();
315 
316  Ptr<LteSimpleSpectrumPhy> testDlSpectrumPhy = CreateObject<LteSimpleSpectrumPhy> ();
317  Ptr<LteEnbNetDevice> eNbDev = enbDevs.Get (0)->GetObject<LteEnbNetDevice> ();
318  testDlSpectrumPhy->SetRxSpectrumModel (LteSpectrumValueHelper::GetSpectrumModel (eNbDev->GetDlEarfcn (), m_dlBandwidth));
319  dlChannel->AddRx (testDlSpectrumPhy);
320 
321  testDlSpectrumPhy->TraceConnectWithoutContext ("RxStart",
322  MakeBoundCallback (&DlDataRxStartNofitication, this));
323 
324  //Test SpectrumPhy to get signals form UL channel
325  Ptr<LteSpectrumPhy> ueUlSpectrumPhy = ueDevs.Get (0)->GetObject<LteUeNetDevice> ()->GetPhy ()->GetUplinkSpectrumPhy ()->GetObject<LteSpectrumPhy> ();
326  Ptr<SpectrumChannel> ulChannel = ueUlSpectrumPhy->GetChannel ();
327 
328  Ptr<LteSimpleSpectrumPhy> testUlSpectrumPhy = CreateObject<LteSimpleSpectrumPhy> ();
329  testUlSpectrumPhy->SetRxSpectrumModel (LteSpectrumValueHelper::GetSpectrumModel (eNbDev->GetUlEarfcn (), m_ulBandwidth));
330  ulChannel->AddRx (testUlSpectrumPhy);
331 
332  testUlSpectrumPhy->TraceConnectWithoutContext ("RxStart",
333  MakeBoundCallback (&UlDataRxStartNofitication, this));
334 
335  Simulator::Stop (Seconds (0.500));
336  Simulator::Run ();
337 
338  NS_TEST_ASSERT_MSG_EQ (m_usedMutedDlRbg, false,
339  "Scheduler used DL RBG muted by FFR Algorithm");
340 
341  NS_TEST_ASSERT_MSG_EQ (m_usedMutedUlRbg, false,
342  "Scheduler used UL RBG muted by FFR Algorithm");
343 
344  Simulator::Destroy ();
345 }
346 
347 
348 
349 LteStrictFrTestCase::LteStrictFrTestCase (std::string name, uint32_t userNum,
350  std::string schedulerType,
351  uint8_t dlBandwidth, uint8_t ulBandwidth,
352  uint8_t dlCommonSubBandwidth, uint8_t dlEdgeSubBandOffset, uint8_t dlEdgeSubBandwidth,
353  uint8_t ulCommonSubBandwidth, uint8_t ulEdgeSubBandOffset, uint8_t ulEdgeSubBandwidth,
354  std::vector<bool> availableDlRb, std::vector<bool> availableUlRb)
355  : LteFrTestCase (name, userNum, dlBandwidth, ulBandwidth, availableDlRb, availableUlRb),
356  m_schedulerType (schedulerType),
357  m_dlCommonSubBandwidth (dlCommonSubBandwidth),
358  m_dlEdgeSubBandOffset (dlEdgeSubBandOffset),
359  m_dlEdgeSubBandwidth (dlEdgeSubBandwidth),
360  m_ulCommonSubBandwidth (ulCommonSubBandwidth),
361  m_ulEdgeSubBandOffset (ulEdgeSubBandOffset),
362  m_ulEdgeSubBandwidth (ulEdgeSubBandwidth)
363 {
364  NS_LOG_INFO ("Creating LteFrTestCase");
365 }
366 
367 LteStrictFrTestCase::~LteStrictFrTestCase ()
368 {
369 }
370 
371 void
372 LteStrictFrTestCase::DoRun (void)
373 {
374  NS_LOG_DEBUG ("LteFrTestCase");
375 
376  Config::Reset ();
377  Config::SetDefault ("ns3::LteHelper::UseIdealRrc", BooleanValue (false));
378 
383  Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();
384  lteHelper->SetFfrAlgorithmType ("ns3::LteFrStrictAlgorithm");
385 
386  lteHelper->SetFfrAlgorithmAttribute ("DlCommonSubBandwidth", UintegerValue (m_dlCommonSubBandwidth));
387  lteHelper->SetFfrAlgorithmAttribute ("DlEdgeSubBandOffset", UintegerValue (m_dlEdgeSubBandOffset));
388  lteHelper->SetFfrAlgorithmAttribute ("DlEdgeSubBandwidth", UintegerValue (m_dlEdgeSubBandwidth));
389 
390  lteHelper->SetFfrAlgorithmAttribute ("UlCommonSubBandwidth", UintegerValue (m_ulCommonSubBandwidth));
391  lteHelper->SetFfrAlgorithmAttribute ("UlEdgeSubBandOffset", UintegerValue (m_ulEdgeSubBandOffset));
392  lteHelper->SetFfrAlgorithmAttribute ("UlEdgeSubBandwidth", UintegerValue (m_ulEdgeSubBandwidth));
393 
394  // Create Nodes: eNodeB and UE
395  NodeContainer enbNodes;
396  NodeContainer ueNodes;
397  enbNodes.Create (1);
398  ueNodes.Create (m_userNum);
399  NodeContainer allNodes = NodeContainer ( enbNodes, ueNodes );
400 
401  // Install Mobility Model
402  MobilityHelper mobility;
403  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
404  mobility.Install (allNodes);
405 
406  // Create Devices and install them in the Nodes (eNB and UE)
407  NetDeviceContainer enbDevs;
408  NetDeviceContainer ueDevs;
409  lteHelper->SetSchedulerType (m_schedulerType);
410  enbDevs = lteHelper->InstallEnbDevice (enbNodes);
411  ueDevs = lteHelper->InstallUeDevice (ueNodes);
412 
413  // Attach a UE to a eNB
414  lteHelper->Attach (ueDevs, enbDevs.Get (0));
415 
416  // Activate the default EPS bearer
417  enum EpsBearer::Qci q = EpsBearer::NGBR_VIDEO_TCP_DEFAULT;
418  EpsBearer bearer (q);
419  lteHelper->ActivateDataRadioBearer (ueDevs, bearer);
420 
421  //Test SpectrumPhy to get signals form DL channel
422  Ptr<LteSpectrumPhy> enbDlSpectrumPhy = enbDevs.Get (0)->GetObject<LteEnbNetDevice> ()->GetPhy ()->GetDownlinkSpectrumPhy ()->GetObject<LteSpectrumPhy> ();
423  Ptr<SpectrumChannel> dlChannel = enbDlSpectrumPhy->GetChannel ();
424 
425  Ptr<LteSimpleSpectrumPhy> testDlSpectrumPhy = CreateObject<LteSimpleSpectrumPhy> ();
426  Ptr<LteEnbNetDevice> eNbDev = enbDevs.Get (0)->GetObject<LteEnbNetDevice> ();
427  testDlSpectrumPhy->SetRxSpectrumModel (LteSpectrumValueHelper::GetSpectrumModel (eNbDev->GetDlEarfcn (), m_dlBandwidth));
428  dlChannel->AddRx (testDlSpectrumPhy);
429 
430  testDlSpectrumPhy->TraceConnectWithoutContext ("RxStart",
431  MakeBoundCallback (&DlDataRxStartNofitication, this));
432 
433  //Test SpectrumPhy to get signals form UL channel
434  Ptr<LteSpectrumPhy> ueUlSpectrumPhy = ueDevs.Get (0)->GetObject<LteUeNetDevice> ()->GetPhy ()->GetUplinkSpectrumPhy ()->GetObject<LteSpectrumPhy> ();
435  Ptr<SpectrumChannel> ulChannel = ueUlSpectrumPhy->GetChannel ();
436 
437  Ptr<LteSimpleSpectrumPhy> testUlSpectrumPhy = CreateObject<LteSimpleSpectrumPhy> ();
438  testUlSpectrumPhy->SetRxSpectrumModel (LteSpectrumValueHelper::GetSpectrumModel (eNbDev->GetUlEarfcn (), m_ulBandwidth));
439  ulChannel->AddRx (testUlSpectrumPhy);
440 
441  testUlSpectrumPhy->TraceConnectWithoutContext ("RxStart",
442  MakeBoundCallback (&UlDataRxStartNofitication, this));
443 
444  Simulator::Stop (Seconds (0.500));
445  Simulator::Run ();
446 
447  NS_TEST_ASSERT_MSG_EQ (m_usedMutedDlRbg, false,
448  "Scheduler used DL RBG muted by FFR Algorithm");
449 
450  NS_TEST_ASSERT_MSG_EQ (m_usedMutedUlRbg, false,
451  "Scheduler used UL RBG muted by FFR Algorithm");
452 
453  Simulator::Destroy ();
454 }
455 
456 void
457 DlDataRxStartNofiticationArea (LteFrAreaTestCase *testcase,
458  Ptr<const SpectrumValue> spectrumValue)
459 {
460  testcase->DlDataRxStart (spectrumValue);
461 }
462 
463 void
464 UlDataRxStartNofiticationArea (LteFrAreaTestCase *testcase,
465  Ptr<const SpectrumValue> spectrumValue)
466 {
467  testcase->UlDataRxStart (spectrumValue);
468 }
469 
470 LteFrAreaTestCase::LteFrAreaTestCase (std::string name, std::string schedulerType)
471  : TestCase ("Test: " + name),
472  m_schedulerType (schedulerType)
473 {
474  m_dlBandwidth = 25;
475  m_ulBandwidth = 25;
476  m_usedWrongDlRbg = false;
477  m_usedWrongUlRbg = false;
478 }
479 LteFrAreaTestCase::~LteFrAreaTestCase ()
480 {
481 }
482 
483 void
484 LteFrAreaTestCase::DlDataRxStart (Ptr<const SpectrumValue> spectrumValue)
485 {
486  //need time to report new UE measurements, and wait because of filtering
487  if ( (Simulator::Now () - m_teleportTime ) < MilliSeconds (400))
488  {
489  return;
490  }
491 
492  NS_LOG_DEBUG ("DL DATA Power allocation :");
493  Values::const_iterator it;
494  uint32_t i = 0;
495  for (it = spectrumValue->ConstValuesBegin (); it != spectrumValue->ConstValuesEnd (); it++)
496  {
497  double power = (*it) * (m_dlBandwidth * 180000);
498  NS_LOG_DEBUG ("RB " << i << " POWER: " << " " << power);
499  NS_LOG_DEBUG ("RB " << i << " POWER: " << " " << power
500  << " Available: " << m_expectedDlRb[i] << " Expected Power: " << m_expectedDlPower );
501 
502  if (m_expectedDlRb[i] == false && power > 0)
503  {
504  m_usedWrongDlRbg = true;
505  }
506  else if (m_expectedDlRb[i] == true && power > 0)
507  {
508  NS_TEST_ASSERT_MSG_EQ_TOL (power, m_expectedDlPower, 0.1,
509  "Wrong Data Channel DL Power level");
510  }
511  i++;
512  }
513 }
514 
515 void
516 LteFrAreaTestCase::UlDataRxStart (Ptr<const SpectrumValue> spectrumValue)
517 {
518  //need time to report new UE measurements, and wait because of filtering
519  if ( (Simulator::Now () - m_teleportTime ) < MilliSeconds (400))
520  {
521  return;
522  }
523 
524  NS_LOG_DEBUG ("UL DATA Power allocation :");
525  Values::const_iterator it;
526  uint32_t i = 0;
527  for (it = spectrumValue->ConstValuesBegin (); it != spectrumValue->ConstValuesEnd (); it++)
528  {
529  double power = (*it) * (m_ulBandwidth * 180000);
530  NS_LOG_DEBUG ("RB " << i << " POWER: " << power << " expectedUlPower: " << m_expectedUlPower);
531  if (m_expectedUlRb[i] == false && power > 0)
532  {
533  m_usedWrongUlRbg = true;
534  }
535  else if (m_expectedUlRb[i] == true && power > 0)
536  {
537  NS_TEST_ASSERT_MSG_EQ_TOL (power, m_expectedUlPower, 0.01,
538  "Wrong Data Channel UL Power level" << Simulator::Now ().GetSeconds ());
539  }
540  i++;
541  }
542 }
543 
544 void
545 LteFrAreaTestCase::SimpleTeleportUe (uint32_t x, uint32_t y)
546 {
547  NS_LOG_FUNCTION (this);
548  NS_LOG_DEBUG ("Teleport UE to : (" << x << ", " << y << ", 0)");
549  m_teleportTime = Simulator::Now ();
550  m_ueMobility->SetPosition (Vector (x, y, 0.0));
551 }
552 
553 void
554 LteFrAreaTestCase::TeleportUe (uint32_t x, uint32_t y, double expectedPower,
555  std::vector<bool> expectedDlRb)
556 {
557  NS_LOG_FUNCTION (this);
558  NS_LOG_DEBUG ("Teleport UE to : (" << x << ", " << y << ", 0)");
559  m_teleportTime = Simulator::Now ();
560  m_ueMobility->SetPosition (Vector (x, y, 0.0));
561  m_expectedDlPower = expectedPower;
562  m_expectedDlRb = expectedDlRb;
563 }
564 
565 void
566 LteFrAreaTestCase::TeleportUe2 (Ptr<Node> ueNode, uint32_t x, uint32_t y, double expectedPower,
567  std::vector<bool> expectedDlRb)
568 {
569  NS_LOG_FUNCTION (this);
570  NS_LOG_DEBUG ("Teleport UE to : (" << x << ", " << y << ", 0)");
571 
572  Ptr<MobilityModel> ueMobility = ueNode->GetObject<MobilityModel> ();
573  ueMobility->SetPosition (Vector (x, y, 0.0));
574  m_teleportTime = Simulator::Now ();
575  m_expectedDlPower = expectedPower;
576  m_expectedDlRb = expectedDlRb;
577 }
578 
579 void
580 LteFrAreaTestCase::SetDlExpectedValues (double expectedDlPower, std::vector<bool> expectedDlRb)
581 {
582  NS_LOG_FUNCTION (this);
583  m_expectedDlPower = expectedDlPower;
584  m_expectedDlRb = expectedDlRb;
585 }
586 
587 void
588 LteFrAreaTestCase::SetUlExpectedValues (double expectedUlPower, std::vector<bool> expectedUlRb)
589 {
590  NS_LOG_FUNCTION (this);
591  m_expectedUlPower = expectedUlPower;
592  m_expectedUlRb = expectedUlRb;
593 }
594 
595 void
596 LteFrAreaTestCase::DoRun (void)
597 {
598 }
599 
600 LteStrictFrAreaTestCase::LteStrictFrAreaTestCase (std::string name, std::string schedulerType)
601  : LteFrAreaTestCase (name, schedulerType)
602 {
603  NS_LOG_INFO ("Creating LteFrTestCase");
604 }
605 
606 LteStrictFrAreaTestCase::~LteStrictFrAreaTestCase ()
607 {
608 }
609 
610 void
611 LteStrictFrAreaTestCase::DoRun (void)
612 {
613  NS_LOG_DEBUG ("LteStrictFrAreaTestCase");
614 
615  Config::Reset ();
616  Config::SetDefault ("ns3::LteHelper::UseIdealRrc", BooleanValue (true));
617  Config::SetDefault ("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue (false));
618  Config::SetDefault ("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue (false));
619 
620  double eNbTxPower = 30;
621  Config::SetDefault ("ns3::LteEnbPhy::TxPower", DoubleValue (eNbTxPower));
622  Config::SetDefault ("ns3::LteUePhy::TxPower", DoubleValue (10.0));
623  Config::SetDefault ("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue (true));
624 
625  Config::SetDefault ("ns3::LteUePowerControl::ClosedLoop", BooleanValue (true));
626  Config::SetDefault ("ns3::LteUePowerControl::AccumulationEnabled", BooleanValue (false));
627 
628  Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();
629 
630  // Create Nodes: eNodeB and UE
631  NodeContainer enbNodes;
632  NodeContainer ueNodes1;
633  NodeContainer ueNodes2;
634  enbNodes.Create (2);
635  ueNodes1.Create (1);
636  ueNodes2.Create (1);
637  NodeContainer allNodes = NodeContainer ( enbNodes, ueNodes1, ueNodes2);
638 
639  /*
640  * The topology is the following:
641  *
642  * eNB1 UE1 eNB2
643  * | | |
644  * x ------------ x ------------------------ x ------------ x----UE2
645  * 200 m 600 m 200 m 20 m
646  *
647  */
648 
649  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();
650  positionAlloc->Add (Vector (0.0, 0.0, 0.0)); // eNB1
651  positionAlloc->Add (Vector (1000, 0.0, 0.0)); // eNB2
652  positionAlloc->Add (Vector (0.0, 0.0, 0.0)); // UE1
653  positionAlloc->Add (Vector (1020, 0.0, 0.0)); // UE2
654  MobilityHelper mobility;
655  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
656  mobility.SetPositionAllocator (positionAlloc);
657  mobility.Install (allNodes);
658  m_ueMobility = ueNodes1.Get (0)->GetObject<MobilityModel> ();
659 
660  // Disable layer-3 filtering
661  Config::SetDefault ("ns3::LteEnbRrc::RsrpFilterCoefficient",
662  UintegerValue (0));
663  Config::SetDefault ("ns3::LteEnbRrc::RsrqFilterCoefficient",
664  UintegerValue (0));
665 
666  // Create Devices and install them in the Nodes (eNB and UE)
667  NetDeviceContainer enbDevs;
668  NetDeviceContainer ueDevs1;
669  NetDeviceContainer ueDevs2;
670  lteHelper->SetSchedulerType (m_schedulerType);
671 
672  lteHelper->SetFfrAlgorithmType ("ns3::LteFrStrictAlgorithm");
673  lteHelper->SetFfrAlgorithmAttribute ("RsrqThreshold", UintegerValue (25));
674  lteHelper->SetFfrAlgorithmAttribute ("CenterPowerOffset",
675  UintegerValue (LteRrcSap::PdschConfigDedicated::dB0));
676  lteHelper->SetFfrAlgorithmAttribute ("EdgePowerOffset",
677  UintegerValue (LteRrcSap::PdschConfigDedicated::dB3));
678 
679  lteHelper->SetFfrAlgorithmAttribute ("DlCommonSubBandwidth", UintegerValue (6));
680  lteHelper->SetFfrAlgorithmAttribute ("DlEdgeSubBandOffset", UintegerValue (6));
681  lteHelper->SetFfrAlgorithmAttribute ("DlEdgeSubBandwidth", UintegerValue (6));
682 
683  lteHelper->SetFfrAlgorithmAttribute ("UlCommonSubBandwidth", UintegerValue (6));
684  lteHelper->SetFfrAlgorithmAttribute ("UlEdgeSubBandOffset", UintegerValue (6));
685  lteHelper->SetFfrAlgorithmAttribute ("UlEdgeSubBandwidth", UintegerValue (6));
686  enbDevs.Add (lteHelper->InstallEnbDevice (enbNodes.Get (0)));
687 
688  lteHelper->SetFfrAlgorithmType ("ns3::LteFrNoOpAlgorithm");
689  enbDevs.Add (lteHelper->InstallEnbDevice (enbNodes.Get (1)));
690 
691  ueDevs1 = lteHelper->InstallUeDevice (ueNodes1);
692  ueDevs2 = lteHelper->InstallUeDevice (ueNodes2);
693 
694  // Attach a UE to a eNB
695  lteHelper->Attach (ueDevs1, enbDevs.Get (0));
696  lteHelper->Attach (ueDevs2, enbDevs.Get (1));
697 
698  // Activate an EPS bearer
699  enum EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
700  EpsBearer bearer (q);
701  lteHelper->ActivateDataRadioBearer (ueDevs1, bearer);
702  lteHelper->ActivateDataRadioBearer (ueDevs2, bearer);
703 
704  //Test SpectrumPhy to get signals form DL channel
705  Ptr<LteSpectrumPhy> enbDlSpectrumPhy = enbDevs.Get (0)->GetObject<LteEnbNetDevice> ()->GetPhy ()->GetDownlinkSpectrumPhy ()->GetObject<LteSpectrumPhy> ();
706  Ptr<SpectrumChannel> dlChannel = enbDlSpectrumPhy->GetChannel ();
707 
708  Ptr<LteSimpleSpectrumPhy> testDlSpectrumPhy = CreateObject<LteSimpleSpectrumPhy> ();
709  Ptr<LteEnbNetDevice> eNbDev = enbDevs.Get (0)->GetObject<LteEnbNetDevice> ();
710  testDlSpectrumPhy->SetRxSpectrumModel (LteSpectrumValueHelper::GetSpectrumModel (eNbDev->GetDlEarfcn (), m_dlBandwidth));
711  dlChannel->AddRx (testDlSpectrumPhy);
712 
713  testDlSpectrumPhy->SetCellId (1);
714 
715  testDlSpectrumPhy->TraceConnectWithoutContext ("RxStart",
716  MakeBoundCallback (&DlDataRxStartNofiticationArea, this));
717 
718  //Test SpectrumPhy to get signals form UL channel
719  Ptr<LteSpectrumPhy> ueUlSpectrumPhy = ueDevs1.Get (0)->GetObject<LteUeNetDevice> ()->GetPhy ()->GetUplinkSpectrumPhy ()->GetObject<LteSpectrumPhy> ();
720  Ptr<SpectrumChannel> ulChannel = ueUlSpectrumPhy->GetChannel ();
721 
722  Ptr<LteSimpleSpectrumPhy> testUlSpectrumPhy = CreateObject<LteSimpleSpectrumPhy> ();
723  testUlSpectrumPhy->SetRxSpectrumModel (LteSpectrumValueHelper::GetSpectrumModel (eNbDev->GetUlEarfcn (), m_ulBandwidth));
724  ulChannel->AddRx (testUlSpectrumPhy);
725 
726  testUlSpectrumPhy->SetCellId (1);
727 
728  testUlSpectrumPhy->TraceConnectWithoutContext ("RxStart",
729  MakeBoundCallback (&UlDataRxStartNofiticationArea, this));
730 
731  std::vector<bool> expectedDlRbCenterArea;
732  expectedDlRbCenterArea.resize (m_dlBandwidth, false);
733  std::vector<bool> expectedUlRbCenterArea;
734  expectedUlRbCenterArea.resize (m_ulBandwidth, false);
735  for (uint32_t i = 0; i < 6; i++)
736  {
737  expectedDlRbCenterArea[i] = true;
738  expectedUlRbCenterArea[i] = true;
739  }
740 
741  std::vector<bool> expectedDlRbEdgeArea;
742  expectedDlRbEdgeArea.resize (m_dlBandwidth, false);
743  std::vector<bool> expectedUlRbEdgeArea;
744  expectedUlRbEdgeArea.resize (m_ulBandwidth, false);
745  for (uint32_t i = 12; i < 18; i++)
746  {
747  expectedDlRbEdgeArea[i] = true;
748  expectedUlRbEdgeArea[i] = true;
749  }
750 
751  Simulator::Schedule (MilliSeconds (1),
752  &LteFrAreaTestCase::TeleportUe, this, 200, 0, 1, expectedDlRbCenterArea );
753  Simulator::Schedule (MilliSeconds (1),
754  &LteFrAreaTestCase::SetUlExpectedValues, this, 0.0150543, expectedUlRbCenterArea );
755 
756  Simulator::Schedule (MilliSeconds (501),
757  &LteFrAreaTestCase::TeleportUe, this, 800, 0, 2, expectedDlRbEdgeArea );
758  Simulator::Schedule (MilliSeconds (501),
759  &LteFrAreaTestCase::SetUlExpectedValues, this, 0.199526, expectedUlRbEdgeArea );
760 
761  Simulator::Schedule (MilliSeconds (1001),
762  &LteFrAreaTestCase::TeleportUe, this, 200, 0, 1, expectedDlRbCenterArea );
763  Simulator::Schedule (MilliSeconds (1001),
764  &LteFrAreaTestCase::SetUlExpectedValues, this, 0.0150543, expectedUlRbCenterArea );
765 
766  Simulator::Stop (Seconds (1.500));
767  Simulator::Run ();
768 
769  NS_TEST_ASSERT_MSG_EQ (m_usedWrongDlRbg, false,
770  "Scheduler used DL RB muted by FFR Algorithm");
771  NS_TEST_ASSERT_MSG_EQ (m_usedWrongUlRbg, false,
772  "Scheduler used UL RB muted by FFR Algorithm");
773 
774  Simulator::Destroy ();
775 }
776 
777 LteSoftFrAreaTestCase::LteSoftFrAreaTestCase (std::string name, std::string schedulerType)
778  : LteFrAreaTestCase (name, schedulerType)
779 {
780  NS_LOG_INFO ("Creating LteSoftFrAreaTestCase");
781 }
782 
783 LteSoftFrAreaTestCase::~LteSoftFrAreaTestCase ()
784 {
785 }
786 
787 void
788 LteSoftFrAreaTestCase::DoRun (void)
789 {
790  NS_LOG_DEBUG ("LteSoftFrAreaTestCase");
791 
792  Config::Reset ();
793  Config::SetDefault ("ns3::LteHelper::UseIdealRrc", BooleanValue (true));
794  Config::SetDefault ("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue (false));
795  Config::SetDefault ("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue (false));
796 
797  double eNbTxPower = 30;
798  Config::SetDefault ("ns3::LteEnbPhy::TxPower", DoubleValue (eNbTxPower));
799  Config::SetDefault ("ns3::LteUePhy::TxPower", DoubleValue (10.0));
800  Config::SetDefault ("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue (true));
801 
802  Config::SetDefault ("ns3::LteUePowerControl::ClosedLoop", BooleanValue (true));
803  Config::SetDefault ("ns3::LteUePowerControl::AccumulationEnabled", BooleanValue (false));
804 
805  Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();
806 
807  // Create Nodes: eNodeB and UE
808  NodeContainer enbNodes;
809  NodeContainer ueNodes1;
810  NodeContainer ueNodes2;
811  enbNodes.Create (2);
812  ueNodes1.Create (1);
813  ueNodes2.Create (1);
814  NodeContainer allNodes = NodeContainer ( enbNodes, ueNodes1, ueNodes2);
815 
816  /*
817  * The topology is the following:
818  *
819  * eNB1 UE1 eNB2
820  * | | |
821  * x ------------ x ------------------------ x ------------ x----UE2
822  * 200 m 600 m 200 m 20 m
823  *
824  */
825 
826  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();
827  positionAlloc->Add (Vector (0.0, 0.0, 0.0)); // eNB1
828  positionAlloc->Add (Vector (1000, 0.0, 0.0)); // eNB2
829  positionAlloc->Add (Vector (0.0, 0.0, 0.0)); // UE1
830  positionAlloc->Add (Vector (1020, 0.0, 0.0)); // UE2
831  MobilityHelper mobility;
832  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
833  mobility.SetPositionAllocator (positionAlloc);
834  mobility.Install (allNodes);
835  m_ueMobility = ueNodes1.Get (0)->GetObject<MobilityModel> ();
836 
837  // Disable layer-3 filtering
838  Config::SetDefault ("ns3::LteEnbRrc::RsrpFilterCoefficient",
839  UintegerValue (0));
840  Config::SetDefault ("ns3::LteEnbRrc::RsrqFilterCoefficient",
841  UintegerValue (0));
842 
843  // Create Devices and install them in the Nodes (eNB and UE)
844  NetDeviceContainer enbDevs;
845  NetDeviceContainer ueDevs1;
846  NetDeviceContainer ueDevs2;
847  lteHelper->SetSchedulerType (m_schedulerType);
848 
849  lteHelper->SetFfrAlgorithmType ("ns3::LteFrSoftAlgorithm");
850  lteHelper->SetFfrAlgorithmAttribute ("AllowCenterUeUseEdgeSubBand", BooleanValue (false));
851  lteHelper->SetFfrAlgorithmAttribute ("RsrqThreshold", UintegerValue (25));
852  lteHelper->SetFfrAlgorithmAttribute ("CenterPowerOffset",
853  UintegerValue (LteRrcSap::PdschConfigDedicated::dB0));
854  lteHelper->SetFfrAlgorithmAttribute ("EdgePowerOffset",
855  UintegerValue (LteRrcSap::PdschConfigDedicated::dB3));
856 
857  lteHelper->SetFfrAlgorithmAttribute ("DlEdgeSubBandOffset", UintegerValue (8));
858  lteHelper->SetFfrAlgorithmAttribute ("DlEdgeSubBandwidth", UintegerValue (8));
859  lteHelper->SetFfrAlgorithmAttribute ("UlEdgeSubBandOffset", UintegerValue (8));
860  lteHelper->SetFfrAlgorithmAttribute ("UlEdgeSubBandwidth", UintegerValue (8));
861  enbDevs.Add (lteHelper->InstallEnbDevice (enbNodes.Get (0)));
862 
863  lteHelper->SetFfrAlgorithmType ("ns3::LteFrNoOpAlgorithm");
864  enbDevs.Add (lteHelper->InstallEnbDevice (enbNodes.Get (1)));
865 
866  ueDevs1 = lteHelper->InstallUeDevice (ueNodes1);
867  ueDevs2 = lteHelper->InstallUeDevice (ueNodes2);
868 
869  // Attach a UE to a eNB
870  lteHelper->Attach (ueDevs1, enbDevs.Get (0));
871  lteHelper->Attach (ueDevs2, enbDevs.Get (1));
872 
873  // Activate an EPS bearer
874  enum EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
875  EpsBearer bearer (q);
876  lteHelper->ActivateDataRadioBearer (ueDevs1, bearer);
877  lteHelper->ActivateDataRadioBearer (ueDevs2, bearer);
878 
879  //Test SpectrumPhy to get signals form DL channel
880  Ptr<LteSpectrumPhy> enbDlSpectrumPhy = enbDevs.Get (0)->GetObject<LteEnbNetDevice> ()->GetPhy ()->GetDownlinkSpectrumPhy ()->GetObject<LteSpectrumPhy> ();
881  Ptr<SpectrumChannel> dlChannel = enbDlSpectrumPhy->GetChannel ();
882 
883  Ptr<LteSimpleSpectrumPhy> testDlSpectrumPhy = CreateObject<LteSimpleSpectrumPhy> ();
884  Ptr<LteEnbNetDevice> eNbDev = enbDevs.Get (0)->GetObject<LteEnbNetDevice> ();
885  testDlSpectrumPhy->SetRxSpectrumModel (LteSpectrumValueHelper::GetSpectrumModel (eNbDev->GetDlEarfcn (), m_dlBandwidth));
886  dlChannel->AddRx (testDlSpectrumPhy);
887 
888  testDlSpectrumPhy->SetCellId (1);
889 
890  testDlSpectrumPhy->TraceConnectWithoutContext ("RxStart",
891  MakeBoundCallback (&DlDataRxStartNofiticationArea, this));
892 
893  //Test SpectrumPhy to get signals form UL channel
894  Ptr<LteSpectrumPhy> ueUlSpectrumPhy = ueDevs1.Get (0)->GetObject<LteUeNetDevice> ()->GetPhy ()->GetUplinkSpectrumPhy ()->GetObject<LteSpectrumPhy> ();
895  Ptr<SpectrumChannel> ulChannel = ueUlSpectrumPhy->GetChannel ();
896 
897  Ptr<LteSimpleSpectrumPhy> testUlSpectrumPhy = CreateObject<LteSimpleSpectrumPhy> ();
898  testUlSpectrumPhy->SetRxSpectrumModel (LteSpectrumValueHelper::GetSpectrumModel (eNbDev->GetUlEarfcn (), m_ulBandwidth));
899  ulChannel->AddRx (testUlSpectrumPhy);
900 
901  testUlSpectrumPhy->SetCellId (1);
902 
903  testUlSpectrumPhy->TraceConnectWithoutContext ("RxStart",
904  MakeBoundCallback (&UlDataRxStartNofiticationArea, this));
905 
906 
907  std::vector<bool> expectedDlRbCenterArea;
908  expectedDlRbCenterArea.resize (m_dlBandwidth, false);
909  std::vector<bool> expectedUlRbCenterArea;
910  expectedUlRbCenterArea.resize (m_ulBandwidth, false);
911  for (uint32_t i = 0; i < 8; i++)
912  {
913  expectedDlRbCenterArea[i] = true;
914  expectedUlRbCenterArea[i] = true;
915  }
916  for (uint32_t i = 16; i < 25; i++)
917  {
918  expectedDlRbCenterArea[i] = true;
919  }
920 
921  std::vector<bool> expectedDlRbEdgeArea;
922  expectedDlRbEdgeArea.resize (m_dlBandwidth, false);
923  std::vector<bool> expectedUlRbEdgeArea;
924  expectedUlRbEdgeArea.resize (m_ulBandwidth, false);
925  for (uint32_t i = 8; i < 16; i++)
926  {
927  expectedDlRbEdgeArea[i] = true;
928  expectedUlRbEdgeArea[i] = true;
929  }
930 
931  Simulator::Schedule (MilliSeconds (1),
932  &LteFrAreaTestCase::TeleportUe, this, 200, 0, 1, expectedDlRbCenterArea );
933  Simulator::Schedule (MilliSeconds (1),
934  &LteFrAreaTestCase::SetUlExpectedValues, this, 0.0150543, expectedUlRbCenterArea );
935 
936  Simulator::Schedule (MilliSeconds (501),
937  &LteFrAreaTestCase::TeleportUe, this, 800, 0, 2, expectedDlRbEdgeArea );
938  Simulator::Schedule (MilliSeconds (501),
939  &LteFrAreaTestCase::SetUlExpectedValues, this, 0.199526, expectedUlRbEdgeArea );
940 
941  Simulator::Schedule (MilliSeconds (1001),
942  &LteFrAreaTestCase::TeleportUe, this, 200, 0, 1, expectedDlRbCenterArea );
943  Simulator::Schedule (MilliSeconds (1001),
944  &LteFrAreaTestCase::SetUlExpectedValues, this, 0.0150543, expectedUlRbCenterArea );
945 
946  Simulator::Stop (Seconds (1.500));
947  Simulator::Run ();
948 
949 #if 0
950  NS_TEST_ASSERT_MSG_EQ (m_usedWrongDlRbg, false,
951  "Scheduler used DL RBG muted by FFR Algorithm");
952 
953 #endif
954  NS_TEST_ASSERT_MSG_EQ (m_usedWrongUlRbg, false,
955  "Scheduler used UL RB muted by FFR Algorithm");
956 
957  Simulator::Destroy ();
958 }
959 
960 LteSoftFfrAreaTestCase::LteSoftFfrAreaTestCase (std::string name, std::string schedulerType)
961  : LteFrAreaTestCase (name, schedulerType)
962 {
963  NS_LOG_INFO ("Creating LteSoftFfrAreaTestCase");
964 }
965 
966 LteSoftFfrAreaTestCase::~LteSoftFfrAreaTestCase ()
967 {
968 }
969 
970 void
971 LteSoftFfrAreaTestCase::DoRun (void)
972 {
973  NS_LOG_DEBUG ("LteSoftFfrAreaTestCase");
974 
975  Config::Reset ();
976  Config::SetDefault ("ns3::LteHelper::UseIdealRrc", BooleanValue (true));
977  Config::SetDefault ("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue (false));
978  Config::SetDefault ("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue (false));
979 
980  double eNbTxPower = 30;
981  Config::SetDefault ("ns3::LteEnbPhy::TxPower", DoubleValue (eNbTxPower));
982  Config::SetDefault ("ns3::LteUePhy::TxPower", DoubleValue (10.0));
983  Config::SetDefault ("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue (true));
984 
985  Config::SetDefault ("ns3::LteUePowerControl::ClosedLoop", BooleanValue (true));
986  Config::SetDefault ("ns3::LteUePowerControl::AccumulationEnabled", BooleanValue (false));
987 
988  Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();
989 
990  // Create Nodes: eNodeB and UE
991  NodeContainer enbNodes;
992  NodeContainer ueNodes1;
993  NodeContainer ueNodes2;
994  enbNodes.Create (2);
995  ueNodes1.Create (1);
996  ueNodes2.Create (1);
997  NodeContainer allNodes = NodeContainer ( enbNodes, ueNodes1, ueNodes2);
998 
999  /*
1000  * The topology is the following:
1001  *
1002  * eNB1 UE1 eNB2
1003  * | | |
1004  * x ------------ x ------------------------ x ------------ x----UE2
1005  * 200 m 600 m 200 m 20 m
1006  *
1007  */
1008 
1009  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();
1010  positionAlloc->Add (Vector (0.0, 0.0, 0.0)); // eNB1
1011  positionAlloc->Add (Vector (1000, 0.0, 0.0)); // eNB2
1012  positionAlloc->Add (Vector (0.0, 0.0, 0.0)); // UE1
1013  positionAlloc->Add (Vector (1020, 0.0, 0.0)); // UE2
1014  MobilityHelper mobility;
1015  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
1016  mobility.SetPositionAllocator (positionAlloc);
1017  mobility.Install (allNodes);
1018  m_ueMobility = ueNodes1.Get (0)->GetObject<MobilityModel> ();
1019 
1020  // Disable layer-3 filtering
1021  Config::SetDefault ("ns3::LteEnbRrc::RsrpFilterCoefficient",
1022  UintegerValue (0));
1023  Config::SetDefault ("ns3::LteEnbRrc::RsrqFilterCoefficient",
1024  UintegerValue (0));
1025 
1026  // Create Devices and install them in the Nodes (eNB and UE)
1027  NetDeviceContainer enbDevs;
1028  NetDeviceContainer ueDevs1;
1029  NetDeviceContainer ueDevs2;
1030  lteHelper->SetSchedulerType (m_schedulerType);
1031 
1032  lteHelper->SetFfrAlgorithmType ("ns3::LteFfrSoftAlgorithm");
1033  lteHelper->SetFfrAlgorithmAttribute ("CenterRsrqThreshold", UintegerValue (28));
1034  lteHelper->SetFfrAlgorithmAttribute ("EdgeRsrqThreshold", UintegerValue (18));
1035  lteHelper->SetFfrAlgorithmAttribute ("CenterAreaPowerOffset",
1036  UintegerValue (LteRrcSap::PdschConfigDedicated::dB_3));
1037  lteHelper->SetFfrAlgorithmAttribute ("MediumAreaPowerOffset",
1038  UintegerValue (LteRrcSap::PdschConfigDedicated::dB0));
1039  lteHelper->SetFfrAlgorithmAttribute ("EdgeAreaPowerOffset",
1040  UintegerValue (LteRrcSap::PdschConfigDedicated::dB3));
1041 
1042  lteHelper->SetFfrAlgorithmAttribute ("UlCommonSubBandwidth", UintegerValue (6));
1043  lteHelper->SetFfrAlgorithmAttribute ("DlCommonSubBandwidth", UintegerValue (6));
1044 
1045  lteHelper->SetFfrAlgorithmAttribute ("DlEdgeSubBandOffset", UintegerValue (6));
1046  lteHelper->SetFfrAlgorithmAttribute ("DlEdgeSubBandwidth", UintegerValue (6));
1047  lteHelper->SetFfrAlgorithmAttribute ("UlEdgeSubBandOffset", UintegerValue (6));
1048  lteHelper->SetFfrAlgorithmAttribute ("UlEdgeSubBandwidth", UintegerValue (6));
1049  enbDevs.Add (lteHelper->InstallEnbDevice (enbNodes.Get (0)));
1050 
1051  lteHelper->SetFfrAlgorithmType ("ns3::LteFrNoOpAlgorithm");
1052  enbDevs.Add (lteHelper->InstallEnbDevice (enbNodes.Get (1)));
1053 
1054  ueDevs1 = lteHelper->InstallUeDevice (ueNodes1);
1055  ueDevs2 = lteHelper->InstallUeDevice (ueNodes2);
1056 
1057  // Attach a UE to a eNB
1058  lteHelper->Attach (ueDevs1, enbDevs.Get (0));
1059  lteHelper->Attach (ueDevs2, enbDevs.Get (1));
1060 
1061  // Activate an EPS bearer
1062  enum EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
1063  EpsBearer bearer (q);
1064  lteHelper->ActivateDataRadioBearer (ueDevs1, bearer);
1065  lteHelper->ActivateDataRadioBearer (ueDevs2, bearer);
1066 
1067  //Test SpectrumPhy to get signals form DL channel
1068  Ptr<LteSpectrumPhy> enbDlSpectrumPhy = enbDevs.Get (0)->GetObject<LteEnbNetDevice> ()->GetPhy ()->GetDownlinkSpectrumPhy ()->GetObject<LteSpectrumPhy> ();
1069  Ptr<SpectrumChannel> dlChannel = enbDlSpectrumPhy->GetChannel ();
1070 
1071  Ptr<LteSimpleSpectrumPhy> testDlSpectrumPhy = CreateObject<LteSimpleSpectrumPhy> ();
1072  Ptr<LteEnbNetDevice> eNbDev = enbDevs.Get (0)->GetObject<LteEnbNetDevice> ();
1073  testDlSpectrumPhy->SetRxSpectrumModel (LteSpectrumValueHelper::GetSpectrumModel (eNbDev->GetDlEarfcn (), m_dlBandwidth));
1074  dlChannel->AddRx (testDlSpectrumPhy);
1075 
1076  testDlSpectrumPhy->SetCellId (1);
1077 
1078  testDlSpectrumPhy->TraceConnectWithoutContext ("RxStart",
1079  MakeBoundCallback (&DlDataRxStartNofiticationArea, this));
1080 
1081  //Test SpectrumPhy to get signals form UL channel
1082  Ptr<LteSpectrumPhy> ueUlSpectrumPhy = ueDevs1.Get (0)->GetObject<LteUeNetDevice> ()->GetPhy ()->GetUplinkSpectrumPhy ()->GetObject<LteSpectrumPhy> ();
1083  Ptr<SpectrumChannel> ulChannel = ueUlSpectrumPhy->GetChannel ();
1084 
1085  Ptr<LteSimpleSpectrumPhy> testUlSpectrumPhy = CreateObject<LteSimpleSpectrumPhy> ();
1086  testUlSpectrumPhy->SetRxSpectrumModel (LteSpectrumValueHelper::GetSpectrumModel (eNbDev->GetUlEarfcn (), m_ulBandwidth));
1087  ulChannel->AddRx (testUlSpectrumPhy);
1088 
1089  testUlSpectrumPhy->SetCellId (1);
1090 
1091  testUlSpectrumPhy->TraceConnectWithoutContext ("RxStart",
1092  MakeBoundCallback (&UlDataRxStartNofiticationArea, this));
1093 
1094  double expectedDlPowerCenterArea = 0.5;
1095  std::vector<bool> expectedDlRbCenterArea;
1096  expectedDlRbCenterArea.resize (m_dlBandwidth, false);
1097  std::vector<bool> expectedUlRbCenterArea;
1098  expectedUlRbCenterArea.resize (m_ulBandwidth, false);
1099  for (uint32_t i = 6; i < 12; i++)
1100  {
1101  expectedDlRbCenterArea[i] = true;
1102  expectedUlRbCenterArea[i] = true;
1103  }
1104  for (uint32_t i = 18; i < 25; i++)
1105  {
1106  expectedDlRbCenterArea[i] = true;
1107  expectedUlRbCenterArea[i] = true;
1108  }
1109 
1110  double expectedDlPowerMiddleArea = 1.0;
1111  std::vector<bool> expectedDlRbMiddleArea;
1112  expectedDlRbMiddleArea.resize (m_dlBandwidth, false);
1113  std::vector<bool> expectedUlRbMiddleArea;
1114  expectedUlRbMiddleArea.resize (m_ulBandwidth, false);
1115  for (uint32_t i = 0; i < 6; i++)
1116  {
1117  expectedDlRbMiddleArea[i] = true;
1118  expectedUlRbMiddleArea[i] = true;
1119  }
1120 
1121  double expectedDlPowerEdgeArea = 2.0;
1122  std::vector<bool> expectedDlRbEdgeArea;
1123  expectedDlRbEdgeArea.resize (m_dlBandwidth, false);
1124  std::vector<bool> expectedUlRbEdgeArea;
1125  expectedUlRbEdgeArea.resize (m_ulBandwidth, false);
1126  for (uint32_t i = 12; i < 18; i++)
1127  {
1128  expectedDlRbEdgeArea[i] = true;
1129  expectedUlRbEdgeArea[i] = true;
1130  }
1131 
1132  Simulator::Schedule (MilliSeconds (1),
1133  &LteFrAreaTestCase::TeleportUe, this, 200, 0,
1134  expectedDlPowerCenterArea, expectedDlRbCenterArea );
1135  Simulator::Schedule (MilliSeconds (1),
1136  &LteFrAreaTestCase::SetUlExpectedValues, this, 0.0150543, expectedUlRbCenterArea );
1137 
1138  Simulator::Schedule (MilliSeconds (501),
1139  &LteFrAreaTestCase::TeleportUe, this, 600, 0,
1140  expectedDlPowerMiddleArea, expectedDlRbMiddleArea );
1141  Simulator::Schedule (MilliSeconds (501),
1142  &LteFrAreaTestCase::SetUlExpectedValues, this, 0.135489, expectedUlRbMiddleArea );
1143 
1144  Simulator::Schedule (MilliSeconds (1001),
1145  &LteFrAreaTestCase::TeleportUe, this, 800, 0,
1146  expectedDlPowerEdgeArea, expectedDlRbEdgeArea );
1147  Simulator::Schedule (MilliSeconds (1001),
1148  &LteFrAreaTestCase::SetUlExpectedValues, this, 0.199526, expectedUlRbEdgeArea );
1149 
1150  Simulator::Schedule (MilliSeconds (1501),
1151  &LteFrAreaTestCase::TeleportUe, this, 600, 0,
1152  expectedDlPowerMiddleArea, expectedDlRbMiddleArea );
1153  Simulator::Schedule (MilliSeconds (1501),
1154  &LteFrAreaTestCase::SetUlExpectedValues, this, 0.135489, expectedUlRbMiddleArea );
1155 
1156  Simulator::Schedule (MilliSeconds (2001),
1157  &LteFrAreaTestCase::TeleportUe, this, 200, 0,
1158  expectedDlPowerCenterArea, expectedDlRbCenterArea );
1159  Simulator::Schedule (MilliSeconds (2001),
1160  &LteFrAreaTestCase::SetUlExpectedValues, this, 0.0150543, expectedUlRbCenterArea );
1161 
1162  Simulator::Stop (Seconds (2.500));
1163  Simulator::Run ();
1164 
1165  NS_TEST_ASSERT_MSG_EQ (m_usedWrongDlRbg, false,
1166  "Scheduler used DL RBG muted by FFR Algorithm");
1167 
1168  NS_TEST_ASSERT_MSG_EQ (m_usedWrongUlRbg, false,
1169  "Scheduler used UL RB muted by FFR Algorithm");
1170 
1171  Simulator::Destroy ();
1172 }
1173 
1174 
1175 LteEnhancedFfrAreaTestCase::LteEnhancedFfrAreaTestCase (std::string name, std::string schedulerType)
1176  : LteFrAreaTestCase (name, schedulerType)
1177 {
1178  NS_LOG_INFO ("Creating LteEnhancedFfrAreaTestCase");
1179 }
1180 
1181 LteEnhancedFfrAreaTestCase::~LteEnhancedFfrAreaTestCase ()
1182 {
1183 }
1184 
1185 void
1186 LteEnhancedFfrAreaTestCase::DoRun (void)
1187 {
1188  NS_LOG_DEBUG ("LteEnhancedFfrAreaTestCase");
1189 
1190  Config::Reset ();
1191  Config::SetDefault ("ns3::LteHelper::UseIdealRrc", BooleanValue (true));
1192  Config::SetDefault ("ns3::LteHelper::UsePdschForCqiGeneration", BooleanValue (true));
1193  Config::SetDefault ("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue (false));
1194  Config::SetDefault ("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue (false));
1195 
1196  double eNbTxPower = 30;
1197  Config::SetDefault ("ns3::LteEnbPhy::TxPower", DoubleValue (eNbTxPower));
1198  Config::SetDefault ("ns3::LteUePhy::TxPower", DoubleValue (10.0));
1199  Config::SetDefault ("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue (true));
1200 
1201  Config::SetDefault ("ns3::LteUePowerControl::ClosedLoop", BooleanValue (true));
1202  Config::SetDefault ("ns3::LteUePowerControl::AccumulationEnabled", BooleanValue (false));
1203 
1204 
1205  Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();
1206 
1207  // Create Nodes: eNodeB and UE
1208  NodeContainer enbNodes;
1209  NodeContainer ueNodes1;
1210  NodeContainer ueNodes2;
1211  enbNodes.Create (2);
1212  ueNodes1.Create (1);
1213  ueNodes2.Create (1);
1214  NodeContainer allNodes = NodeContainer ( enbNodes, ueNodes1, ueNodes2);
1215 
1216  /*
1217  * The topology is the following:
1218  *
1219  * eNB1 UE1 eNB2
1220  * | | |
1221  * x ------------ x ------------------------ x ------------ x----UE2
1222  * 200 m 600 m 200 m 20 m
1223  *
1224  */
1225 
1226  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();
1227  positionAlloc->Add (Vector (0.0, 0.0, 0.0)); // eNB1
1228  positionAlloc->Add (Vector (1000, 0.0, 0.0)); // eNB2
1229  positionAlloc->Add (Vector (0.0, 0.0, 0.0)); // UE1
1230  positionAlloc->Add (Vector (1020, 0.0, 0.0)); // UE2
1231  MobilityHelper mobility;
1232  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
1233  mobility.SetPositionAllocator (positionAlloc);
1234  mobility.Install (allNodes);
1235  m_ueMobility = ueNodes1.Get (0)->GetObject<MobilityModel> ();
1236 
1237  // Disable layer-3 filtering
1238  Config::SetDefault ("ns3::LteEnbRrc::RsrpFilterCoefficient",
1239  UintegerValue (0));
1240  Config::SetDefault ("ns3::LteEnbRrc::RsrqFilterCoefficient",
1241  UintegerValue (0));
1242 
1243  // Create Devices and install them in the Nodes (eNB and UE)
1244  NetDeviceContainer enbDevs;
1245  NetDeviceContainer ueDevs1;
1246  NetDeviceContainer ueDevs2;
1247  lteHelper->SetSchedulerType (m_schedulerType);
1248  lteHelper->SetSchedulerAttribute ("HarqEnabled", BooleanValue (true));
1249 
1250  lteHelper->SetEnbDeviceAttribute ("DlBandwidth", UintegerValue (m_dlBandwidth));
1251  lteHelper->SetEnbDeviceAttribute ("UlBandwidth", UintegerValue (m_ulBandwidth));
1252 
1253  lteHelper->SetFfrAlgorithmType ("ns3::LteFfrEnhancedAlgorithm");
1254  lteHelper->SetFfrAlgorithmAttribute ("RsrqThreshold", UintegerValue (25));
1255  lteHelper->SetFfrAlgorithmAttribute ("DlCqiThreshold", UintegerValue (10));
1256  lteHelper->SetFfrAlgorithmAttribute ("UlCqiThreshold", UintegerValue (15));
1257  lteHelper->SetFfrAlgorithmAttribute ("CenterAreaPowerOffset",
1258  UintegerValue (LteRrcSap::PdschConfigDedicated::dB_6));
1259  lteHelper->SetFfrAlgorithmAttribute ("EdgeAreaPowerOffset",
1260  UintegerValue (LteRrcSap::PdschConfigDedicated::dB0));
1261 
1262  lteHelper->SetFfrAlgorithmAttribute ("UlSubBandOffset", UintegerValue (0));
1263  lteHelper->SetFfrAlgorithmAttribute ("UlReuse3SubBandwidth", UintegerValue (4));
1264  lteHelper->SetFfrAlgorithmAttribute ("UlReuse1SubBandwidth", UintegerValue (4));
1265 
1266  lteHelper->SetFfrAlgorithmAttribute ("DlSubBandOffset", UintegerValue (0));
1267  lteHelper->SetFfrAlgorithmAttribute ("DlReuse3SubBandwidth", UintegerValue (4));
1268  lteHelper->SetFfrAlgorithmAttribute ("DlReuse1SubBandwidth", UintegerValue (4));
1269 
1270  enbDevs.Add (lteHelper->InstallEnbDevice (enbNodes.Get (0)));
1271 
1272  lteHelper->SetFfrAlgorithmType ("ns3::LteFrNoOpAlgorithm");
1273  enbDevs.Add (lteHelper->InstallEnbDevice (enbNodes.Get (1)));
1274 
1275  ueDevs1 = lteHelper->InstallUeDevice (ueNodes1);
1276  ueDevs2 = lteHelper->InstallUeDevice (ueNodes2);
1277 
1278  // Attach a UE to a eNB
1279  lteHelper->Attach (ueDevs1, enbDevs.Get (0));
1280  lteHelper->Attach (ueDevs2, enbDevs.Get (1));
1281 
1282  // Activate an EPS bearer
1283  enum EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
1284  EpsBearer bearer (q);
1285  lteHelper->ActivateDataRadioBearer (ueDevs1, bearer);
1286  lteHelper->ActivateDataRadioBearer (ueDevs2, bearer);
1287 
1288  //Test SpectrumPhy to get signals form DL channel
1289  Ptr<LteSpectrumPhy> enbDlSpectrumPhy = enbDevs.Get (0)->GetObject<LteEnbNetDevice> ()->GetPhy ()->GetDownlinkSpectrumPhy ()->GetObject<LteSpectrumPhy> ();
1290  Ptr<SpectrumChannel> dlChannel = enbDlSpectrumPhy->GetChannel ();
1291 
1292  Ptr<LteSimpleSpectrumPhy> testDlSpectrumPhy = CreateObject<LteSimpleSpectrumPhy> ();
1293  Ptr<LteEnbNetDevice> eNbDev = enbDevs.Get (0)->GetObject<LteEnbNetDevice> ();
1294  testDlSpectrumPhy->SetRxSpectrumModel (LteSpectrumValueHelper::GetSpectrumModel (eNbDev->GetDlEarfcn (), m_dlBandwidth));
1295  dlChannel->AddRx (testDlSpectrumPhy);
1296 
1297  testDlSpectrumPhy->SetCellId (1);
1298 
1299  testDlSpectrumPhy->TraceConnectWithoutContext ("RxStart",
1300  MakeBoundCallback (&DlDataRxStartNofiticationArea, this));
1301 
1302  //Test SpectrumPhy to get signals form UL channel
1303  Ptr<LteSpectrumPhy> ueUlSpectrumPhy = ueDevs1.Get (0)->GetObject<LteUeNetDevice> ()->GetPhy ()->GetUplinkSpectrumPhy ()->GetObject<LteSpectrumPhy> ();
1304  Ptr<SpectrumChannel> ulChannel = ueUlSpectrumPhy->GetChannel ();
1305 
1306  Ptr<LteSimpleSpectrumPhy> testUlSpectrumPhy = CreateObject<LteSimpleSpectrumPhy> ();
1307  testUlSpectrumPhy->SetRxSpectrumModel (LteSpectrumValueHelper::GetSpectrumModel (eNbDev->GetUlEarfcn (), m_ulBandwidth));
1308  ulChannel->AddRx (testUlSpectrumPhy);
1309 
1310  testUlSpectrumPhy->SetCellId (1);
1311 
1312  testUlSpectrumPhy->TraceConnectWithoutContext ("RxStart",
1313  MakeBoundCallback (&UlDataRxStartNofiticationArea, this));
1314 
1315  double expectedDlPowerCenterArea = 0.251189;
1316  std::vector<bool> expectedDlRbCenterArea;
1317  expectedDlRbCenterArea.resize (m_dlBandwidth, false);
1318  std::vector<bool> expectedUlRbCenterArea;
1319  expectedUlRbCenterArea.resize (m_ulBandwidth, false);
1320  for (uint32_t i = 0; i < 8; i++)
1321  {
1322  expectedDlRbCenterArea[i] = true;
1323  expectedUlRbCenterArea[i] = true;
1324  }
1325  for (uint32_t i = 12; i < 16; i++)
1326  {
1327  expectedDlRbCenterArea[i] = true;
1328  expectedUlRbCenterArea[i] = true;
1329  }
1330  for (uint32_t i = 20; i < 24; i++)
1331  {
1332  expectedDlRbCenterArea[i] = true;
1333  expectedUlRbCenterArea[i] = true;
1334  }
1335 
1336  double expectedDlPowerMiddleArea = 0.251189;
1337  std::vector<bool> expectedDlRbMiddleArea;
1338  expectedDlRbMiddleArea.resize (m_dlBandwidth, false);
1339  std::vector<bool> expectedUlRbMiddleArea;
1340  expectedUlRbMiddleArea.resize (m_ulBandwidth, false);
1341  for (uint32_t i = 4; i < 8; i++)
1342  {
1343  expectedDlRbMiddleArea[i] = true;
1344  expectedUlRbMiddleArea[i] = true;
1345  }
1346 
1347  double expectedDlPowerEdgeArea = 1.0;
1348  std::vector<bool> expectedDlRbEdgeArea;
1349  expectedDlRbEdgeArea.resize (m_dlBandwidth, false);
1350  std::vector<bool> expectedUlRbEdgeArea;
1351  expectedUlRbEdgeArea.resize (m_ulBandwidth, false);
1352  for (uint32_t i = 0; i < 4; i++)
1353  {
1354  expectedDlRbEdgeArea[i] = true;
1355  expectedUlRbEdgeArea[i] = true;
1356  }
1357 
1358  Simulator::Schedule (MilliSeconds (1),
1359  &LteEnhancedFfrAreaTestCase::TeleportUe, this, 100, 0,
1360  expectedDlPowerCenterArea, expectedDlRbCenterArea );
1361  Simulator::Schedule (MilliSeconds (1),
1362  &LteFrAreaTestCase::SetUlExpectedValues, this, 0.00250905, expectedUlRbCenterArea );
1363 
1364  Simulator::Schedule (MilliSeconds (501),
1365  &LteEnhancedFfrAreaTestCase::TeleportUe, this, 300, 0,
1366  expectedDlPowerMiddleArea, expectedDlRbMiddleArea );
1367  Simulator::Schedule (MilliSeconds (501),
1368  &LteFrAreaTestCase::SetUlExpectedValues, this, 0.0225815, expectedUlRbMiddleArea );
1369 
1370  Simulator::Schedule (MilliSeconds (1001),
1371  &LteEnhancedFfrAreaTestCase::TeleportUe, this, 600, 0,
1372  expectedDlPowerEdgeArea, expectedDlRbEdgeArea );
1373  Simulator::Schedule (MilliSeconds (1001),
1374  &LteFrAreaTestCase::SetUlExpectedValues, this, 0.0903259, expectedUlRbEdgeArea );
1375 
1376  Simulator::Schedule (MilliSeconds (1501),
1377  &LteEnhancedFfrAreaTestCase::TeleportUe, this, 100, 0,
1378  expectedDlPowerCenterArea, expectedDlRbCenterArea );
1379  Simulator::Schedule (MilliSeconds (1501),
1380  &LteFrAreaTestCase::SetUlExpectedValues, this, 0.00250905, expectedUlRbCenterArea );
1381 
1382  Simulator::Schedule (MilliSeconds (2001),
1383  &LteEnhancedFfrAreaTestCase::TeleportUe, this, 300, 0,
1384  expectedDlPowerMiddleArea, expectedDlRbMiddleArea );
1385  Simulator::Schedule (MilliSeconds (2001),
1386  &LteFrAreaTestCase::SetUlExpectedValues, this, 0.0225815, expectedUlRbCenterArea );
1387 
1388  Simulator::Stop (Seconds (2.500));
1389  Simulator::Run ();
1390 
1391  NS_TEST_ASSERT_MSG_EQ (m_usedWrongDlRbg, false,
1392  "Scheduler used DL RBG muted by FFR Algorithm");
1393 
1394  NS_TEST_ASSERT_MSG_EQ (m_usedWrongUlRbg, false,
1395  "Scheduler used UL RB muted by FFR Algorithm");
1396 
1397  Simulator::Destroy ();
1398 }
1399 
1400 
1401 LteDistributedFfrAreaTestCase::LteDistributedFfrAreaTestCase (std::string name, std::string schedulerType)
1402  : LteFrAreaTestCase (name, schedulerType)
1403 {
1404  NS_LOG_INFO ("Creating LteDistributedFfrAreaTestCase");
1405 }
1406 
1407 LteDistributedFfrAreaTestCase::~LteDistributedFfrAreaTestCase ()
1408 {
1409 }
1410 
1411 void
1412 LteDistributedFfrAreaTestCase::DoRun (void)
1413 {
1414  NS_LOG_DEBUG ("LteDistributedFfrAreaTestCase");
1415 
1416  Config::Reset ();
1417  Config::SetDefault ("ns3::LteHelper::UseIdealRrc", BooleanValue (true));
1418  Config::SetDefault ("ns3::LteHelper::UsePdschForCqiGeneration", BooleanValue (true));
1419  Config::SetDefault ("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue (false));
1420  Config::SetDefault ("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue (false));
1421 
1422  double eNbTxPower = 30;
1423  Config::SetDefault ("ns3::LteEnbPhy::TxPower", DoubleValue (eNbTxPower));
1424  Config::SetDefault ("ns3::LteUePhy::TxPower", DoubleValue (10.0));
1425  Config::SetDefault ("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue (true));
1426 
1427  Config::SetDefault ("ns3::LteUePowerControl::ClosedLoop", BooleanValue (true));
1428  Config::SetDefault ("ns3::LteUePowerControl::AccumulationEnabled", BooleanValue (false));
1429 
1430  // Disable layer-3 filtering
1431  Config::SetDefault ("ns3::LteEnbRrc::RsrpFilterCoefficient",
1432  UintegerValue (0));
1433  Config::SetDefault ("ns3::LteEnbRrc::RsrqFilterCoefficient",
1434  UintegerValue (0));
1435 
1436  uint8_t bandwidth = 25;
1437 
1438  Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();
1439  Ptr<PointToPointEpcHelper> epcHelper = CreateObject<PointToPointEpcHelper> ();
1440  lteHelper->SetEpcHelper (epcHelper);
1441  lteHelper->SetHandoverAlgorithmType ("ns3::NoOpHandoverAlgorithm"); // disable automatic handover
1442 
1443  Ptr<Node> pgw = epcHelper->GetPgwNode ();
1444 
1445  // Create a single RemoteHost
1446  NodeContainer remoteHostContainer;
1447  remoteHostContainer.Create (1);
1448  Ptr<Node> remoteHost = remoteHostContainer.Get (0);
1449  InternetStackHelper internet;
1450  internet.Install (remoteHostContainer);
1451 
1452  // Create the Internet
1453  PointToPointHelper p2ph;
1454  p2ph.SetDeviceAttribute ("DataRate", DataRateValue (DataRate ("100Gb/s")));
1455  p2ph.SetDeviceAttribute ("Mtu", UintegerValue (1500));
1456  p2ph.SetChannelAttribute ("Delay", TimeValue (Seconds (0.010)));
1457  NetDeviceContainer internetDevices = p2ph.Install (pgw, remoteHost);
1458  Ipv4AddressHelper ipv4h;
1459  ipv4h.SetBase ("1.0.0.0", "255.0.0.0");
1460  Ipv4InterfaceContainer internetIpIfaces = ipv4h.Assign (internetDevices);
1461  Ipv4Address remoteHostAddr = internetIpIfaces.GetAddress (1);
1462 
1463  // Routing of the Internet Host (towards the LTE network)
1464  Ipv4StaticRoutingHelper ipv4RoutingHelper;
1465  Ptr<Ipv4StaticRouting> remoteHostStaticRouting = ipv4RoutingHelper.GetStaticRouting (remoteHost->GetObject<Ipv4> ());
1466  // interface 0 is localhost, 1 is the p2p device
1467  remoteHostStaticRouting->AddNetworkRouteTo (Ipv4Address ("7.0.0.0"), Ipv4Mask ("255.0.0.0"), 1);
1468 
1469  // Create Nodes: eNodeB and UE
1470  NodeContainer enbNodes;
1471  NodeContainer ueNodes1;
1472  NodeContainer ueNodes2;
1473  enbNodes.Create (2);
1474  ueNodes1.Create (2);
1475  ueNodes2.Create (1);
1476  NodeContainer ueNodes = NodeContainer ( ueNodes1, ueNodes2);
1477  NodeContainer allNodes = NodeContainer ( enbNodes, ueNodes1, ueNodes2);
1478 
1479  /*
1480  * The topology is the following:
1481  *
1482  * eNB1 UE1 UE2 eNB2
1483  * | | | |
1484  * x ------------ x ------------------------ x ------------ x
1485  * 200 m 600 m 200 m
1486  *
1487  */
1488 
1489  // Install Mobility Model
1490  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();
1491  positionAlloc->Add (Vector (0.0, 0.0, 0.0)); // eNB1
1492  positionAlloc->Add (Vector (1000, 0.0, 0.0)); // eNB2
1493 
1494  positionAlloc->Add (Vector (200, 0.0, 0.0)); // UE1
1495  positionAlloc->Add (Vector (200, 0.0, 0.0)); // UE1
1496  positionAlloc->Add (Vector (800, 0.0, 0.0)); // UE2
1497 
1498  MobilityHelper mobility;
1499  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
1500  mobility.SetPositionAllocator (positionAlloc);
1501  mobility.Install (allNodes);
1502  m_ueMobility = ueNodes2.Get (0)->GetObject<MobilityModel> ();
1503 
1504  // Create Devices and install them in the Nodes (eNB and UE)
1505  NetDeviceContainer enbDevs;
1506  NetDeviceContainer ueDevs1;
1507  NetDeviceContainer ueDevs2;
1508  lteHelper->SetSchedulerType (m_schedulerType);
1509 
1510  lteHelper->SetEnbDeviceAttribute ("DlBandwidth", UintegerValue (bandwidth));
1511  lteHelper->SetEnbDeviceAttribute ("UlBandwidth", UintegerValue (bandwidth));
1512 
1513  lteHelper->SetFfrAlgorithmType ("ns3::LteFfrDistributedAlgorithm");
1514  lteHelper->SetFfrAlgorithmAttribute ("CalculationInterval", TimeValue (MilliSeconds (10)));
1515  lteHelper->SetFfrAlgorithmAttribute ("RsrqThreshold", UintegerValue (25));
1516  lteHelper->SetFfrAlgorithmAttribute ("RsrpDifferenceThreshold", UintegerValue (5));
1517  lteHelper->SetFfrAlgorithmAttribute ("EdgeRbNum", UintegerValue (6));
1518  lteHelper->SetFfrAlgorithmAttribute ("CenterPowerOffset",
1519  UintegerValue (LteRrcSap::PdschConfigDedicated::dB0));
1520  lteHelper->SetFfrAlgorithmAttribute ("EdgePowerOffset",
1521  UintegerValue (LteRrcSap::PdschConfigDedicated::dB3));
1522 
1523  enbDevs = lteHelper->InstallEnbDevice (enbNodes);
1524  ueDevs1 = lteHelper->InstallUeDevice (ueNodes1);
1525  ueDevs2 = lteHelper->InstallUeDevice (ueNodes2);
1526 
1527  NetDeviceContainer ueLteDevs;
1528  ueLteDevs.Add (ueDevs1);
1529  ueLteDevs.Add (ueDevs2);
1530 
1531  // Add X2 inteface
1532  lteHelper->AddX2Interface (enbNodes);
1533 
1534  // Install the IP stack on the UEs
1535  internet.Install (ueNodes);
1536  Ipv4InterfaceContainer ueIpIfaces;
1537  ueIpIfaces = epcHelper->AssignUeIpv4Address (NetDeviceContainer (ueLteDevs));
1538  // Assign IP address to UEs, and install applications
1539  for (uint32_t u = 0; u < ueNodes.GetN (); ++u)
1540  {
1541  Ptr<Node> ueNode = ueNodes.Get (u);
1542  // Set the default gateway for the UE
1543  Ptr<Ipv4StaticRouting> ueStaticRouting = ipv4RoutingHelper.GetStaticRouting (ueNode->GetObject<Ipv4> ());
1544  ueStaticRouting->SetDefaultRoute (epcHelper->GetUeDefaultGatewayAddress (), 1);
1545  }
1546 
1547  // Attach a UE to a eNB
1548  lteHelper->Attach (ueDevs1, enbDevs.Get (0));
1549  lteHelper->Attach (ueDevs2, enbDevs.Get (1));
1550 
1551 
1552  // Install and start applications on UEs and remote host
1553  uint16_t dlPort = 10000;
1554  uint16_t ulPort = 20000;
1555 
1556  // randomize a bit start times to avoid simulation artifacts
1557  // (e.g., buffer overflows due to packet transmissions happening
1558  // exactly at the same time)
1559  Ptr<UniformRandomVariable> startTimeSeconds = CreateObject<UniformRandomVariable> ();
1560  startTimeSeconds->SetAttribute ("Min", DoubleValue (0));
1561  startTimeSeconds->SetAttribute ("Max", DoubleValue (0.010));
1562 
1563  for (uint32_t u = 0; u < ueNodes.GetN (); ++u)
1564  {
1565  Ptr<Node> ue = ueNodes.Get (u);
1566  // Set the default gateway for the UE
1567  Ptr<Ipv4StaticRouting> ueStaticRouting = ipv4RoutingHelper.GetStaticRouting (ue->GetObject<Ipv4> ());
1568  ueStaticRouting->SetDefaultRoute (epcHelper->GetUeDefaultGatewayAddress (), 1);
1569 
1570  for (uint32_t b = 0; b < 1; ++b)
1571  {
1572  ++dlPort;
1573  ++ulPort;
1574 
1575  ApplicationContainer clientApps;
1576  ApplicationContainer serverApps;
1577 
1578  NS_LOG_LOGIC ("installing UDP DL app for UE " << u);
1579  UdpClientHelper dlClientHelper (ueIpIfaces.GetAddress (u), dlPort);
1580  dlClientHelper.SetAttribute ("MaxPackets", UintegerValue (1000000));
1581  dlClientHelper.SetAttribute ("Interval", TimeValue (MilliSeconds (1.0)));
1582  clientApps.Add (dlClientHelper.Install (remoteHost));
1583  PacketSinkHelper dlPacketSinkHelper ("ns3::UdpSocketFactory",
1584  InetSocketAddress (Ipv4Address::GetAny (), dlPort));
1585  serverApps.Add (dlPacketSinkHelper.Install (ue));
1586 
1587  NS_LOG_LOGIC ("installing UDP UL app for UE " << u);
1588  UdpClientHelper ulClientHelper (remoteHostAddr, ulPort);
1589  ulClientHelper.SetAttribute ("MaxPackets", UintegerValue (1000000));
1590  ulClientHelper.SetAttribute ("Interval", TimeValue (MilliSeconds (1.0)));
1591  clientApps.Add (ulClientHelper.Install (ue));
1592  PacketSinkHelper ulPacketSinkHelper ("ns3::UdpSocketFactory",
1593  InetSocketAddress (Ipv4Address::GetAny (), ulPort));
1594  serverApps.Add (ulPacketSinkHelper.Install (remoteHost));
1595 
1596  Ptr<EpcTft> tft = Create<EpcTft> ();
1597  EpcTft::PacketFilter dlpf;
1598  dlpf.localPortStart = dlPort;
1599  dlpf.localPortEnd = dlPort;
1600  tft->Add (dlpf);
1601  EpcTft::PacketFilter ulpf;
1602  ulpf.remotePortStart = ulPort;
1603  ulpf.remotePortEnd = ulPort;
1604  tft->Add (ulpf);
1605  EpsBearer bearer (EpsBearer::NGBR_VIDEO_TCP_DEFAULT);
1606  lteHelper->ActivateDedicatedEpsBearer (ueLteDevs.Get (u), bearer, tft);
1607 
1608  Time startTime = Seconds (startTimeSeconds->GetValue ());
1609  serverApps.Start (startTime);
1610  clientApps.Start (startTime);
1611  }
1612  }
1613 
1614  //Test SpectrumPhy to get signals form DL channel
1615  Ptr<LteSpectrumPhy> enbDlSpectrumPhy = enbDevs.Get (0)->GetObject<LteEnbNetDevice> ()->GetPhy ()->GetDownlinkSpectrumPhy ()->GetObject<LteSpectrumPhy> ();
1616  Ptr<SpectrumChannel> dlChannel = enbDlSpectrumPhy->GetChannel ();
1617 
1618  Ptr<LteSimpleSpectrumPhy> testDlSpectrumPhy = CreateObject<LteSimpleSpectrumPhy> ();
1619  Ptr<LteEnbNetDevice> eNbDev = enbDevs.Get (0)->GetObject<LteEnbNetDevice> ();
1620  testDlSpectrumPhy->SetRxSpectrumModel (LteSpectrumValueHelper::GetSpectrumModel (eNbDev->GetDlEarfcn (), m_dlBandwidth));
1621  dlChannel->AddRx (testDlSpectrumPhy);
1622 
1623  testDlSpectrumPhy->SetCellId (2);
1624 
1625  testDlSpectrumPhy->TraceConnectWithoutContext ("RxStart",
1626  MakeBoundCallback (&DlDataRxStartNofiticationArea, this));
1627 
1628  //Test SpectrumPhy to get signals form UL channel
1629  Ptr<LteSpectrumPhy> ueUlSpectrumPhy = ueDevs1.Get (0)->GetObject<LteUeNetDevice> ()->GetPhy ()->GetUplinkSpectrumPhy ()->GetObject<LteSpectrumPhy> ();
1630  Ptr<SpectrumChannel> ulChannel = ueUlSpectrumPhy->GetChannel ();
1631 
1632  Ptr<LteSimpleSpectrumPhy> testUlSpectrumPhy = CreateObject<LteSimpleSpectrumPhy> ();
1633  testUlSpectrumPhy->SetRxSpectrumModel (LteSpectrumValueHelper::GetSpectrumModel (eNbDev->GetUlEarfcn (), m_ulBandwidth));
1634  ulChannel->AddRx (testUlSpectrumPhy);
1635 
1636  testUlSpectrumPhy->SetCellId (2);
1637 
1638  testUlSpectrumPhy->TraceConnectWithoutContext ("RxStart",
1639  MakeBoundCallback (&UlDataRxStartNofiticationArea, this));
1640 
1641  double expectedDlPowerCenterArea = 1.0;
1642  std::vector<bool> expectedDlRbCenterArea;
1643  expectedDlRbCenterArea.resize (m_dlBandwidth, false);
1644  std::vector<bool> expectedUlRbCenterArea;
1645  expectedUlRbCenterArea.resize (m_ulBandwidth, false);
1646  for (uint32_t i = 0; i < m_dlBandwidth; i++)
1647  {
1648  expectedDlRbCenterArea[i] = true;
1649  expectedUlRbCenterArea[i] = true;
1650  }
1651 
1652  double expectedDlPowerEdgeArea = 2.0;
1653  std::vector<bool> expectedDlRbEdgeArea;
1654  expectedDlRbEdgeArea.resize (m_dlBandwidth, false);
1655  std::vector<bool> expectedUlRbEdgeArea;
1656  expectedUlRbEdgeArea.resize (m_ulBandwidth, false);
1657  for (uint32_t i = 0; i < 6; i++)
1658  {
1659  expectedDlRbEdgeArea[i] = true;
1660  expectedUlRbEdgeArea[i] = true;
1661  }
1662 
1663  std::vector<bool> expectedDlRbEdgeArea2;
1664  expectedDlRbEdgeArea2.resize (m_dlBandwidth, false);
1665  std::vector<bool> expectedUlRbEdgeArea2;
1666  expectedUlRbEdgeArea2.resize (m_dlBandwidth, false);
1667  for (uint32_t i = 6; i < 12; i++)
1668  {
1669  expectedDlRbEdgeArea2[i] = true;
1670  expectedUlRbEdgeArea2[i] = true;
1671  }
1672 
1673 
1674  Simulator::Schedule (MilliSeconds (1),
1675  &LteFrAreaTestCase::TeleportUe, this, 800, 0,
1676  expectedDlPowerCenterArea, expectedDlRbCenterArea );
1677  Simulator::Schedule (MilliSeconds (1),
1678  &LteFrAreaTestCase::SetUlExpectedValues, this, 0.0225815, expectedUlRbCenterArea );
1679 
1680  Simulator::Schedule (MilliSeconds (501),
1681  &LteFrAreaTestCase::TeleportUe, this, 400, 0,
1682  expectedDlPowerEdgeArea, expectedDlRbEdgeArea );
1683  Simulator::Schedule (MilliSeconds (501),
1684  &LteFrAreaTestCase::SetUlExpectedValues, this, 0.135489, expectedUlRbEdgeArea );
1685 
1686  Simulator::Schedule (MilliSeconds (1001),
1687  &LteFrAreaTestCase::TeleportUe2, this, ueNodes1.Get (0), 600, 0,
1688  expectedDlPowerEdgeArea, expectedDlRbEdgeArea2 );
1689  Simulator::Schedule (MilliSeconds (1001),
1690  &LteFrAreaTestCase::SetUlExpectedValues, this, 0.135489, expectedUlRbEdgeArea2 );
1691 
1692  Simulator::Schedule (MilliSeconds (1501),
1693  &LteFrAreaTestCase::TeleportUe2, this, ueNodes1.Get (0), 200, 0,
1694  expectedDlPowerEdgeArea, expectedDlRbEdgeArea );
1695  Simulator::Schedule (MilliSeconds (1501),
1696  &LteFrAreaTestCase::SetUlExpectedValues, this, 0.135489, expectedUlRbEdgeArea );
1697 
1698  Simulator::Schedule (MilliSeconds (2001),
1699  &LteFrAreaTestCase::TeleportUe, this, 800, 0,
1700  expectedDlPowerCenterArea, expectedDlRbCenterArea );
1701  Simulator::Schedule (MilliSeconds (2001),
1702  &LteFrAreaTestCase::SetUlExpectedValues, this, 0.0225815, expectedUlRbCenterArea );
1703 
1704  Simulator::Stop (Seconds (2.500));
1705  Simulator::Run ();
1706 
1707 #if 0
1708  NS_TEST_ASSERT_MSG_EQ (m_usedWrongDlRbg, false,
1709  "Scheduler used DL RBG muted by FFR Algorithm");
1710 #endif
1711 
1712  NS_TEST_ASSERT_MSG_EQ (m_usedWrongUlRbg, false,
1713  "Scheduler used UL RB muted by FFR Algorithm");
1714 
1715  Simulator::Destroy ();
1716 
1717 }
ns3::SpectrumValue::ConstValuesEnd
Values::const_iterator ConstValuesEnd() const
Definition: spectrum-value.cc:75
ns3::ApplicationContainer
holds a vector of ns3::Application pointers.
Definition: application-container.h:41
LteHardFrTestCase
Test hard frequency reuse algorithm.
Definition: lte-test-frequency-reuse.h:104
ns3::EpcTft::Add
uint8_t Add(PacketFilter f)
add a PacketFilter to the Traffic Flow Template
Definition: epc-tft.cc:224
ns3::LteSimpleSpectrumPhy::SetCellId
void SetCellId(uint16_t cellId)
Set cell ID.
Definition: lte-simple-spectrum-phy.cc:163
ns3::Time
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:102
LteStrictFrTestCase::m_schedulerType
std::string m_schedulerType
scheduler type
Definition: lte-test-frequency-reuse.h:180
LteFrequencyReuseTestSuite
Test the fractional frequency reuse algorithms.
Definition: lte-test-frequency-reuse.h:40
ns3::InetSocketAddress
an Inet address class
Definition: inet-socket-address.h:40
LteFrAreaTestCase::m_usedWrongUlRbg
bool m_usedWrongUlRbg
used wrong UL RBG?
Definition: lte-test-frequency-reuse.h:279
LteFrAreaTestCase::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: lte-test-frequency-reuse.cc:596
ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:73
NS_LOG_FUNCTION
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by "...
Definition: log-macros-enabled.h:213
LteFrAreaTestCase::m_expectedDlRb
std::vector< bool > m_expectedDlRb
the expected DL per RB
Definition: lte-test-frequency-reuse.h:273
ns3::BooleanValue
AttributeValue implementation for Boolean.
Definition: boolean.h:36
ns3::LteHelper::InstallEnbDevice
NetDeviceContainer InstallEnbDevice(NodeContainer c)
Create a set of eNodeB devices.
Definition: lte-helper.cc:474
LteFrAreaTestCase::m_schedulerType
std::string m_schedulerType
the scheduler type
Definition: lte-test-frequency-reuse.h:264
ns3::Ipv4InterfaceContainer
holds a vector of std::pair of Ptr and interface index.
Definition: ipv4-interface-container.h:54
ns3::Ipv4StaticRouting::SetDefaultRoute
void SetDefaultRoute(Ipv4Address nextHop, uint32_t interface, uint32_t metric=0)
Add a default route to the static routing table.
Definition: ipv4-static-routing.cc:112
ns3::Object::GetObject
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:459
ns3::NetDeviceContainer::Get
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr stored in this container at a given index.
Definition: net-device-container.cc:62
UlDataRxStartNofitication
void UlDataRxStartNofitication(LteFrTestCase *testcase, Ptr< const SpectrumValue > spectrumValue)
Definition: lte-test-frequency-reuse.cc:171
ns3::PointToPointHelper::Install
NetDeviceContainer Install(NodeContainer c)
Definition: point-to-point-helper.cc:220
ns3::Ipv4Mask
a class to represent an Ipv4 address mask
Definition: ipv4-address.h:258
ns3::ApplicationContainer::Add
void Add(ApplicationContainer other)
Append the contents of another ApplicationContainer to the end of this container. ...
Definition: application-container.cc:64
ns3::LteSimpleSpectrumPhy::SetRxSpectrumModel
void SetRxSpectrumModel(Ptr< const SpectrumModel > model)
Set receive spectrum model.
Definition: lte-simple-spectrum-phy.cc:156
LteEnhancedFfrAreaTestCase
Lte Enhanced Ffr Area Test Case.
Definition: lte-test-frequency-reuse.h:358
ns3::TestSuite
A suite of tests to run.
Definition: test.h:1342
LteStrictFrTestCase::m_dlEdgeSubBandwidth
uint8_t m_dlEdgeSubBandwidth
DL edge subbandwidth.
Definition: lte-test-frequency-reuse.h:184
ns3::MakeBoundCallback
Callback< R > MakeBoundCallback(R(*fnPtr)(TX), ARG a1)
Make Callbacks with one bound argument.
Definition: callback.h:1686
LteFrTestCase::UlDataRxStart
void UlDataRxStart(Ptr< const SpectrumValue > spectrumValue)
UL data receive start function.
Definition: lte-test-frequency-reuse.cc:217
LteFrTestCase::m_usedMutedUlRbg
bool m_usedMutedUlRbg
used muted UL RBG?
Definition: lte-test-frequency-reuse.h:93
LteStrictFrTestCase::m_ulEdgeSubBandwidth
uint8_t m_ulEdgeSubBandwidth
UL edge subbandwidth.
Definition: lte-test-frequency-reuse.h:188
LteStrictFrTestCase::LteStrictFrTestCase
LteStrictFrTestCase(std::string name, uint32_t userNum, std::string schedulerType, uint8_t dlBandwidth, uint8_t ulBandwidth, uint8_t dlCommonSubBandwidth, uint8_t dlEdgeSubBandOffset, uint8_t dlEdgeSubBandwidth, uint8_t ulCommonSubBandwidth, uint8_t ulEdgeSubBandOffset, uint8_t ulEdgeSubBandwidth, std::vector< bool > availableDlRb, std::vector< bool > availableUlRb)
Constructor.
Definition: lte-test-frequency-reuse.cc:349
LteHardFrTestCase::m_dlSubBandOffset
uint8_t m_dlSubBandOffset
the DL subband offset
Definition: lte-test-frequency-reuse.h:135
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:957
LteFrAreaTestCase::m_expectedUlRb
std::vector< bool > m_expectedUlRb
expected UL per RB
Definition: lte-test-frequency-reuse.h:278
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:201
ns3::MilliSeconds
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1015
ns3::InternetStackHelper
aggregate IP/TCP/UDP functionality to existing Nodes.
Definition: internet-stack-helper.h:86
NS_LOG_INFO
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:277
ns3::PacketSinkHelper
A helper to make it easier to instantiate an ns3::PacketSinkApplication on a set of nodes...
Definition: packet-sink-helper.h:35
ns3::PointToPointHelper
Build a set of PointToPointNetDevice objects.
Definition: point-to-point-helper.h:43
LteFrAreaTestCase::DlDataRxStart
void DlDataRxStart(Ptr< const SpectrumValue > spectrumValue)
DL data receive start function.
Definition: lte-test-frequency-reuse.cc:484
ns3::TestCase
encapsulates test code
Definition: test.h:1155
LteDistributedFfrAreaTestCase
Lte Distributed Ffr Area Test Case.
Definition: lte-test-frequency-reuse.h:381
ns3::LteSpectrumPhy::GetChannel
Ptr< SpectrumChannel > GetChannel()
Definition: lte-spectrum-phy.cc:303
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:1310
ns3::PointToPointHelper::SetDeviceAttribute
void SetDeviceAttribute(std::string name, const AttributeValue &value)
Set an attribute value to be propagated to each NetDevice created by the helper.
Definition: point-to-point-helper.cc:66
LteHardFrTestCase::m_schedulerType
std::string m_schedulerType
the scheduler type
Definition: lte-test-frequency-reuse.h:133
ns3::LteHelper::ActivateDedicatedEpsBearer
uint8_t ActivateDedicatedEpsBearer(NetDeviceContainer ueDevices, EpsBearer bearer, Ptr< EpcTft > tft)
Activate a dedicated EPS bearer on a given set of UE devices.
Definition: lte-helper.cc:1065
ns3::LteHelper::SetHandoverAlgorithmType
void SetHandoverAlgorithmType(std::string type)
Set the type of handover algorithm to be used by eNodeB devices.
Definition: lte-helper.cc:327
LteFrAreaTestCase::m_ulBandwidth
uint8_t m_ulBandwidth
the UL bandwidth
Definition: lte-test-frequency-reuse.h:267
ns3::UdpClientHelper::Install
ApplicationContainer Install(NodeContainer c)
Definition: udp-client-server-helper.cc:93
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
LteFrAreaTestCase::m_dlBandwidth
uint8_t m_dlBandwidth
the DL bandwidth
Definition: lte-test-frequency-reuse.h:266
first.clientApps
tuple clientApps
Definition: first.py:54
ns3::LteHelper::SetSchedulerType
void SetSchedulerType(std::string type)
Set the type of scheduler to be used by eNodeB devices.
Definition: lte-helper.cc:279
ns3::NodeContainer::GetN
uint32_t GetN(void) const
Get the number of Ptr stored in this container.
Definition: node-container.cc:83
LteFrAreaTestCase::TeleportUe
void TeleportUe(uint32_t x, uint32_t y, double expectedPower, std::vector< bool > expectedDlRb)
Teleport UE function.
Definition: lte-test-frequency-reuse.cc:554
ns3::DataRate
Class for representing data rates.
Definition: data-rate.h:88
ns3::MobilityModel
Keep track of the current position and velocity of an object.
Definition: mobility-model.h:39
LteFrTestCase::LteFrTestCase
LteFrTestCase(std::string name, uint32_t userNum, uint8_t dlBandwidth, uint8_t ulBandwidth, std::vector< bool > availableDlRb, std::vector< bool > availableUlRb)
Constructor.
Definition: lte-test-frequency-reuse.cc:177
ns3::EpsBearer
This class contains the specification of EPS Bearers.
Definition: eps-bearer.h:71
DlDataRxStartNofitication
void DlDataRxStartNofitication(LteFrTestCase *testcase, Ptr< const SpectrumValue > spectrumValue)
TestCase Data.
Definition: lte-test-frequency-reuse.cc:164
ns3::MobilityHelper::Install
void Install(Ptr< Node > node) const
"Layout" a single node according to the current position allocator type.
Definition: mobility-helper.cc:130
third.mobility
tuple mobility
Definition: third.py:101
LteHardFrTestCase::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: lte-test-frequency-reuse.cc:264
ns3::UdpClientHelper
Create a client application which sends UDP packets carrying a 32bit sequence number and a 64 bit tim...
Definition: udp-client-server-helper.h:93
LteStrictFrAreaTestCase::LteStrictFrAreaTestCase
LteStrictFrAreaTestCase(std::string name, std::string schedulerType)
Constructor.
Definition: lte-test-frequency-reuse.cc:600
ns3::TimeValue
AttributeValue implementation for Time.
Definition: nstime.h:1069
LteStrictFrTestCase::m_dlEdgeSubBandOffset
uint8_t m_dlEdgeSubBandOffset
DL edge subband offset.
Definition: lte-test-frequency-reuse.h:183
ns3::TestCase::AddTestCase
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:299
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::UintegerValue
Hold an unsigned integer type.
Definition: uinteger.h:44
LteHardFrTestCase::m_ulSubBandOffset
uint8_t m_ulSubBandOffset
UL subband offset.
Definition: lte-test-frequency-reuse.h:138
startTime
double startTime
Definition: tcp-nsc-comparison.cc:45
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
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:168
ns3::NetDeviceContainer
holds a vector of ns3::NetDevice pointers
Definition: net-device-container.h:41
LteDistributedFfrAreaTestCase::LteDistributedFfrAreaTestCase
LteDistributedFfrAreaTestCase(std::string name, std::string schedulerType)
Constructor.
Definition: lte-test-frequency-reuse.cc:1401
LteSoftFrAreaTestCase
Lte Soft Fr Area Test Case.
Definition: lte-test-frequency-reuse.h:312
LteFrAreaTestCase::m_usedWrongDlRbg
bool m_usedWrongDlRbg
used wrong DL RBG?
Definition: lte-test-frequency-reuse.h:274
LteSoftFfrAreaTestCase::LteSoftFfrAreaTestCase
LteSoftFfrAreaTestCase(std::string name, std::string schedulerType)
Constructor.
Definition: lte-test-frequency-reuse.cc:960
LteFrAreaTestCase::LteFrAreaTestCase
LteFrAreaTestCase(std::string name, std::string schedulerType)
Constructor.
Definition: lte-test-frequency-reuse.cc:470
LteStrictFrTestCase
Test stric frequency reuse algorithm.
Definition: lte-test-frequency-reuse.h:149
ns3::ApplicationContainer::Start
void Start(Time start)
Arrange for all of the Applications in this container to Start() at the Time given as a parameter...
Definition: application-container.cc:84
LteStrictFrTestCase::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: lte-test-frequency-reuse.cc:372
NS_TEST_ASSERT_MSG_EQ_TOL
#define NS_TEST_ASSERT_MSG_EQ_TOL(actual, limit, tol, msg)
Test that actual and expected (limit) values are equal to plus or minus some tolerance and report and...
Definition: test.h:380
LteSoftFrAreaTestCase::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: lte-test-frequency-reuse.cc:788
LteStrictFrAreaTestCase::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: lte-test-frequency-reuse.cc:611
LteFrAreaTestCase::m_expectedDlPower
double m_expectedDlPower
the expected DL power
Definition: lte-test-frequency-reuse.h:272
LteHardFrTestCase::m_dlSubBandwidth
uint8_t m_dlSubBandwidth
the DL subband width
Definition: lte-test-frequency-reuse.h:136
LteFrTestCase::m_availableDlRb
std::vector< bool > m_availableDlRb
the available DL for each RB
Definition: lte-test-frequency-reuse.h:89
first.serverApps
tuple serverApps
Definition: first.py:45
ns3::Ipv4
Access to the IPv4 forwarding table, interfaces, and configuration.
Definition: ipv4.h:76
ns3::UdpClientHelper::SetAttribute
void SetAttribute(std::string name, const AttributeValue &value)
Record an attribute to be set in each Application after it is is created.
Definition: udp-client-server-helper.cc:87
LteFrAreaTestCase::m_ueMobility
Ptr< MobilityModel > m_ueMobility
the UE mobility model
Definition: lte-test-frequency-reuse.h:270
LteFrTestCase::m_usedMutedDlRbg
bool m_usedMutedDlRbg
used muted DL RBG?
Definition: lte-test-frequency-reuse.h:90
ns3::ObjectBase::TraceConnectWithoutContext
bool TraceConnectWithoutContext(std::string name, const CallbackBase &cb)
Connect a TraceSource to a Callback without a context.
Definition: object-base.cc:293
ns3::EpcTft::PacketFilter::remotePortEnd
uint16_t remotePortEnd
end of the port number range of the remote host
Definition: epc-tft.h:135
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::NodeContainer
keep track of a set of node pointers.
Definition: node-container.h:38
ns3::MobilityHelper::SetMobilityModel
void SetMobilityModel(std::string type, std::string n1="", const AttributeValue &v1=EmptyAttributeValue(), std::string n2="", const AttributeValue &v2=EmptyAttributeValue(), std::string n3="", const AttributeValue &v3=EmptyAttributeValue(), std::string n4="", const AttributeValue &v4=EmptyAttributeValue(), std::string n5="", const AttributeValue &v5=EmptyAttributeValue(), std::string n6="", const AttributeValue &v6=EmptyAttributeValue(), std::string n7="", const AttributeValue &v7=EmptyAttributeValue(), std::string n8="", const AttributeValue &v8=EmptyAttributeValue(), std::string n9="", const AttributeValue &v9=EmptyAttributeValue())
Definition: mobility-helper.cc:79
ns3::UniformRandomVariable::GetValue
double GetValue(double min, double max)
Get the next random value, as a double in the specified range .
Definition: random-variable-stream.cc:181
ns3::InternetStackHelper::Install
void Install(std::string nodeName) const
Aggregate implementations of the ns3::Ipv4, ns3::Ipv6, ns3::Udp, and ns3::Tcp classes onto the provid...
Definition: internet-stack-helper.cc:357
ns3::LteHelper::AddX2Interface
void AddX2Interface(NodeContainer enbNodes)
Create an X2 interface between all the eNBs in a given set.
Definition: lte-helper.cc:1217
LteFrTestCase::m_ulBandwidth
uint8_t m_ulBandwidth
the UL bandwidth
Definition: lte-test-frequency-reuse.h:87
LteFrAreaTestCase::SetDlExpectedValues
void SetDlExpectedValues(double expectedPower, std::vector< bool > expectedDlRb)
Set DL expected values function.
Definition: lte-test-frequency-reuse.cc:580
LteStrictFrTestCase::m_ulCommonSubBandwidth
uint8_t m_ulCommonSubBandwidth
UL common subbandwidth.
Definition: lte-test-frequency-reuse.h:186
ns3::MobilityModel::SetPosition
void SetPosition(const Vector &position)
Definition: mobility-model.cc:75
NS_LOG_LOGIC
NS_LOG_LOGIC("Net device "<< nd<< " is not bridged")
UlDataRxStartNofiticationArea
void UlDataRxStartNofiticationArea(LteFrAreaTestCase *testcase, Ptr< const SpectrumValue > spectrumValue)
Definition: lte-test-frequency-reuse.cc:464
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:757
ns3::PointToPointHelper::SetChannelAttribute
void SetChannelAttribute(std::string name, const AttributeValue &value)
Set an attribute value to be propagated to each Channel created by the helper.
Definition: point-to-point-helper.cc:72
ns3::LteHelper::InstallUeDevice
NetDeviceContainer InstallUeDevice(NodeContainer c)
Create a set of UE devices.
Definition: lte-helper.cc:489
ns3::MobilityHelper
Helper class used to assign positions and mobility models to nodes.
Definition: mobility-helper.h:42
ns3::Ipv4StaticRouting::AddNetworkRouteTo
void AddNetworkRouteTo(Ipv4Address network, Ipv4Mask networkMask, Ipv4Address nextHop, uint32_t interface, uint32_t metric=0)
Add a network route to the static routing table.
Definition: ipv4-static-routing.cc:63
LteDistributedFfrAreaTestCase::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: lte-test-frequency-reuse.cc:1412
LteFrAreaTestCase::m_teleportTime
Time m_teleportTime
the telport time
Definition: lte-test-frequency-reuse.h:269
ns3::Ipv4Address
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:40
LteSoftFfrAreaTestCase::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: lte-test-frequency-reuse.cc:971
ns3::Ipv4AddressHelper::Assign
Ipv4InterfaceContainer Assign(const NetDeviceContainer &c)
Assign IP addresses to the net devices specified in the container based on the current network prefix...
Definition: ipv4-address-helper.cc:134
ns3::Ipv4StaticRoutingHelper::GetStaticRouting
Ptr< Ipv4StaticRouting > GetStaticRouting(Ptr< Ipv4 > ipv4) const
Try and find the static routing protocol as either the main routing protocol or in the list of routin...
Definition: ipv4-static-routing-helper.cc:58
ns3::LteHelper::SetEpcHelper
void SetEpcHelper(Ptr< EpcHelper > h)
Set the EpcHelper to be used to setup the EPC network in conjunction with the setup of the LTE radio ...
Definition: lte-helper.cc:272
LteHardFrTestCase::m_ulSubBandwidth
uint8_t m_ulSubBandwidth
UL subband offset.
Definition: lte-test-frequency-reuse.h:139
LteFrAreaTestCase::m_expectedUlPower
double m_expectedUlPower
expected UL power
Definition: lte-test-frequency-reuse.h:277
ns3::Ipv4StaticRoutingHelper
Helper class that adds ns3::Ipv4StaticRouting objects.
Definition: ipv4-static-routing-helper.h:42
ns3::DataRateValue
AttributeValue implementation for DataRate.
Definition: data-rate.h:242
LteSoftFrAreaTestCase::LteSoftFrAreaTestCase
LteSoftFrAreaTestCase(std::string name, std::string schedulerType)
Constructor.
Definition: lte-test-frequency-reuse.cc:777
LteFrTestCase::m_dlBandwidth
uint8_t m_dlBandwidth
the DL bandwidth
Definition: lte-test-frequency-reuse.h:86
LteStrictFrTestCase::m_ulEdgeSubBandOffset
uint8_t m_ulEdgeSubBandOffset
UL edge subband offset.
Definition: lte-test-frequency-reuse.h:187
LteSoftFfrAreaTestCase
Lte Soft Ffr Area Test Case.
Definition: lte-test-frequency-reuse.h:335
ns3::NodeContainer::Get
Ptr< Node > Get(uint32_t i) const
Get the Ptr stored in this container at a given index.
Definition: node-container.cc:88
LteEnhancedFfrAreaTestCase::LteEnhancedFfrAreaTestCase
LteEnhancedFfrAreaTestCase(std::string name, std::string schedulerType)
Constructor.
Definition: lte-test-frequency-reuse.cc:1175
LteFrTestCase::m_userNum
uint32_t m_userNum
the number of UE nodes
Definition: lte-test-frequency-reuse.h:85
NS_LOG_DEBUG
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:269
lteFrequencyReuseTestSuite
static LteFrequencyReuseTestSuite lteFrequencyReuseTestSuite
Definition: lte-test-frequency-reuse.cc:157
ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1007
ns3::Config::SetDefault
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:782
LteFrAreaTestCase::TeleportUe2
void TeleportUe2(Ptr< Node > ueNode, uint32_t x, uint32_t y, double expectedPower, std::vector< bool > expectedDlRb)
Teleport UE 2 function.
Definition: lte-test-frequency-reuse.cc:566
ns3::ListPositionAllocator::Add
void Add(Vector v)
Add a position to the list of positions.
Definition: position-allocator.cc:68
LteFrTestCase::DlDataRxStart
void DlDataRxStart(Ptr< const SpectrumValue > spectrumValue)
DL data receive start function.
Definition: lte-test-frequency-reuse.cc:198
ns3::PacketSinkHelper::Install
ApplicationContainer Install(NodeContainer c) const
Install an ns3::PacketSinkApplication on each node of the input container configured with all the att...
Definition: packet-sink-helper.cc:55
ns3::Ipv4AddressHelper
A helper class to make life easier while doing simple IPv4 address assignment in scripts.
Definition: ipv4-address-helper.h:47
ns3::Now
Time Now(void)
create an ns3::Time instance which contains the current simulation time.
Definition: simulator.cc:365
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:93
ns3::SpectrumValue::ConstValuesBegin
Values::const_iterator ConstValuesBegin() const
Definition: spectrum-value.cc:69
LteHardFrTestCase::LteHardFrTestCase
LteHardFrTestCase(std::string name, uint32_t userNum, std::string schedulerType, uint8_t dlBandwidth, uint8_t ulBandwidth, uint8_t dlSubBandOffset, uint8_t dlSubBandwidth, uint8_t ulSubBandOffset, uint8_t ulSubBandwidth, std::vector< bool > availableDlRb, std::vector< bool > availableUlRb)
Constructor.
Definition: lte-test-frequency-reuse.cc:243
ns3::MobilityHelper::SetPositionAllocator
void SetPositionAllocator(Ptr< PositionAllocator > allocator)
Set the position allocator which will be used to allocate the initial position of every node initiali...
Definition: mobility-helper.cc:47
LteFrTestCase::m_availableUlRb
std::vector< bool > m_availableUlRb
the available UL for each RB
Definition: lte-test-frequency-reuse.h:92
ns3::DoubleValue
This class can be used to hold variables of floating point type such as 'double' or 'float'...
Definition: double.h:41
DlDataRxStartNofiticationArea
void DlDataRxStartNofiticationArea(LteFrAreaTestCase *testcase, Ptr< const SpectrumValue > spectrumValue)
Definition: lte-test-frequency-reuse.cc:457
ns3::ObjectBase::SetAttribute
void SetAttribute(std::string name, const AttributeValue &value)
Set a single attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:185
ns3::LteEnbNetDevice
The eNodeB device implementation.
Definition: lte-enb-net-device.h:56
LteFrAreaTestCase::UlDataRxStart
void UlDataRxStart(Ptr< const SpectrumValue > spectrumValue)
UL data receive start function.
Definition: lte-test-frequency-reuse.cc:516
LteFrTestCase::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: lte-test-frequency-reuse.cc:237
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
LteFrAreaTestCase::SetUlExpectedValues
void SetUlExpectedValues(double expectedPower, std::vector< bool > expectedDlRb)
Set UL expected values function.
Definition: lte-test-frequency-reuse.cc:588
LteFrAreaTestCase
Test frequency reuse algorithm by teleporing UEs to different parts of area and checking if the frequ...
Definition: lte-test-frequency-reuse.h:200
ns3::EpsBearer::Qci
Qci
QoS Class Indicator.
Definition: eps-bearer.h:77
LteFrTestCase
Test frequency reuse algorithm.
Definition: lte-test-frequency-reuse.h:53
LteStrictFrTestCase::m_dlCommonSubBandwidth
uint8_t m_dlCommonSubBandwidth
DL common subbandwidth.
Definition: lte-test-frequency-reuse.h:182
ns3::EpcTft::PacketFilter::remotePortStart
uint16_t remotePortStart
start of the port number range of the remote host
Definition: epc-tft.h:134
ns3::Ipv4AddressHelper::SetBase
void SetBase(Ipv4Address network, Ipv4Mask mask, Ipv4Address base="0.0.0.1")
Set the base network number, network mask and base address.
Definition: ipv4-address-helper.cc:63
LteFrAreaTestCase::SimpleTeleportUe
void SimpleTeleportUe(uint32_t x, uint32_t y)
Simple teleport UE function.
Definition: lte-test-frequency-reuse.cc:545
ns3::EpcTft::PacketFilter
Implement the data structure representing a TrafficFlowTemplate Packet Filter.
Definition: epc-tft.h:74
ns3::LteHelper::SetEnbDeviceAttribute
void SetEnbDeviceAttribute(std::string n, const AttributeValue &v)
Set an attribute for the eNodeB devices (LteEnbNetDevice) to be created.
Definition: lte-helper.cc:400
ns3::Ipv4InterfaceContainer::GetAddress
Ipv4Address GetAddress(uint32_t i, uint32_t j=0) const
Definition: ipv4-interface-container.cc:59
ns3::EpcTft::PacketFilter::localPortStart
uint16_t localPortStart
start of the port number range of the UE
Definition: epc-tft.h:136
ns3::LteSpectrumPhy
The LteSpectrumPhy models the physical layer of LTE.
Definition: lte-spectrum-phy.h:153
ns3::LteUeNetDevice
The LteUeNetDevice class implements the UE net device.
Definition: lte-ue-net-device.h:56
LteEnhancedFfrAreaTestCase::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: lte-test-frequency-reuse.cc:1186