cttc-3gpp-indoor-calibration.cc

Go to the documentation of this file.

// Copyright (c) 2020 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
//
// SPDX-License-Identifier: GPL-2.0-only
 
#include "ns3/antenna-module.h"
#include "ns3/applications-module.h"
#include "ns3/config-store-module.h"
#include "ns3/core-module.h"
#include "ns3/internet-module.h"
#include "ns3/mobility-module.h"
#include "ns3/nr-eps-bearer-tag.h"
#include "ns3/nr-module.h"
#include "ns3/point-to-point-helper.h"
 
using namespace ns3;
 
NS_LOG_COMPONENT_DEFINE("Nr3gppIndoorCalibration");
 
struct DroppingParameters
{
    bool ueAntennaPolarization;
    bool gnbAntennaPolarization;
    uint8_t numVPortsGnb = 1;
    uint8_t numHPortsGnb = 1;
    uint8_t numVPortsUe = 1;
    uint8_t numHPortsUe = 1;
    DroppingParameters()
        : ueAntennaPolarization(false),
          gnbAntennaPolarization(false){};
    DroppingParameters(bool isUePolarized, bool isGnbPolarized)
        : ueAntennaPolarization(isUePolarized),
          gnbAntennaPolarization(isGnbPolarized){};
    DroppingParameters(bool isUePolarized, bool isGnbPolarized, uint8_t nVGnb, uint8_t nHGnb)
        : ueAntennaPolarization(isUePolarized),
          gnbAntennaPolarization(isGnbPolarized),
          numVPortsGnb(nVGnb),
          numHPortsGnb(nHGnb){};
    DroppingParameters(bool isUePolarized,
                       bool isGnbPolarized,
                       uint8_t nVGnb,
                       uint8_t nHGnb,
                       uint8_t nVUe,
                       uint8_t nHUe)
        : ueAntennaPolarization(isUePolarized),
          gnbAntennaPolarization(isGnbPolarized),
          numVPortsGnb(nVGnb),
          numHPortsGnb(nHGnb),
          numVPortsUe(nVUe),
          numHPortsUe(nHUe){};
};
 
class Nr3gppIndoorCalibration
{
  public:
    void UeReception(RxPacketTraceParams params);
 
    void UeSnrPerProcessedChunk(double snr);
 
    void UeRssiPerProcessedChunk(double rssidBm);
 
    void Run(double centralFrequencyBand,
             double bandwidthBand,
             uint16_t numerology,
             double totalTxPower,
             bool cellScan,
             double beamSearchAngleStep,
             bool gNbAntennaModel,
             bool ueAntennaModel,
             std::string indoorScenario,
             double speed,
             std::string resultsDirPath,
             std::string tag,
             uint32_t duration,
             DroppingParameters dropParam = DroppingParameters());
    ~Nr3gppIndoorCalibration();
 
    NodeContainer SelectWellPlacedUes(const NodeContainer ueNodes,
                                      const NodeContainer gnbNodes,
                                      double min3DDistance,
                                      uint32_t numberOfUesToBeSelected);
 
  private:
    std::ofstream m_outSinrFile;         
    std::ofstream m_outSnrFile;          
    std::ofstream m_outRssiFile;         
    std::ofstream m_outUePositionsFile;  
    std::ofstream m_outGnbPositionsFile; 
    std::ofstream m_outDistancesFile;    
};
 
std::string
BuildFileNameString(std::string directoryName, std::string filePrefix, std::string tag)
{
    std::ostringstream oss;
    oss << directoryName << filePrefix << tag;
    return oss.str();
}
 
std::string
BuildTag(bool gNbAntennaModel, bool ueAntennaModel, std::string scenario, double speed)
{
    std::ostringstream oss;
    std::string ao;
 
    std::string gnbAm;
    if (gNbAntennaModel)
    {
        gnbAm = "ISO";
    }
    else
    {
        gnbAm = "3GPP";
    }
 
    std::string ueAm;
    if (ueAntennaModel)
    {
        ueAm = "ISO";
    }
    else
    {
        ueAm = "3GPP";
    }
 
    std::string gm = "";
    oss << "-ao" << ao << "-amGnb" << gnbAm << "-amUE" << ueAm << "-sc" << scenario << "-sp"
        << speed << "-gm" << gm;
 
    return oss.str();
}
 
