d4/db2/lte-test-tta-ff-mac-scheduler_8cc_source.html

/*

 * Copyright (c) 2011 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)

 *

 * SPDX-License-Identifier: GPL-2.0-only

 *

 * Author: Marco Miozzo <marco.miozzo@cttc.es>,

 *         Nicola Baldo <nbaldo@cttc.es>

 *         Dizhi Zhou <dizhi.zhou@gmail.com>

 */


#include "lte-test-tta-ff-mac-scheduler.h"


#include "ns3/boolean.h"

#include "ns3/constant-position-mobility-model.h"

#include "ns3/double.h"

#include "ns3/enum.h"

#include "ns3/eps-bearer.h"

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

#include "ns3/log.h"

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

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

#include "ns3/lte-helper.h"

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

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

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

#include "ns3/mobility-helper.h"

#include "ns3/net-device-container.h"

#include "ns3/node-container.h"

#include "ns3/object.h"

#include "ns3/packet.h"

#include "ns3/ptr.h"

#include "ns3/radio-bearer-stats-calculator.h"

#include "ns3/simulator.h"

#include "ns3/spectrum-error-model.h"

#include "ns3/spectrum-interference.h"

#include "ns3/string.h"

#include "ns3/test.h"


#include <iostream>

#include <sstream>

#include <string>


using namespace ns3;


NS_LOG_COMPONENT_DEFINE("LenaTestTtaFfMacScheduler");


LenaTestTtaFfMacSchedulerSuite::LenaTestTtaFfMacSchedulerSuite()

    : TestSuite("lte-tta-ff-mac-scheduler", Type::SYSTEM)

