3.28/doxygen/lte-test-interference-fr_8cc_source.html

 /* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */

 /*

  * Copyright (c) 2014 Piotr Gawlowicz

  *

  * This program is free software; you can redistribute it and/or modify

  * it under the terms of the GNU General Public License version 2 as

  * published by the Free Software Foundation;

  *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

  *

  * You should have received a copy of the GNU General Public License

  * along with this program; if not, write to the Free Software

  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  *

  * Author: Piotr Gawlowicz <gawlowicz.p@gmail.com>

  * Based on lte-test-interference.{h,cc} by Manuel Requena <manuel.requena@cttc.es>

  *                                                                              Nicola Baldo <nbaldo@cttc.es>

  */


 #include "ns3/simulator.h"

 #include "ns3/log.h"

 #include "ns3/string.h"

 #include "ns3/double.h"

 #include <ns3/enum.h>

 #include "ns3/boolean.h"

 #include <ns3/pointer.h>

 #include "ns3/mobility-helper.h"

 #include "ns3/lte-helper.h"

 #include "ns3/ff-mac-scheduler.h"


 #include "ns3/lte-enb-phy.h"

 #include "ns3/lte-enb-net-device.h"


 #include "ns3/lte-ue-phy.h"

 #include "ns3/lte-ue-net-device.h"


 #include "lte-test-interference-fr.h"


 #include <ns3/lte-chunk-processor.h>


 #include "lte-simple-spectrum-phy.h"

 #include "ns3/spectrum-value.h"

 #include "ns3/lte-spectrum-value-helper.h"


 using namespace ns3;


 NS_LOG_COMPONENT_DEFINE ("LteInterferenceFrTest");


 LteInterferenceFrTestSuite::LteInterferenceFrTestSuite ()

   : TestSuite ("lte-interference-fr", SYSTEM)

 {

 //  LogLevel logLevel = (LogLevel)(LOG_PREFIX_FUNC | LOG_PREFIX_TIME | LOG_LEVEL_DEBUG);

 //  LogComponentEnable ("LteInterferenceFrTest", logLevel);


   AddTestCase (new LteInterferenceHardFrTestCase ("d1=50, d2=20",  50.000000, 20.000000,  356449.932732, 10803.280215), TestCase::QUICK);

   AddTestCase (new LteInterferenceHardFrTestCase ("d1=50, d2=50",  50.000000, 50.000000,  356449.932732, 10803.280215), TestCase::QUICK);

   AddTestCase (new LteInterferenceHardFrTestCase ("d1=50, d2=200",  50.000000, 200.000000,  356449.932732, 10803.280215), TestCase::QUICK);

   AddTestCase (new LteInterferenceHardFrTestCase ("d1=50, d2=500",  50.000000, 500.000000,  356449.932732, 10803.280215), TestCase::QUICK);


   AddTestCase (new LteInterferenceStrictFrTestCase ("d1=50, d2=20",  50.000000, 20.000000,  0.160000, 0.159998, 356449.932732, 10803.280215, 18), TestCase::QUICK);

   AddTestCase (new LteInterferenceStrictFrTestCase ("d1=50, d2=50",  50.000000, 50.000000, 0.999997, 0.999907, 356449.932732, 10803.280215, 28), TestCase::QUICK);

   AddTestCase (new LteInterferenceStrictFrTestCase ("d1=50, d2=200",  50.000000, 200.000000,  15.999282, 15.976339, 356449.932732, 10803.280215, 30), TestCase::QUICK);

   AddTestCase (new LteInterferenceStrictFrTestCase ("d1=50, d2=500",  50.000000, 500.000000,  99.971953, 99.082845, 356449.932732, 10803.280215, 30), TestCase::QUICK);


 }


 static LteInterferenceFrTestSuite LteInterferenceFrTestSuite;


 LteInterferenceHardFrTestCase::LteInterferenceHardFrTestCase (std::string name, double d1, double d2, double dlSinr, double ulSinr)

   : TestCase ("Test: " + name),

     m_d1 (d1),

     m_d2 (d2),

     m_expectedDlSinrDb (10 * std::log10 (dlSinr))

 {

   NS_LOG_INFO ("Creating LteInterferenceFrTestCase");

 }


 LteInterferenceHardFrTestCase::~LteInterferenceHardFrTestCase ()

 {

 }


 void

 LteInterferenceHardFrTestCase::DoRun (void)

 {

   NS_LOG_INFO (this << GetName ());

   NS_LOG_DEBUG ("LteInterferenceHardFrTestCase");


   Config::Reset ();

   Config::SetDefault ("ns3::LteHelper::UseIdealRrc", BooleanValue (false));


   Config::SetDefault ("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue (false));

   Config::SetDefault ("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue (false));

   Config::SetDefault ("ns3::LteAmc::AmcModel", EnumValue (LteAmc::PiroEW2010));

   Config::SetDefault ("ns3::LteAmc::Ber", DoubleValue (0.00005));


   Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();

   lteHelper->SetFfrAlgorithmType ("ns3::LteFrHardAlgorithm");


   lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::FriisSpectrumPropagationLossModel"));


   // Create Nodes: eNodeB and UE

   NodeContainer enbNodes;

   NodeContainer ueNodes1;

   NodeContainer ueNodes2;

   enbNodes.Create (2);

   ueNodes1.Create (1);

   ueNodes2.Create (1);

   NodeContainer allNodes = NodeContainer ( enbNodes, ueNodes1, ueNodes2);


   // the topology is the following:

   //         d2

   //  UE1-----------eNB2

   //   |             |

   // d1|             |d1

   //   |     d2      |

   //  eNB1----------UE2

   //

   Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();

   positionAlloc->Add (Vector (0.0, 0.0, 0.0));   // eNB1

   positionAlloc->Add (Vector (m_d2, m_d1, 0.0)); // eNB2

   positionAlloc->Add (Vector (0.0, m_d1, 0.0));  // UE1

   positionAlloc->Add (Vector (m_d2, 0.0, 0.0));  // UE2

   MobilityHelper mobility;

   mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");

   mobility.SetPositionAllocator (positionAlloc);

   mobility.Install (allNodes);


   // Create Devices and install them in the Nodes (eNB and UE)

   NetDeviceContainer enbDevs;

   NetDeviceContainer ueDevs1;

   NetDeviceContainer ueDevs2;

   lteHelper->SetSchedulerType ("ns3::PfFfMacScheduler");

   lteHelper->SetSchedulerAttribute ("UlCqiFilter", EnumValue (FfMacScheduler::PUSCH_UL_CQI));


   lteHelper->SetFfrAlgorithmAttribute ("DlSubBandOffset", UintegerValue (0));

   lteHelper->SetFfrAlgorithmAttribute ("DlSubBandwidth", UintegerValue (12));

   lteHelper->SetFfrAlgorithmAttribute ("UlSubBandOffset", UintegerValue (0));

   lteHelper->SetFfrAlgorithmAttribute ("UlSubBandwidth", UintegerValue (25));

   enbDevs.Add (lteHelper->InstallEnbDevice (enbNodes.Get (0)));


   lteHelper->SetFfrAlgorithmAttribute ("DlSubBandOffset", UintegerValue (12));

   lteHelper->SetFfrAlgorithmAttribute ("DlSubBandwidth", UintegerValue (12));

   lteHelper->SetFfrAlgorithmAttribute ("UlSubBandOffset", UintegerValue (0));

   lteHelper->SetFfrAlgorithmAttribute ("UlSubBandwidth", UintegerValue (25));

   enbDevs.Add (lteHelper->InstallEnbDevice (enbNodes.Get (1)));


   ueDevs1 = lteHelper->InstallUeDevice (ueNodes1);

   ueDevs2 = lteHelper->InstallUeDevice (ueNodes2);


   lteHelper->Attach (ueDevs1, enbDevs.Get (0));

   lteHelper->Attach (ueDevs2, enbDevs.Get (1));


   // Activate an EPS bearer

   enum EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;

   EpsBearer bearer (q);

   lteHelper->ActivateDataRadioBearer (ueDevs1, bearer);

   lteHelper->ActivateDataRadioBearer (ueDevs2, bearer);


   // Use testing chunk processor in the PHY layer

   // It will be used to test that the SNR is as intended

   // we plug in two instances, one for DL and one for UL


   Ptr<LtePhy> ue1Phy = ueDevs1.Get (0)->GetObject<LteUeNetDevice> ()->GetPhy ()->GetObject<LtePhy> ();

   Ptr<LteChunkProcessor> testDlSinr1 = Create<LteChunkProcessor> ();

   LteSpectrumValueCatcher dlSinr1Catcher;

   testDlSinr1->AddCallback (MakeCallback (&LteSpectrumValueCatcher::ReportValue, &dlSinr1Catcher));

   ue1Phy->GetDownlinkSpectrumPhy ()->AddDataSinrChunkProcessor (testDlSinr1);


   Ptr<LtePhy> enb1phy = enbDevs.Get (0)->GetObject<LteEnbNetDevice> ()->GetPhy ()->GetObject<LtePhy> ();

   Ptr<LteChunkProcessor> testUlSinr1 = Create<LteChunkProcessor> ();

   LteSpectrumValueCatcher ulSinr1Catcher;

   testUlSinr1->AddCallback (MakeCallback (&LteSpectrumValueCatcher::ReportValue, &ulSinr1Catcher));

   enb1phy->GetUplinkSpectrumPhy ()->AddDataSinrChunkProcessor (testUlSinr1);


   // same as above for eNB2 and UE2


   Ptr<LtePhy> ue2Phy = ueDevs2.Get (0)->GetObject<LteUeNetDevice> ()->GetPhy ()->GetObject<LtePhy> ();

   Ptr<LteChunkProcessor> testDlSinr2 = Create<LteChunkProcessor> ();

   LteSpectrumValueCatcher dlSinr2Catcher;

   testDlSinr2->AddCallback (MakeCallback (&LteSpectrumValueCatcher::ReportValue, &dlSinr2Catcher));

   ue2Phy->GetDownlinkSpectrumPhy ()->AddDataSinrChunkProcessor (testDlSinr2);


   Ptr<LtePhy> enb2phy = enbDevs.Get (1)->GetObject<LteEnbNetDevice> ()->GetPhy ()->GetObject<LtePhy> ();

   Ptr<LteChunkProcessor> testUlSinr2 = Create<LteChunkProcessor> ();

   LteSpectrumValueCatcher ulSinr2Catcher;

   testUlSinr2->AddCallback (MakeCallback (&LteSpectrumValueCatcher::ReportValue, &ulSinr2Catcher));

   enb1phy->GetUplinkSpectrumPhy ()->AddDataSinrChunkProcessor (testUlSinr2);


 // need to allow for RRC connection establishment + SRS

   Simulator::Stop (Seconds (0.200));

   Simulator::Run ();


   for (uint32_t i = 0; i < 12; i++)

     {

       double dlSinr1 = dlSinr1Catcher.GetValue ()->operator[] (i);

       double dlSinr1Db = 10.0 * std::log10 (dlSinr1);

       NS_TEST_ASSERT_MSG_EQ_TOL (dlSinr1Db, m_expectedDlSinrDb, 0.01, "Wrong SINR in DL! (eNB1 --> UE1)");


       double dlSinr2 = dlSinr2Catcher.GetValue ()->operator[] (i);

       NS_TEST_ASSERT_MSG_EQ_TOL (dlSinr2, 0, 0.01, "Wrong SINR in DL! (eNB2 --> UE2)");

     }


   for (uint32_t i = 12; i < 24; i++)

     {

       double dlSinr1 = dlSinr1Catcher.GetValue ()->operator[] (i);

       NS_TEST_ASSERT_MSG_EQ_TOL (dlSinr1, 0, 0.01, "Wrong SINR in DL! (eNB1 --> UE1)");


       double dlSinr2 = dlSinr2Catcher.GetValue ()->operator[] (i);

       double dlSinr2Db = 10.0 * std::log10 (dlSinr2);

       NS_TEST_ASSERT_MSG_EQ_TOL (dlSinr2Db, m_expectedDlSinrDb, 0.01, "Wrong SINR in DL! (eNB2 --> UE2)");

     }


   //FR algorithms do not operate in uplink now, so we do not test it

 //  double ulSinr1Db = 10.0 * std::log10 (testUlSinr1->GetValue ()->operator[] (0));

 //  NS_LOG_DEBUG("ulSinr1Db: "<< ulSinr1Db);

 //  NS_TEST_ASSERT_MSG_EQ_TOL (ulSinr1Db, m_expectedUlSinrDb, 0.01, "Wrong SINR in UL!  (UE1 --> eNB1)");

 //

 //  double ulSinr2Db = 10.0 * std::log10 (testUlSinr2->GetValue ()->operator[] (0));

 //  NS_LOG_DEBUG("ulSinr2Db: "<< ulSinr2Db);

 //  NS_TEST_ASSERT_MSG_EQ_TOL (ulSinr2Db, m_expectedUlSinrDb, 0.01, "Wrong SINR in UL!  (UE2 --> eNB2)");


   Simulator::Destroy ();

 }


 LteInterferenceStrictFrTestCase::LteInterferenceStrictFrTestCase (std::string name, double d1, double d2,

                                                                   double commonDlSinr, double commonUlSinr, double edgeDlSinr, double edgeUlSinr,

                                                                   uint32_t rspqThreshold)

   : TestCase ("Test: " + name),

     m_d1 (d1),

     m_d2 (d2),

     m_commonDlSinrDb (10 * std::log10 (commonDlSinr)),

     m_edgeDlSinrDb (10 * std::log10 (edgeDlSinr)),

     m_rspqThreshold (rspqThreshold)

 {

   NS_LOG_INFO ("Creating LteInterferenceFrTestCase");

 }


 LteInterferenceStrictFrTestCase::~LteInterferenceStrictFrTestCase ()

 {

 }


 void

 LteInterferenceStrictFrTestCase::DoRun (void)

 {

   NS_LOG_INFO (this << GetName ());

   NS_LOG_DEBUG ("LteInterferenceStrictFrTestCase");


   Config::Reset ();

   Config::SetDefault ("ns3::LteHelper::UseIdealRrc", BooleanValue (true));


   Config::SetDefault ("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue (false));

   Config::SetDefault ("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue (false));

   Config::SetDefault ("ns3::LteAmc::AmcModel", EnumValue (LteAmc::PiroEW2010));

   Config::SetDefault ("ns3::LteAmc::Ber", DoubleValue (0.00005));


   Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();

   lteHelper->SetFfrAlgorithmType ("ns3::LteFrStrictAlgorithm");

   lteHelper->SetFfrAlgorithmAttribute ("RsrqThreshold", UintegerValue (m_rspqThreshold));

   lteHelper->SetFfrAlgorithmAttribute ("CenterPowerOffset",

                                        UintegerValue (LteRrcSap::PdschConfigDedicated::dB0));

   lteHelper->SetFfrAlgorithmAttribute ("EdgePowerOffset",

                                        UintegerValue (LteRrcSap::PdschConfigDedicated::dB0));


   lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::FriisSpectrumPropagationLossModel"));


   // Create Nodes: eNodeB and UE

   NodeContainer enbNodes;

   NodeContainer ueNodes1;

   NodeContainer ueNodes2;

   enbNodes.Create (2);

   ueNodes1.Create (2);

   ueNodes2.Create (2);

   NodeContainer allNodes = NodeContainer ( enbNodes, ueNodes1, ueNodes2);


   // the topology is the following:

   //         d2

   //  UE1-----------eNB2

   //   |             |

   // d1|             |d1

   //   |     d2      |

   //  eNB1----------UE2

   //

   Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();

   positionAlloc->Add (Vector (0.0,  0.0,  0.0));  // eNB1

   positionAlloc->Add (Vector (m_d2, m_d1, 0.0));  // eNB2


   positionAlloc->Add (Vector (0.0, m_d1, 0.0));  // UE1-eNB1

   positionAlloc->Add (Vector (0.5 * m_d2, 0.0, 0.0));  // UE2-eNB1


   positionAlloc->Add (Vector (m_d2, 0.0, 0.0));   // UE1-eNB2

   positionAlloc->Add (Vector (0.5 * m_d2, m_d1, 0.0));    // UE2-eNB2


   MobilityHelper mobility;

   mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");

   mobility.SetPositionAllocator (positionAlloc);

   mobility.Install (allNodes);


   // Create Devices and install them in the Nodes (eNB and UE)

   NetDeviceContainer enbDevs;

   NetDeviceContainer ueDevs1;

   NetDeviceContainer ueDevs2;

   lteHelper->SetSchedulerType ("ns3::PfFfMacScheduler");

   lteHelper->SetSchedulerAttribute ("UlCqiFilter", EnumValue (FfMacScheduler::PUSCH_UL_CQI));


   lteHelper->SetFfrAlgorithmAttribute ("DlCommonSubBandwidth", UintegerValue (12));

   lteHelper->SetFfrAlgorithmAttribute ("DlEdgeSubBandOffset", UintegerValue (0));

   lteHelper->SetFfrAlgorithmAttribute ("DlEdgeSubBandwidth", UintegerValue (6));

   lteHelper->SetFfrAlgorithmAttribute ("UlCommonSubBandwidth", UintegerValue (25));

   lteHelper->SetFfrAlgorithmAttribute ("UlEdgeSubBandOffset", UintegerValue (0));

   lteHelper->SetFfrAlgorithmAttribute ("UlEdgeSubBandwidth", UintegerValue (0));


   enbDevs.Add (lteHelper->InstallEnbDevice (enbNodes.Get (0)));


   lteHelper->SetFfrAlgorithmAttribute ("DlCommonSubBandwidth", UintegerValue (12));

   lteHelper->SetFfrAlgorithmAttribute ("DlEdgeSubBandOffset", UintegerValue (6));

   lteHelper->SetFfrAlgorithmAttribute ("DlEdgeSubBandwidth", UintegerValue (6));

   enbDevs.Add (lteHelper->InstallEnbDevice (enbNodes.Get (1)));


   ueDevs1 = lteHelper->InstallUeDevice (ueNodes1);

   ueDevs2 = lteHelper->InstallUeDevice (ueNodes2);


   lteHelper->Attach (ueDevs1, enbDevs.Get (0));

   lteHelper->Attach (ueDevs2, enbDevs.Get (1));


   // Activate an EPS bearer

   enum EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;

   EpsBearer bearer (q);

   lteHelper->ActivateDataRadioBearer (ueDevs1, bearer);

   lteHelper->ActivateDataRadioBearer (ueDevs2, bearer);


   // Use testing chunk processor in the PHY layer

   // It will be used to test that the SNR is as intended

   // we plug in two instances, one for DL and one for UL


   Ptr<LtePhy> ue1Phy = ueDevs1.Get (0)->GetObject<LteUeNetDevice> ()->GetPhy ()->GetObject<LtePhy> ();

   Ptr<LteChunkProcessor> testDlSinr1 = Create<LteChunkProcessor> ();

   LteSpectrumValueCatcher dlSinr1Catcher;

   testDlSinr1->AddCallback (MakeCallback (&LteSpectrumValueCatcher::ReportValue, &dlSinr1Catcher));

   ue1Phy->GetDownlinkSpectrumPhy ()->AddDataSinrChunkProcessor (testDlSinr1);


   Ptr<LtePhy> enb1phy = enbDevs.Get (0)->GetObject<LteEnbNetDevice> ()->GetPhy ()->GetObject<LtePhy> ();

   Ptr<LteChunkProcessor> testUlSinr1 = Create<LteChunkProcessor> ();

   LteSpectrumValueCatcher ulSinr1Catcher;

   testUlSinr1->AddCallback (MakeCallback (&LteSpectrumValueCatcher::ReportValue, &ulSinr1Catcher));

   enb1phy->GetUplinkSpectrumPhy ()->AddDataSinrChunkProcessor (testUlSinr1);


   // same as above for eNB2 and UE2


   Ptr<LtePhy> ue2Phy = ueDevs2.Get (0)->GetObject<LteUeNetDevice> ()->GetPhy ()->GetObject<LtePhy> ();

   Ptr<LteChunkProcessor> testDlSinr2 = Create<LteChunkProcessor> ();

   LteSpectrumValueCatcher dlSinr2Catcher;

   testDlSinr2->AddCallback (MakeCallback (&LteSpectrumValueCatcher::ReportValue, &dlSinr2Catcher));

   ue2Phy->GetDownlinkSpectrumPhy ()->AddDataSinrChunkProcessor (testDlSinr2);


   Ptr<LtePhy> enb2phy = enbDevs.Get (1)->GetObject<LteEnbNetDevice> ()->GetPhy ()->GetObject<LtePhy> ();

   Ptr<LteChunkProcessor> testUlSinr2 = Create<LteChunkProcessor> ();

   LteSpectrumValueCatcher ulSinr2Catcher;

   testUlSinr2->AddCallback (MakeCallback (&LteSpectrumValueCatcher::ReportValue, &ulSinr2Catcher));

   enb1phy->GetUplinkSpectrumPhy ()->AddDataSinrChunkProcessor (testUlSinr2);


 // need to allow for UE Measurement report

   Simulator::Stop (Seconds (2.000));

   Simulator::Run ();


   for (uint32_t i = 0; i < 12; i++)

     {

       double dlSinr1 = dlSinr1Catcher.GetValue ()->operator[] (i);

       double dlSinr1Db = 10.0 * std::log10 (dlSinr1);

       NS_TEST_ASSERT_MSG_EQ_TOL (dlSinr1Db, m_commonDlSinrDb, 0.01, "Wrong SINR in DL! (eNB1 --> UE1)");


       double dlSinr2 = dlSinr2Catcher.GetValue ()->operator[] (i);

       double dlSinr2Db = 10.0 * std::log10 (dlSinr2);

       NS_TEST_ASSERT_MSG_EQ_TOL (dlSinr2Db, m_commonDlSinrDb, 0.01, "Wrong SINR in DL! (eNB2 --> UE2)");

     }


   for (uint32_t i = 12; i < 18; i++)

     {

       double dlSinr1 = dlSinr1Catcher.GetValue ()->operator[] (i);

       double dlSinr1Db = 10.0 * std::log10 (dlSinr1);

       NS_TEST_ASSERT_MSG_EQ_TOL (dlSinr1Db, m_edgeDlSinrDb, 0.01, "Wrong SINR in DL! (eNB1 --> UE1)");


       double dlSinr2 = dlSinr2Catcher.GetValue ()->operator[] (i);

       NS_TEST_ASSERT_MSG_EQ_TOL (dlSinr2, 0, 0.01, "Wrong SINR in DL! (eNB2 --> UE2)");

     }


   for (uint32_t i = 18; i < 24; i++)

     {

       double dlSinr1 = dlSinr1Catcher.GetValue ()->operator[] (i);

       NS_TEST_ASSERT_MSG_EQ_TOL (dlSinr1, 0, 0.01, "Wrong SINR in DL! (eNB1 --> UE1)");


       double dlSinr2 = dlSinr2Catcher.GetValue ()->operator[] (i);

       double dlSinr2Db = 10.0 * std::log10 (dlSinr2);

       NS_TEST_ASSERT_MSG_EQ_TOL (dlSinr2Db, m_edgeDlSinrDb, 0.01, "Wrong SINR in DL! (eNB2 --> UE2)");

     }


   //FR algorithms do not operate in uplink now, so we do not test it

 //  double ulSinr1Db = 10.0 * std::log10 (testUlSinr1->GetValue ()->operator[] (0));

 //  NS_LOG_DEBUG("ulSinr1Db: "<< ulSinr1Db);

 //  NS_TEST_ASSERT_MSG_EQ_TOL (ulSinr1Db, m_expectedUlSinrDb, 0.01, "Wrong SINR in UL!  (UE1 --> eNB1)");

 //

 //  double ulSinr2Db = 10.0 * std::log10 (testUlSinr2->GetValue ()->operator[] (0));

 //  NS_LOG_DEBUG("ulSinr2Db: "<< ulSinr2Db);

 //  NS_TEST_ASSERT_MSG_EQ_TOL (ulSinr2Db, m_expectedUlSinrDb, 0.01, "Wrong SINR in UL!  (UE2 --> eNB2)");


   Simulator::Destroy ();

 }

LteInterferenceStrictFrTestCase::~LteInterferenceStrictFrTestCase
virtual ~LteInterferenceStrictFrTestCase()
Definition: lte-test-interference-fr.cc:254

ns3::Ptr< LteHelper >

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

LteInterferenceStrictFrTestCase::m_d2
double m_d2
distance between UE and other ENB
Definition: lte-test-interference-fr.h:107

ns3::Object::GetObject
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:459

ns3::StringValue
Hold variables of type string.
Definition: string.h:41

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

ns3::TestSuite
A suite of tests to run.
Definition: test.h:1342

LteInterferenceStrictFrTestCase::m_commonDlSinrDb
double m_commonDlSinrDb
expected common DL SINR in dB
Definition: lte-test-interference-fr.h:108

LteInterferenceHardFrTestCase::LteInterferenceHardFrTestCase
LteInterferenceHardFrTestCase(std::string name, double d1, double d2, double dlSinr, double ulSinr)
Constructor.
Definition: lte-test-interference-fr.cc:83

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

NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:201

ns3::LtePhy::GetUplinkSpectrumPhy
Ptr< LteSpectrumPhy > GetUplinkSpectrumPhy()
Definition: lte-phy.cc:111

NS_LOG_INFO
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:277

LteInterferenceHardFrTestCase::m_d1
double m_d1
distance between UE and ENB
Definition: lte-test-interference-fr.h:72

LteInterferenceStrictFrTestCase::LteInterferenceStrictFrTestCase
LteInterferenceStrictFrTestCase(std::string name, double d1, double d2, double commonDlSinr, double commonUlSinr, double edgeDlSinr, double edgeUlSinr, uint32_t rspqThreshold)
Constructor.
Definition: lte-test-interference-fr.cc:241

ns3::TestCase
encapsulates test code
Definition: test.h:1155

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

std
STL namespace.

LteInterferenceHardFrTestCase::~LteInterferenceHardFrTestCase
virtual ~LteInterferenceHardFrTestCase()
Definition: lte-test-interference-fr.cc:92

LteInterferenceFrTestSuite
static LteInterferenceFrTestSuite LteInterferenceFrTestSuite
Definition: lte-test-interference-fr.cc:77

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

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::EpsBearer
This class contains the specification of EPS Bearers.
Definition: eps-bearer.h:71

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

ns3::EnumValue
Hold variables of type enum.
Definition: enum.h:54

LteInterferenceHardFrTestCase::m_expectedDlSinrDb
double m_expectedDlSinrDb
expected DL SINR in dB
Definition: lte-test-interference-fr.h:74

LteInterferenceFrTestSuite::LteInterferenceFrTestSuite
LteInterferenceFrTestSuite()
TestSuite.
Definition: lte-test-interference-fr.cc:59

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

ns3::LteHelper::SetSchedulerAttribute
void SetSchedulerAttribute(std::string n, const AttributeValue &v)
Set an attribute for the scheduler to be created.
Definition: lte-helper.cc:293

ns3::NetDeviceContainer
holds a vector of ns3::NetDevice pointers
Definition: net-device-container.h:41

ns3::MakeCallback
Callback< R > MakeCallback(R(T::*memPtr)(void), OBJ objPtr)
Definition: callback.h:1489

ns3::LteSpectrumValueCatcher
A sink to be plugged to the callback of LteChunkProcessor allowing to save and later retrieve the lat...
Definition: lte-chunk-processor.h:103

ns3::LtePhy::GetDownlinkSpectrumPhy
Ptr< LteSpectrumPhy > GetDownlinkSpectrumPhy()
Definition: lte-phy.cc:105

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

LteInterferenceHardFrTestCase::m_d2
double m_d2
distance between UE and other ENB
Definition: lte-test-interference-fr.h:73

LteInterferenceStrictFrTestCase::m_edgeDlSinrDb
double m_edgeDlSinrDb
expected edge DL SINR in dB
Definition: lte-test-interference-fr.h:109

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::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

LteInterferenceStrictFrTestCase::m_rspqThreshold
uint32_t m_rspqThreshold
RSPQ threshold.
Definition: lte-test-interference-fr.h:111

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::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

NS_LOG_DEBUG
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:269

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

ns3::ListPositionAllocator::Add
void Add(Vector v)
Add a position to the list of positions.
Definition: position-allocator.cc:68

LteInterferenceFrTestSuite
Test suite for the interference test when using different frequency reuse algorithms.Check if the interfence values correspond to theoretical values.
Definition: lte-test-interference-fr.h:40

LteInterferenceHardFrTestCase
Lte interference test when using hard frequency reuse algorithm.
Definition: lte-test-interference-fr.h:54

LteInterferenceStrictFrTestCase
Lte interference test when using strict frequency reuse algorithm.
Definition: lte-test-interference-fr.h:83

lte-test-interference-fr.h

ns3::TestCase::GetName
std::string GetName(void) const
Definition: test.cc:370

LteInterferenceStrictFrTestCase::m_d1
double m_d1
distance between UE and ENB
Definition: lte-test-interference-fr.h:106

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::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

ns3::DoubleValue
This class can be used to hold variables of floating point type such as 'double' or 'float'...
Definition: double.h:41

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

LteInterferenceHardFrTestCase::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: lte-test-interference-fr.cc:97

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

lte-simple-spectrum-phy.h

ns3::EpsBearer::Qci
Qci
QoS Class Indicator.
Definition: eps-bearer.h:77

LteInterferenceStrictFrTestCase::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: lte-test-interference-fr.cc:259

ns3::LtePhy
The LtePhy models the physical layer of LTE.
Definition: lte-phy.h:52

ns3::LteUeNetDevice
The LteUeNetDevice class implements the UE net device.
Definition: lte-ue-net-device.h:56