void
UeReceptionTrace(Nr3gppIndoorCalibration* scenario, RxPacketTraceParams params)
{
    scenario->UeReception(params);
}
 
void
UeSnrPerProcessedChunkTrace(Nr3gppIndoorCalibration* scenario, double snr)
{
    scenario->UeSnrPerProcessedChunk(snr);
}
 
void
UeRssiPerProcessedChunkTrace(Nr3gppIndoorCalibration* scenario, double rssidBm)
{
    scenario->UeRssiPerProcessedChunk(rssidBm);
}
 
void
Nr3gppIndoorCalibration::UeReception(RxPacketTraceParams params)
{
    m_outSinrFile << params.m_cellId << params.m_rnti << "\t" << 10 * log10(params.m_sinr)
                  << std::endl;
}
 
void
Nr3gppIndoorCalibration::UeSnrPerProcessedChunk(double snr)
{
    m_outSnrFile << 10 * log10(snr) << std::endl;
}
 
void
Nr3gppIndoorCalibration::UeRssiPerProcessedChunk(double rssidBm)
{
    m_outRssiFile << rssidBm << std::endl;
}
 
Nr3gppIndoorCalibration::~Nr3gppIndoorCalibration()
{
    m_outSinrFile.close();
    m_outSnrFile.close();
    m_outRssiFile.close();
}
 
NodeContainer
Nr3gppIndoorCalibration::SelectWellPlacedUes(const NodeContainer ueNodes,
                                             const NodeContainer gnbNodes,
                                             double minDistance,
                                             uint32_t numberOfUesToBeSelected)
{
    NodeContainer ueNodesFiltered;
    bool correctDistance = true;
 
    for (NodeContainer::Iterator itUe = ueNodes.Begin(); itUe != ueNodes.End(); itUe++)
    {
        correctDistance = true;
        Ptr<MobilityModel> ueMm = (*itUe)->GetObject<MobilityModel>();
        Vector uePos = ueMm->GetPosition();
 
        for (NodeContainer::Iterator itGnb = gnbNodes.Begin(); itGnb != gnbNodes.End(); itGnb++)
        {
            Ptr<MobilityModel> gnbMm = (*itGnb)->GetObject<MobilityModel>();
            Vector gnbPos = gnbMm->GetPosition();
            double x = uePos.x - gnbPos.x;
            double y = uePos.y - gnbPos.y;
            double distance = sqrt(x * x + y * y);
 
            if (distance < minDistance)
            {
                correctDistance = false;
                // NS_LOG("The UE node "<<(*itUe)->GetId() << " has wrong position, discarded.");
                break;
            }
            else
            {
                m_outDistancesFile << distance << std::endl;
            }
        }
 
        if (correctDistance)
        {
            ueNodesFiltered.Add(*itUe);
        }
        if (ueNodesFiltered.GetN() >= numberOfUesToBeSelected)
        {
            // there are enough candidate UE nodes
            break;
        }
    }
    return ueNodesFiltered;
}
 