{

    NS_LOG_INFO("creating LenaTestTtaFfMacSchedulerSuite");


    bool errorModel = false;


    // Test Case : AMC works in TTA


    // Note: here the MCS is calculated by the narrowband CQI


    // DOWNLINK - DISTANCE 0 -> MCS 28 -> Itbs 26 (from table 7.1.7.2.1-1 of 36.213)

    // 1 user -> 24 PRB at Itbs 26 -> 2196 -> 2196000 bytes/sec for one UE; 0 bytes/sec for other

    // UEs 3 users -> 2196000 among 3 users -> 2196000 bytes/sec for one UE; 0 bytes/sec for other

    // UEs 6 users -> 2196000 among 6 users -> 2196000 bytes/sec for one UE; 0 bytes/sec for other

    // UEs 12 users -> 2196000 among 12 users -> 2196000 bytes/sec for one UE; 0 bytes/sec for other

    // UEs UPLINK- DISTANCE 0 -> MCS 28 -> Itbs 26 (from table 7.1.7.2.1-1 of 36.213) 1 user -> 25

    // PRB at Itbs 26 -> 2292 -> 2292000 bytes/sec 3 users -> 8 PRB at Itbs 26 -> 749 -> 749000

    // bytes/sec 6 users -> 4 PRB at Itbs 26 -> 373 -> 373000 bytes/sec after the patch enforcing

    // min 3 PRBs per UE: 12 users -> 3 PRB at Itbs 26 -> 277 bytes * 8/12 UE/TTI -> 184670

    // bytes/sec

    AddTestCase(new LenaTtaFfMacSchedulerTestCase(1, 0, 2196000, 2292000, errorModel),

                TestCase::Duration::EXTENSIVE);

    AddTestCase(new LenaTtaFfMacSchedulerTestCase(3, 0, 2196000, 749000, errorModel),

                TestCase::Duration::QUICK);

    AddTestCase(new LenaTtaFfMacSchedulerTestCase(6, 0, 2196000, 373000, errorModel),

                TestCase::Duration::EXTENSIVE);

    AddTestCase(new LenaTtaFfMacSchedulerTestCase(12, 0, 2196000, 184670, errorModel),

                TestCase::Duration::EXTENSIVE);

    AddTestCase(new LenaTtaFfMacSchedulerTestCase(15, 0, 2196000, 147730, errorModel),

                TestCase::Duration::EXTENSIVE);


    // DOWNLINK - DISTANCE 4800 -> MCS 22 -> Itbs 20 (from table 7.1.7.2.1-1 of 36.213)

    // 1 user -> 24 PRB at Itbs 15 -> 1383 -> 1383000 bytes/sec for one UE; 0 bytes/sec for other

    // UEs 3 users -> 1383000 among 3 users -> 1383000 bytes/sec for one UE; 0 bytes/sec for other

    // UEs 6 users -> 1383000 among 6 users -> 1383000 bytes/sec for one UE; 0 bytes/sec for other

    // UEs 12 users -> 1383000 among 12 users -> 1383000 bytes/sec for one UE; 0 bytes/sec for other

    // UEs UPLINK - DISTANCE 4800 -> MCS 14 -> Itbs 13 (from table 7.1.7.2.1-1 of 36.213) 1 user ->

    // 25 PRB at Itbs 13 -> 807 -> 807000 bytes/sec 3 users -> 8 PRB at Itbs 13 -> 253 -> 253000

    // bytes/sec 6 users -> 4 PRB at Itbs 13 -> 125 -> 125000 bytes/sec after the patch enforcing

    // min 3 PRBs per UE: 12 users -> 3 PRB at Itbs 13 -> 93  bytes * 8/12 UE/TTI  -> 62000

    // bytes/sec

    AddTestCase(new LenaTtaFfMacSchedulerTestCase(1, 4800, 1383000, 807000, errorModel),

                TestCase::Duration::EXTENSIVE);

    AddTestCase(new LenaTtaFfMacSchedulerTestCase(3, 4800, 1383000, 253000, errorModel),

                TestCase::Duration::EXTENSIVE);

    AddTestCase(new LenaTtaFfMacSchedulerTestCase(6, 4800, 1383000, 125000, errorModel),

                TestCase::Duration::EXTENSIVE);

    AddTestCase(new LenaTtaFfMacSchedulerTestCase(12, 4800, 1383000, 62000, errorModel),

                TestCase::Duration::EXTENSIVE);


    // DOWNLINK - DISTANCE 6000 -> MCS 20 -> Itbs 18 (from table 7.1.7.2.1-1 of 36.213)

    // 1 user -> 24 PRB at Itbs 15 -> 1191 -> 1191000 bytes/sec for one UE; 0 bytes/sec for other

    // UEs 3 users -> 1191000 among 3 users -> 1191000 bytes/sec for one UE; 0 bytes/sec for other

    // UEs 6 users -> 1191000 among 6 users -> 1191000 bytes/sec for one UE; 0 bytes/sec for other

    // UEs 12 users ->1191000 among 12 users -> 1191000 bytes/sec for one UE; 0 bytes/sec for other

    // UEs UPLINK - DISTANCE 6000 -> MCS 12 -> Itbs 11 (from table 7.1.7.2.1-1 of 36.213) 1 user ->

    // 25 PRB at Itbs 11 -> 621 -> 621000 bytes/sec 3 users -> 8 PRB at Itbs 11 -> 201 -> 201000

    // bytes/sec 6 users -> 4 PRB at Itbs 11 -> 97 -> 97000 bytes/sec after the patch enforcing min

    // 3 PRBs per UE: 12 users -> 3 PRB at Itbs 11 -> 73 bytes * 8/12 UE/TTI -> 48667 bytes/sec

    AddTestCase(new LenaTtaFfMacSchedulerTestCase(1, 6000, 1191000, 621000, errorModel),

                TestCase::Duration::EXTENSIVE);

    AddTestCase(new LenaTtaFfMacSchedulerTestCase(3, 6000, 1191000, 201000, errorModel),

                TestCase::Duration::EXTENSIVE);

    AddTestCase(new LenaTtaFfMacSchedulerTestCase(6, 6000, 1191000, 97000, errorModel),

                TestCase::Duration::EXTENSIVE);

    AddTestCase(new LenaTtaFfMacSchedulerTestCase(12, 6000, 1191000, 48667, errorModel),

                TestCase::Duration::EXTENSIVE);


    // DOWNLINK - DISTANCE 10000 -> MCS 14 -> Itbs 13 (from table 7.1.7.2.1-1 of 36.213)

    // 1 user -> 24 PRB at Itbs 8 -> 775 -> 775000 bytes/sec for one UE; 0 bytes/sec for other UEs

    // 3 users -> 775000 among 3 users -> 775000 bytes/sec for one UE; 0 bytes/sec for other UEs

    // 6 users -> 775000 among 6 users -> 775000 bytes/sec for one UE; 0 bytes/sec for other UEs

    // 12 users -> 775000 among 12 users -> 775000 bytes/sec for one UE; 0 bytes/sec for other UEs

    // UPLINK - DISTANCE 10000 -> MCS 8 -> Itbs 8 (from table 7.1.7.2.1-1 of 36.213)

    // 1 user -> 24 PRB at Itbs 8 -> 437 -> 437000 bytes/sec

    // 3 users -> 8 PRB at Itbs 8 -> 137 -> 137000 bytes/sec

    // 6 users -> 4 PRB at Itbs 8 -> 67 -> 67000 bytes/sec

    // after the patch enforcing min 3 PRBs per UE:

    // 12 users -> 3 PRB at Itbs 8 -> 49 bytes * 8/12 UE/TTI -> 32667 bytes/sec

    AddTestCase(new LenaTtaFfMacSchedulerTestCase(1, 10000, 775000, 437000, errorModel),

                TestCase::Duration::EXTENSIVE);

    AddTestCase(new LenaTtaFfMacSchedulerTestCase(3, 10000, 775000, 137000, errorModel),

                TestCase::Duration::EXTENSIVE);

    AddTestCase(new LenaTtaFfMacSchedulerTestCase(6, 10000, 775000, 67000, errorModel),

                TestCase::Duration::EXTENSIVE);

    AddTestCase(new LenaTtaFfMacSchedulerTestCase(12, 10000, 775000, 32667, errorModel),

                TestCase::Duration::EXTENSIVE);


    // DONWLINK - DISTANCE 20000 -> MCS 8 -> Itbs 8 (from table 7.1.7.2.1-1 of 36.213)

    // 1 user -> 24 PRB at Itbs 8 -> 421 -> 421000 bytes/sec for one UE; 0 bytes/sec for other UEs

    // 3 users -> 421000 among 3 users -> 421000 bytes/sec for one UE; 0 bytes/sec for other UEs

    // 6 users -> 421000 among 6 users -> 421000 bytes/sec for one UE; 0 bytes/sec for other UEs

    // 12 users -> 421000 among 12 users -> 421000 bytes/sec for one UE; 0 bytes/sec for other UEs

    // UPLINK - DISTANCE 20000 -> MCS 2 -> Itbs 2 (from table 7.1.7.2.1-1 of 36.213)

    // 1 user -> 25 PRB at Itbs 2 -> 233 -> 137000 bytes/sec

    // 3 users -> 8 PRB at Itbs 2 -> 69 -> 41000 bytes/sec

    // 6 users -> 4 PRB at Itbs 2 -> 32 -> 22000 bytes/sec

    // after the patch enforcing min 3 PRBs per UE:

    // 12 users -> 3 PRB at Itbs 2 -> 26 bytes * 8/12 UE/TTI -> 12000 bytes/sec

    AddTestCase(new LenaTtaFfMacSchedulerTestCase(1, 20000, 421000, 137000, errorModel),

                TestCase::Duration::EXTENSIVE);

    AddTestCase(new LenaTtaFfMacSchedulerTestCase(3, 20000, 421000, 41000, errorModel),

                TestCase::Duration::EXTENSIVE);

    AddTestCase(new LenaTtaFfMacSchedulerTestCase(6, 20000, 421000, 22000, errorModel),

                TestCase::Duration::EXTENSIVE);

    AddTestCase(new LenaTtaFfMacSchedulerTestCase(12, 20000, 421000, 12000, errorModel),

                TestCase::Duration::EXTENSIVE);


    // DOWNLINK - DISTANCE 100000 -> CQI == 0 -> out of range -> 0 bytes/sec

    // UPLINK - DISTANCE 100000 -> CQI == 0 -> out of range -> 0 bytes/sec

    AddTestCase(new LenaTtaFfMacSchedulerTestCase(1, 100000, 0, 0, errorModel),

                TestCase::Duration::QUICK);

}


/**

 * @ingroup lte-test

 * Static variable for test initialization

 */

static LenaTestTtaFfMacSchedulerSuite lenaTestTtaFfMacSchedulerSuite;


// --------------- T E S T - C A S E ------------------------------


std::string


LenaTtaFfMacSchedulerTestCase::BuildNameString(uint16_t nUser, double dist)

{

    std::ostringstream oss;

    oss << nUser << " UEs, distance " << dist << " m";

    return oss.str();

}


LenaTtaFfMacSchedulerTestCase::LenaTtaFfMacSchedulerTestCase(uint16_t nUser,

                                                             double dist,

                                                             double thrRefDl,

                                                             double thrRefUl,

                                                             bool errorModelEnabled)

    : TestCase(BuildNameString(nUser, dist)),

      m_nUser(nUser),

      m_dist(dist),

      m_thrRefDl(thrRefDl),

      m_thrRefUl(thrRefUl),

      m_errorModelEnabled(errorModelEnabled)

{

}


LenaTtaFfMacSchedulerTestCase::~LenaTtaFfMacSchedulerTestCase()

{

}


void


LenaTtaFfMacSchedulerTestCase::DoRun()

{

    NS_LOG_FUNCTION(this << m_nUser << m_dist);


    if (!m_errorModelEnabled)

    {

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

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

    }


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

    Config::SetDefault("ns3::MacStatsCalculator::DlOutputFilename",

                       StringValue(CreateTempDirFilename("DlMacStats.txt")));

    Config::SetDefault("ns3::MacStatsCalculator::UlOutputFilename",

                       StringValue(CreateTempDirFilename("UlMacStats.txt")));

    Config::SetDefault("ns3::RadioBearerStatsCalculator::DlRlcOutputFilename",

                       StringValue(CreateTempDirFilename("DlRlcStats.txt")));

    Config::SetDefault("ns3::RadioBearerStatsCalculator::UlRlcOutputFilename",

                       StringValue(CreateTempDirFilename("UlRlcStats.txt")));


    // Disable Uplink Power Control

    Config::SetDefault("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue(false));


    /**

     * Initialize Simulation Scenario: 1 eNB and m_nUser UEs

     */


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

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


    // Create Nodes: eNodeB and UE

    NodeContainer enbNodes;

    NodeContainer ueNodes;

    enbNodes.Create(1);

    ueNodes.Create(m_nUser);


    // Install Mobility Model

    MobilityHelper mobility;

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

    mobility.Install(enbNodes);

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

    mobility.Install(ueNodes);


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

    NetDeviceContainer enbDevs;

    NetDeviceContainer ueDevs;

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

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

    enbDevs = lteHelper->InstallEnbDevice(enbNodes);

    ueDevs = lteHelper->InstallUeDevice(ueNodes);


    // Attach a UE to a eNB

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


    // Activate an EPS bearer

    EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;

    EpsBearer bearer(q);

    lteHelper->ActivateDataRadioBearer(ueDevs, bearer);


    Ptr<LteEnbNetDevice> lteEnbDev = enbDevs.Get(0)->GetObject<LteEnbNetDevice>();

    Ptr<LteEnbPhy> enbPhy = lteEnbDev->GetPhy();

    enbPhy->SetAttribute("TxPower", DoubleValue(30.0));

    enbPhy->SetAttribute("NoiseFigure", DoubleValue(5.0));


    // Set UEs' position and power

    for (int i = 0; i < m_nUser; i++)

    {

        Ptr<ConstantPositionMobilityModel> mm =

            ueNodes.Get(i)->GetObject<ConstantPositionMobilityModel>();

        mm->SetPosition(Vector(m_dist, 0.0, 0.0));

        Ptr<LteUeNetDevice> lteUeDev = ueDevs.Get(i)->GetObject<LteUeNetDevice>();

        Ptr<LteUePhy> uePhy = lteUeDev->GetPhy();

        uePhy->SetAttribute("TxPower", DoubleValue(23.0));

        uePhy->SetAttribute("NoiseFigure", DoubleValue(9.0));

    }


    double statsStartTime = 0.300; // need to allow for RRC connection establishment + SRS

    double statsDuration = 0.6;

    double tolerance = 0.1;

    Simulator::Stop(Seconds(statsStartTime + statsDuration - 0.000001));


    lteHelper->EnableMacTraces();

    lteHelper->EnableRlcTraces();

    Ptr<RadioBearerStatsCalculator> rlcStats = lteHelper->GetRlcStats();

    rlcStats->SetAttribute("StartTime", TimeValue(Seconds(statsStartTime)));

    rlcStats->SetAttribute("EpochDuration", TimeValue(Seconds(statsDuration)));


    Simulator::Run();


    /**

     * Check that the downlink assignment is done in a "Throughput to Average" manner

     */

    NS_LOG_INFO("DL - Test with " << m_nUser << " user(s) at distance " << m_dist);

    std::vector<uint64_t> dlDataRxed;

    for (int i = 0; i < m_nUser; i++)

    {

        // get the imsi

        uint64_t imsi = ueDevs.Get(i)->GetObject<LteUeNetDevice>()->GetImsi();

        uint8_t lcId = 3;

        dlDataRxed.push_back(rlcStats->GetDlRxData(imsi, lcId));

        NS_LOG_INFO("\tUser " << i << " imsi " << imsi << " bytes rxed " << (double)dlDataRxed.at(i)

                              << "  thr " << (double)dlDataRxed.at(i) / statsDuration << " ref "

                              << m_thrRefDl);

    }


    /**

     * Check that the assignment is done in a "Throughput to Average" manner among users

     * with maximum SINRs: without fading, current FD MT always assign all resources to one UE

     */


    uint8_t found = 0;

    for (int i = 0; i < m_nUser; i++)

    {

        double throughput = (double)dlDataRxed.at(i) / statsDuration;

        if (throughput != 0 && found == 0)

        {

            NS_TEST_ASSERT_MSG_EQ_TOL(throughput,

                                      m_thrRefDl,

                                      m_thrRefDl * tolerance,

                                      " Unfair Throughput!");

            found = 1;

        }

        else if (throughput != 0 && found == 1)

        {

            NS_TEST_ASSERT_MSG_EQ_TOL(0, m_thrRefDl, m_thrRefDl * tolerance, " Unfair Throughput!");

        }

        else

        {

            NS_TEST_ASSERT_MSG_EQ_TOL(throughput, 0, 0, " Unfair Throughput!");

        }

    }


    /**

     * Check that the uplink assignment is done in a "proportional fair" manner

     */

    NS_LOG_INFO("UL - Test with " << m_nUser << " user(s) at distance " << m_dist);

    std::vector<uint64_t> ulDataRxed;

    for (int i = 0; i < m_nUser; i++)

    {

        // get the imsi

        uint64_t imsi = ueDevs.Get(i)->GetObject<LteUeNetDevice>()->GetImsi();

        // get the lcId

        uint8_t lcId = 3;

        ulDataRxed.push_back(rlcStats->GetUlRxData(imsi, lcId));

        NS_LOG_INFO("\tUser " << i << " imsi " << imsi << " bytes rxed " << (double)ulDataRxed.at(i)

                              << "  thr " << (double)ulDataRxed.at(i) / statsDuration << " ref "

                              << m_thrRefUl);

    }

    /**

     * Check that the assignment is done in a "proportional fair" manner among users

     * with equal SINRs: the bandwidth should be distributed according to the

     * ratio of the estimated throughput per TTI of each user; therefore equally

     * partitioning the whole bandwidth achievable from a single users in a TTI

     */

    for (int i = 0; i < m_nUser; i++)

    {

        NS_TEST_ASSERT_MSG_EQ_TOL((double)ulDataRxed.at(i) / statsDuration,

                                  m_thrRefUl,

                                  m_thrRefUl * tolerance,

                                  " Unfair Throughput!");

    }

    Simulator::Destroy();

}


LenaTestTtaFfMacSchedulerSuite
Lena Test Tta Ff Mac Scheduler Suite.
Definition lte-test-tta-ff-mac-scheduler.h:71

LenaTestTtaFfMacSchedulerSuite::LenaTestTtaFfMacSchedulerSuite
LenaTestTtaFfMacSchedulerSuite()
Definition lte-test-tta-ff-mac-scheduler.cc:47

LenaTtaFfMacSchedulerTestCase
This system test program creates different test cases with a single eNB and several UEs,...
Definition lte-test-tta-ff-mac-scheduler.h:31

LenaTtaFfMacSchedulerTestCase::m_dist
double m_dist
the distance between nodes
Definition lte-test-tta-ff-mac-scheduler.h:59

LenaTtaFfMacSchedulerTestCase::m_thrRefUl
double m_thrRefUl
the UL throughput reference
Definition lte-test-tta-ff-mac-scheduler.h:61

LenaTtaFfMacSchedulerTestCase::LenaTtaFfMacSchedulerTestCase
LenaTtaFfMacSchedulerTestCase(uint16_t nUser, double dist, double thrRefDl, double thrRefUl, bool errorModelEnabled)
Constructor.
Definition lte-test-tta-ff-mac-scheduler.cc:178

LenaTtaFfMacSchedulerTestCase::m_nUser
uint16_t m_nUser
number of UE nodes
Definition lte-test-tta-ff-mac-scheduler.h:58

LenaTtaFfMacSchedulerTestCase::m_errorModelEnabled
bool m_errorModelEnabled
is error model enabled?
Definition lte-test-tta-ff-mac-scheduler.h:62

LenaTtaFfMacSchedulerTestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition lte-test-tta-ff-mac-scheduler.cc:197

LenaTtaFfMacSchedulerTestCase::BuildNameString
static std::string BuildNameString(uint16_t nUser, double dist)
Build name string.
Definition lte-test-tta-ff-mac-scheduler.cc:171

LenaTtaFfMacSchedulerTestCase::~LenaTtaFfMacSchedulerTestCase
~LenaTtaFfMacSchedulerTestCase() override
Definition lte-test-tta-ff-mac-scheduler.cc:192

LenaTtaFfMacSchedulerTestCase::m_thrRefDl
double m_thrRefDl
the DL throughput reference
Definition lte-test-tta-ff-mac-scheduler.h:60

double

ns3::BooleanValue
AttributeValue implementation for Boolean.
Definition boolean.h:26

ns3::ConstantPositionMobilityModel
Mobility model for which the current position does not change once it has been set and until it is se...
Definition constant-position-mobility-model.h:23

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

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

ns3::EpsBearer
This class contains the specification of EPS Bearers.
Definition eps-bearer.h:80

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

ns3::EpsBearer::GBR_CONV_VOICE
@ GBR_CONV_VOICE
GBR Conversational Voice.
Definition eps-bearer.h:96

ns3::FfMacScheduler::SRS_UL_CQI
@ SRS_UL_CQI
Definition ff-mac-scheduler.h:82

ns3::LteEnbNetDevice
The eNodeB device implementation.
Definition lte-enb-net-device.h:48

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

ns3::MobilityHelper
Helper class used to assign positions and mobility models to nodes.
Definition mobility-helper.h:33

ns3::MobilityModel::SetPosition
void SetPosition(const Vector &position)
Definition mobility-model.cc:81

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

ns3::NodeContainer
keep track of a set of node pointers.
Definition node-container.h:29

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

ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition ptr.h:66

ns3::Simulator::Destroy
static void Destroy()
Execute the events scheduled with ScheduleDestroy().
Definition simulator.cc:131

ns3::Simulator::Run
static void Run()
Run the simulation.
Definition simulator.cc:167

ns3::Simulator::Stop
static void Stop()
Tell the Simulator the calling event should be the last one executed.
Definition simulator.cc:175

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

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

ns3::TestCase::AddTestCase
void AddTestCase(TestCase *testCase, Duration duration=Duration::QUICK)
Add an individual child TestCase to this test suite.
Definition test.cc:292

ns3::TestCase::CreateTempDirFilename
std::string CreateTempDirFilename(std::string filename)
Construct the full path to a file in a temporary directory.
Definition test.cc:432

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

ns3::TestSuite::Type
Type
Type of test.
Definition test.h:1274

ns3::TimeValue
AttributeValue implementation for Time.
Definition nstime.h:1431

ns3::Config::SetDefault
void SetDefault(std::string name, const AttributeValue &value)
Definition config.cc:883

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

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

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

lenaTestTtaFfMacSchedulerSuite
static LenaTestTtaFfMacSchedulerSuite lenaTestTtaFfMacSchedulerSuite
Static variable for test initialization.
Definition lte-test-tta-ff-mac-scheduler.cc:166

ns3::Create
Ptr< T > Create(Ts &&... args)
Create class instances by constructors with varying numbers of arguments and return them by Ptr.
Definition ptr.h:436

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

ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition nstime.h:1344

lte-test-tta-ff-mac-scheduler.h

ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.

throughput
std::ofstream throughput
Definition tcp-bbr-example.cc:58