void
Nr3gppIndoorCalibration::Run(double centralFrequencyBand,
                             double bandwidthBand,
                             uint16_t numerology,
                             double totalTxPower,
                             bool cellScan,
                             double beamSearchAngleStep,
                             bool gNbAntennaModel,
                             bool ueAntennaModel,
                             std::string indoorScenario,
                             double speed,
                             std::string resultsDirPath,
                             std::string tag,
                             uint32_t duration,
                             DroppingParameters dropParam)
{
    Time simTime = MilliSeconds(duration);
    Time udpAppStartTimeDl = MilliSeconds(100);
    Time udpAppStopTimeDl = MilliSeconds(duration);
    uint32_t packetSize = 1000;
    DataRate udpRate = DataRate("0.1kbps");
    // initially created 240 UE nodes, out of which will be selected 120 UEs that
    // are well placed respecting the minimum distance parameter that is configured
    uint16_t ueCount = 240;
    // the minimum distance parameter
    double minDistance = 0;
    // BS atnenna height is 3 meters
    double gNbHeight = 3;
    // UE antenna height is 1.5 meters
    double ueHeight = 1.5;
 
    NS_ABORT_MSG_UNLESS(indoorScenario == "InH-OfficeOpen" || indoorScenario == "InH-OfficeMixed",
                        "The scenario is not supported");
 
    // if simulation tag is not provided create one
    if (tag.empty())
    {
        tag = BuildTag(gNbAntennaModel, ueAntennaModel, indoorScenario, speed);
    }
    std::string filenameSinr = BuildFileNameString(resultsDirPath, "sinrs", tag);
    std::string filenameSnr = BuildFileNameString(resultsDirPath, "snrs", tag);
    std::string filenameRssi = BuildFileNameString(resultsDirPath, "rssi", tag);
    std::string filenameUePositions = BuildFileNameString(resultsDirPath, "ue-positions", tag);
    std::string filenameGnbPositions = BuildFileNameString(resultsDirPath, "gnb-positions", tag);
    std::string filenameDistances = BuildFileNameString(resultsDirPath, "distances", tag);
 
    m_outSinrFile.open(filenameSinr.c_str());
    m_outSinrFile.setf(std::ios_base::fixed);
 
    if (!m_outSinrFile.is_open())
    {
        NS_ABORT_MSG("Can't open file " << filenameSinr);
    }
 
    m_outSnrFile.open(filenameSnr.c_str());
    m_outSnrFile.setf(std::ios_base::fixed);
 
    if (!m_outSnrFile.is_open())
    {
        NS_ABORT_MSG("Can't open file " << filenameSnr);
    }
 
    m_outRssiFile.open(filenameRssi.c_str());
    m_outRssiFile.setf(std::ios_base::fixed);
 
    if (!m_outRssiFile.is_open())
    {
        NS_ABORT_MSG("Can't open file " << filenameRssi);
    }
 
    m_outUePositionsFile.open(filenameUePositions.c_str());
    m_outUePositionsFile.setf(std::ios_base::fixed);
 
    if (!m_outUePositionsFile.is_open())
    {
        NS_ABORT_MSG("Can't open file " << filenameUePositions);
    }
 
    m_outGnbPositionsFile.open(filenameGnbPositions.c_str());
    m_outGnbPositionsFile.setf(std::ios_base::fixed);
 
    if (!m_outGnbPositionsFile.is_open())
    {
        NS_ABORT_MSG("Can't open file " << filenameGnbPositions);
    }
 
    m_outDistancesFile.open(filenameDistances.c_str());
    m_outDistancesFile.setf(std::ios_base::fixed);
 
    if (!m_outDistancesFile.is_open())
    {
        NS_ABORT_MSG("Can't open file " << filenameDistances);
    }
 
    // create base stations and mobile terminals
    NodeContainer gNbNodes;
    NodeContainer ueNodes;
    MobilityHelper mobility;
 
    gNbNodes.Create(12);
    ueNodes.Create(ueCount);
 
    // Creating positions of the gNB according to the 3GPP TR 38.901 Figure 7.2.-1
    Ptr<ListPositionAllocator> gNbPositionAlloc = CreateObject<ListPositionAllocator>();
 
    for (uint8_t j = 0; j < 2; j++)
    {
        for (uint8_t i = 0; i < 6; i++)
        {
            gNbPositionAlloc->Add(Vector(i * 20, j * 20, gNbHeight));
        }
    }
 
    mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
    mobility.SetPositionAllocator(gNbPositionAlloc);
    mobility.Install(gNbNodes);
 
    double minBigBoxX = -10.0;
    double minBigBoxY = -15.0;
    double maxBigBoxX = 110.0;
    double maxBigBoxY = 35.0;
 
    // Creating positions of the UEs according to the 3GPP TR 38.901 and
    // R11700144, uniformly randombly distributed in the rectangular area
 
    NodeContainer selectedUeNodes;
    for (uint8_t j = 0; j < 2; j++)
    {
        double minSmallBoxY = minBigBoxY + j * (maxBigBoxY - minBigBoxY) / 2;
 
        for (uint8_t i = 0; i < 6; i++)
        {
            double minSmallBoxX = minBigBoxX + i * (maxBigBoxX - minBigBoxX) / 6;
            Ptr<UniformRandomVariable> ueRandomVarX = CreateObject<UniformRandomVariable>();
 
            double minX = minSmallBoxX;
            double maxX = minSmallBoxX + (maxBigBoxX - minBigBoxX) / 6 - 0.0001;
            double minY = minSmallBoxY;
            double maxY = minSmallBoxY + (maxBigBoxY - minBigBoxY) / 2 - 0.0001;
 
            Ptr<RandomBoxPositionAllocator> ueRandomRectPosAlloc =
                CreateObject<RandomBoxPositionAllocator>();
            ueRandomVarX->SetAttribute("Min", DoubleValue(minX));
            ueRandomVarX->SetAttribute("Max", DoubleValue(maxX));
            ueRandomRectPosAlloc->SetX(ueRandomVarX);
            Ptr<UniformRandomVariable> ueRandomVarY = CreateObject<UniformRandomVariable>();
            ueRandomVarY->SetAttribute("Min", DoubleValue(minY));
            ueRandomVarY->SetAttribute("Max", DoubleValue(maxY));
            ueRandomRectPosAlloc->SetY(ueRandomVarY);
            Ptr<ConstantRandomVariable> ueRandomVarZ = CreateObject<ConstantRandomVariable>();
            ueRandomVarZ->SetAttribute("Constant", DoubleValue(ueHeight));
            ueRandomRectPosAlloc->SetZ(ueRandomVarZ);
 
            uint8_t smallBoxIndex = j * 6 + i;
 
            NodeContainer smallBoxCandidateNodes;
            NodeContainer smallBoxGnbNode;
 
            smallBoxGnbNode.Add(gNbNodes.Get(smallBoxIndex));
 
            for (uint32_t n = smallBoxIndex * ueCount / 12;
                 n < smallBoxIndex * static_cast<uint32_t>(ueCount / 12) +
                         static_cast<uint32_t>(ueCount / 12);
                 n++)
            {
                smallBoxCandidateNodes.Add(ueNodes.Get(n));
            }
            mobility.SetPositionAllocator(ueRandomRectPosAlloc);
            mobility.Install(smallBoxCandidateNodes);
            NodeContainer sn =
                SelectWellPlacedUes(smallBoxCandidateNodes, smallBoxGnbNode, minDistance, 10);
            selectedUeNodes.Add(sn);
        }
    }
 
    for (uint32_t j = 0; j < selectedUeNodes.GetN(); j++)
    {
        Vector v = selectedUeNodes.Get(j)->GetObject<MobilityModel>()->GetPosition();
        m_outUePositionsFile << j << "\t" << v.x << "\t" << v.y << "\t" << v.z << " " << std::endl;
    }
 
    for (uint32_t j = 0; j < gNbNodes.GetN(); j++)
    {
        Vector v = gNbNodes.Get(j)->GetObject<MobilityModel>()->GetPosition();
        m_outGnbPositionsFile << j << "\t" << v.x << "\t" << v.y << "\t" << v.z << " " << std::endl;
    }
 
    m_outUePositionsFile.close();
    m_outGnbPositionsFile.close();
    m_outDistancesFile.close();
 
    // setup the nr simulation
    Ptr<NrHelper> nrHelper = CreateObject<NrHelper>();
    Ptr<NrPointToPointEpcHelper> nrEpcHelper = CreateObject<NrPointToPointEpcHelper>();
    Ptr<IdealBeamformingHelper> idealBeamformingHelper = CreateObject<IdealBeamformingHelper>();
    Ptr<NrChannelHelper> channelHelper = CreateObject<NrChannelHelper>();
 
    nrHelper->SetBeamformingHelper(idealBeamformingHelper);
    nrHelper->SetEpcHelper(nrEpcHelper);
    channelHelper->ConfigureFactories(indoorScenario, "Default", "ThreeGpp");
 
    /*
     * Spectrum division. We create one operational band, containing one
     * component carrier, which in turn contains a single bandwidth part
     * centered at the frequency specified by the input parameters.
     *
     * The configured spectrum division is:
     * |------------------------Band-------------------------|
     * |-------------------------CC--------------------------|
     * |-------------------------BWP-------------------------|
     *
     * Each spectrum part length is, as well, specified by the input parameters.
     * The band will use the indoor channel modeling specified by scenario.
     */
    BandwidthPartInfoPtrVector allBwps;
    CcBwpCreator ccBwpCreator;
    const uint8_t numCcPerBand = 1;
 
    // Create the configuration for the CcBwpHelper. SimpleOperationBandConf creates
    // a single BWP per CC
    CcBwpCreator::SimpleOperationBandConf bandConf(centralFrequencyBand,
                                                   bandwidthBand,
                                                   numCcPerBand);
 
    // By using the configuration created, make the operation band
    OperationBandInfo band = ccBwpCreator.CreateOperationBandContiguousCc(bandConf);
    // Set and create the channel for the band
    channelHelper->AssignChannelsToBands({band});
    allBwps = CcBwpCreator::GetAllBwps({band});
 
    // Disable channel matrix update to speed up the simulation execution
    // Config::SetDefault ("ns3::Nr3gppChannel::UpdatePeriod", TimeValue (MilliSeconds(0)));
    // Config::SetDefault ("ns3::NrRlcUm::MaxTxBufferSize", UintegerValue(999999999));
    // Config::SetDefault ("ns3::NrRlcUmLowLat::MaxTxBufferSize", UintegerValue(999999999));
    Config::SetDefault("ns3::NrGnbRrc::SrsPeriodicity", UintegerValue(320));
 
    if (cellScan)
    {
        idealBeamformingHelper->SetAttribute("BeamformingMethod",
                                             TypeIdValue(CellScanBeamforming::GetTypeId()));
        idealBeamformingHelper->SetBeamformingAlgorithmAttribute("BeamSearchAngleStep",
                                                                 DoubleValue(beamSearchAngleStep));
    }
    else
    {
        idealBeamformingHelper->SetAttribute("BeamformingMethod",
                                             TypeIdValue(DirectPathBeamforming::GetTypeId()));
    }
 
    nrHelper->SetSchedulerTypeId(TypeId::LookupByName("ns3::NrMacSchedulerTdmaPF"));
 
    // Antennas for all the UEs - Should be 2x4 = 8 antenna elements
    nrHelper->SetUeAntennaAttribute("NumRows", UintegerValue(2));
    nrHelper->SetUeAntennaAttribute("NumColumns", UintegerValue(4));
    // Antenna element type for UEs
    if (ueAntennaModel)
    {
        nrHelper->SetUeAntennaAttribute("AntennaElement",
                                        PointerValue(CreateObject<IsotropicAntennaModel>()));
    }
    else
    {
        nrHelper->SetUeAntennaAttribute("AntennaElement",
                                        PointerValue(CreateObject<ThreeGppAntennaModel>()));
    }
    // Antennas for all the gNbs - Should be 4x8 = 32 antenna elements
    nrHelper->SetGnbAntennaAttribute("NumRows", UintegerValue(4));
    nrHelper->SetGnbAntennaAttribute("NumColumns", UintegerValue(8));
    // Antenna element type for gNBs
    if (gNbAntennaModel)
    {
        nrHelper->SetGnbAntennaAttribute("AntennaElement",
                                         PointerValue(CreateObject<IsotropicAntennaModel>()));
    }
    else
    {
        nrHelper->SetGnbAntennaAttribute("AntennaElement",
                                         PointerValue(CreateObject<ThreeGppAntennaModel>()));
    }
 
    // Setting antenna polarization for gNB and UE
    if (dropParam.gnbAntennaPolarization)
    {
        nrHelper->SetGnbAntennaAttribute("IsPolarized", BooleanValue(true));
    }
    if (dropParam.ueAntennaPolarization)
    {
        nrHelper->SetUeAntennaAttribute("IsPolarized", BooleanValue(true));
    }
    nrHelper->SetGnbAntennaAttribute("NumVerticalPorts", UintegerValue(dropParam.numVPortsGnb));
    nrHelper->SetGnbAntennaAttribute("NumHorizontalPorts", UintegerValue(dropParam.numHPortsGnb));
    nrHelper->SetUeAntennaAttribute("NumVerticalPorts", UintegerValue(dropParam.numVPortsUe));
    nrHelper->SetUeAntennaAttribute("NumHorizontalPorts", UintegerValue(dropParam.numHPortsUe));
    // mobility.SetPositionAllocator (ueRandomRectPosAlloc);
    // install nr net devices
    NetDeviceContainer gNbDevs = nrHelper->InstallGnbDevice(gNbNodes, allBwps);
    NetDeviceContainer ueNetDevs = nrHelper->InstallUeDevice(selectedUeNodes, allBwps);
 
    int64_t randomStream = 1;
    randomStream += nrHelper->AssignStreams(gNbDevs, randomStream);
    randomStream += nrHelper->AssignStreams(ueNetDevs, randomStream);
 
    for (uint32_t i = 0; i < gNbDevs.GetN(); i++)
    {
        nrHelper->GetGnbPhy(gNbDevs.Get(i), 0)
            ->SetAttribute("Numerology", UintegerValue(numerology));
        // Remove log operation when input is in dBm
        nrHelper->GetGnbPhy(gNbDevs.Get(i), 0)->SetAttribute("TxPower", DoubleValue(totalTxPower));
        // gNB noise figure shall be set to 7 dB
        nrHelper->GetGnbPhy(gNbDevs.Get(i), 0)->SetAttribute("NoiseFigure", DoubleValue(7));
    }
    for (uint32_t j = 0; j < ueNetDevs.GetN(); j++)
    {
        // UE noise figure shall be set to 10 dB
        nrHelper->GetUePhy(ueNetDevs.Get(j), 0)->SetAttribute("NoiseFigure", DoubleValue(10));
    }
 
    // create the internet and install the IP stack on the UEs
    // get SGW/PGW and create a single RemoteHost
    auto [remoteHost, remoteHostIpv4Address] =
        nrEpcHelper->SetupRemoteHost("100Gb/s", 2500, Seconds(0.000));
 
    InternetStackHelper internet;
    internet.Install(ueNodes);
    Ipv4InterfaceContainer ueIpIface;
    ueIpIface = nrEpcHelper->AssignUeIpv4Address(NetDeviceContainer(ueNetDevs));
 
    // attach UEs to the closest gNB
    nrHelper->AttachToClosestGnb(ueNetDevs, gNbDevs);
 
    // assign IP address to UEs, and install UDP downlink applications
    uint16_t dlPort = 1234;
    ApplicationContainer clientAppsDl;
    ApplicationContainer serverAppsDl;
 
    Time udpInterval =
        Time::FromDouble((packetSize * 8) / static_cast<double>(udpRate.GetBitRate()), Time::S);
 
    UdpServerHelper dlPacketSinkHelper(dlPort);
    serverAppsDl.Add(dlPacketSinkHelper.Install(ueNodes));
 
    // configure UDP downlink traffic
    for (uint32_t i = 0; i < ueNetDevs.GetN(); i++)
    {
        UdpClientHelper dlClient(ueIpIface.GetAddress(i), dlPort);
        dlClient.SetAttribute("MaxPackets", UintegerValue(0xFFFFFFFF));
        dlClient.SetAttribute("PacketSize", UintegerValue(packetSize));
        dlClient.SetAttribute(
            "Interval",
            TimeValue(udpInterval)); // we try to saturate, we just need to measure during a short
                                     // time, how much traffic can handle each BWP
        clientAppsDl.Add(dlClient.Install(remoteHost));
    }
 
    // start UDP server and client apps
    serverAppsDl.Start(udpAppStartTimeDl);
    clientAppsDl.Start(udpAppStartTimeDl);
 
    serverAppsDl.Stop(udpAppStopTimeDl);
    clientAppsDl.Stop(udpAppStopTimeDl);
 
    for (uint32_t i = 0; i < ueNetDevs.GetN(); i++)
    {
        Ptr<NrSpectrumPhy> ue1SpectrumPhy =
            DynamicCast<NrUeNetDevice>(ueNetDevs.Get(i))->GetPhy(0)->GetSpectrumPhy();
        ue1SpectrumPhy->TraceConnectWithoutContext("RxPacketTraceUe",
                                                   MakeBoundCallback(&UeReceptionTrace, this));
        Ptr<NrInterference> ue1SpectrumPhyInterference = ue1SpectrumPhy->GetNrInterference();
        NS_ABORT_IF(!ue1SpectrumPhyInterference);
        ue1SpectrumPhyInterference->TraceConnectWithoutContext(
            "SnrPerProcessedChunk",
            MakeBoundCallback(&UeSnrPerProcessedChunkTrace, this));
        ue1SpectrumPhyInterference->TraceConnectWithoutContext(
            "RssiPerProcessedChunk",
            MakeBoundCallback(&UeRssiPerProcessedChunkTrace, this));
    }
 
    Simulator::Stop(simTime);
    Simulator::Run();
    Simulator::Destroy();
}
 
int
main(int argc, char* argv[])
{
    // Parameters according to R1-1703534 3GPP TSG RAN WG1 Meetging #88, 2017
    // Evaluation assumptions for Phase 1 NR MIMO system level calibration,
    double centralFrequencyBand = 30e9;
    double bandwidthBand = 40e6;
    uint16_t numerology = 2;
    double totalTxPower = 23;
 
    uint32_t duration = 150;
    bool cellScan = false;
    double beamSearchAngleStep = 10.0;
    bool enableGnbIso = true;
    bool enableUeIso = true;
    std::string indoorScenario = "InH-OfficeOpen";
    double speed = 3.00;
    bool polarizedAntennas = false;
    std::string outdir = "./";
    std::string simTag = "";
    uint8_t numVPortsGnb = 1;
    uint8_t numHPortsGnb = 1;
    uint8_t numVPortsUe = 1;
    uint8_t numHPortsUe = 1;
 
    CommandLine cmd(__FILE__);
 
    cmd.AddValue("duration",
                 "Simulation duration in ms, should be greater than 100 ms to allow the collection "
                 "of traces",
                 duration);
    cmd.AddValue("cellScan",
                 "Use beam search method to determine beamforming vector,"
                 "true to use cell scanning method",
                 cellScan);
    cmd.AddValue("beamSearchAngleStep",
                 "Beam search angle step for beam search method",
                 beamSearchAngleStep);
    cmd.AddValue("enableGnbIso", "Enable Isotropic antenna for the gNB", enableGnbIso);
    cmd.AddValue("enableGnbIso", "Enable Isotropic antenna for the UE", enableUeIso);
    cmd.AddValue("indoorScenario",
                 "The indoor scenario to be used can be: InH-OfficeMixed or InH-OfficeOpen",
                 indoorScenario);
    cmd.AddValue("speed", "UE speed in km/h", speed);
    cmd.AddValue("outdir", "directory where to store the simulation results", outdir);
    cmd.AddValue("polarizedAntennas",
                 "Set true to to make UE and Gnb anetnna polarized",
                 polarizedAntennas);
    cmd.AddValue("simTag",
                 "tag to be appended to output filenames to distinguish simulation campaigns",
                 simTag);
    cmd.AddValue("vportGnb", "Set GNB Vertical Ports", numVPortsGnb);
    cmd.AddValue("hportGnb", "Set GNB Horizontal Ports", numHPortsGnb);
    cmd.AddValue("vportUe", "Set UE Vertical Ports", numVPortsUe);
    cmd.AddValue("hportUE", "Set UE Horizontal Ports", numHPortsUe);
 
    cmd.Parse(argc, argv);
 
    ConfigStore inputConfig;
    inputConfig.ConfigureDefaults();
 
    Nr3gppIndoorCalibration phase1CalibrationScenario;
 
    DroppingParameters dropParam = {polarizedAntennas,
                                    polarizedAntennas,
                                    numVPortsGnb,
                                    numHPortsGnb,
                                    numVPortsUe,
                                    numHPortsUe};
 
    phase1CalibrationScenario.Run(centralFrequencyBand,
                                  bandwidthBand,
                                  numerology,
                                  totalTxPower,
                                  cellScan,
                                  beamSearchAngleStep,
                                  enableGnbIso,
                                  enableUeIso,
                                  indoorScenario,
                                  speed,
                                  outdir,
                                  simTag,
                                  duration,
                                  dropParam);
    return 0;
}