diff --git a/examples/realtime/realtime-udp-echo.py b/examples/realtime/realtime-udp-echo.py index be3ea87c1..626ef3afb 100644 --- a/examples/realtime/realtime-udp-echo.py +++ b/examples/realtime/realtime-udp-echo.py @@ -23,49 +23,52 @@ # - DropTail queues # - Tracing of queues and packet receptions to file "udp-echo.tr" -import ns3 - +import ns.applications +import ns.core +import ns.csma +import ns.internet +import ns.network def main(argv): # # Allow the user to override any of the defaults and the above Bind() at # run-time, via command-line arguments # - cmd = ns3.CommandLine() + cmd = ns.core.CommandLine() cmd.Parse(argv) # # But since this is a realtime script, don't allow the user to mess with # that. # - ns3.GlobalValue.Bind("SimulatorImplementationType", ns3.StringValue("ns3::RealtimeSimulatorImpl")) + ns.core.GlobalValue.Bind("SimulatorImplementationType", ns.core.StringValue("ns3::RealtimeSimulatorImpl")) # # Explicitly create the nodes required by the topology (shown above). # print "Create nodes." - n = ns3.NodeContainer() + n = ns.network.NodeContainer() n.Create(4) - internet = ns3.InternetStackHelper() + internet = ns.internet.InternetStackHelper() internet.Install(n) # # Explicitly create the channels required by the topology (shown above). # print ("Create channels.") - csma = ns3.CsmaHelper() - csma.SetChannelAttribute("DataRate", ns3.DataRateValue(ns3.DataRate(5000000))) - csma.SetChannelAttribute("Delay", ns3.TimeValue(ns3.MilliSeconds(2))); - csma.SetDeviceAttribute("Mtu", ns3.UintegerValue(1400)) + csma = ns.csma.CsmaHelper() + csma.SetChannelAttribute("DataRate", ns.network.DataRateValue(ns.network.DataRate(5000000))) + csma.SetChannelAttribute("Delay", ns.core.TimeValue(ns.core.MilliSeconds(2))); + csma.SetDeviceAttribute("Mtu", ns.core.UintegerValue(1400)) d = csma.Install(n) # # We've got the "hardware" in place. Now we need to add IP addresses. # print ("Assign IP Addresses.") - ipv4 = ns3.Ipv4AddressHelper() - ipv4.SetBase(ns3.Ipv4Address("10.1.1.0"), ns3.Ipv4Mask("255.255.255.0")) + ipv4 = ns.internet.Ipv4AddressHelper() + ipv4.SetBase(ns.network.Ipv4Address("10.1.1.0"), ns.network.Ipv4Mask("255.255.255.0")) i = ipv4.Assign(d) print ("Create Applications.") @@ -74,10 +77,10 @@ def main(argv): # Create a UdpEchoServer application on node one. # port = 9 # well-known echo port number - server = ns3.UdpEchoServerHelper(port) + server = ns.applications.UdpEchoServerHelper(port) apps = server.Install(n.Get(1)) - apps.Start(ns3.Seconds(1.0)) - apps.Stop(ns3.Seconds(10.0)) + apps.Start(ns.core.Seconds(1.0)) + apps.Stop(ns.core.Seconds(10.0)) # # Create a UdpEchoClient application to send UDP datagrams from node zero to @@ -85,16 +88,16 @@ def main(argv): # packetSize = 1024 maxPacketCount = 500 - interPacketInterval = ns3.Seconds(0.01) - client = ns3.UdpEchoClientHelper(i.GetAddress (1), port) - client.SetAttribute("MaxPackets", ns3.UintegerValue(maxPacketCount)) - client.SetAttribute("Interval", ns3.TimeValue(interPacketInterval)) - client.SetAttribute("PacketSize", ns3.UintegerValue(packetSize)) + interPacketInterval = ns.core.Seconds(0.01) + client = ns.applications.UdpEchoClientHelper(i.GetAddress (1), port) + client.SetAttribute("MaxPackets", ns.core.UintegerValue(maxPacketCount)) + client.SetAttribute("Interval", ns.core.TimeValue(interPacketInterval)) + client.SetAttribute("PacketSize", ns.core.UintegerValue(packetSize)) apps = client.Install(n.Get(0)) - apps.Start(ns3.Seconds(2.0)) - apps.Stop(ns3.Seconds(10.0)) + apps.Start(ns.core.Seconds(2.0)) + apps.Stop(ns.core.Seconds(10.0)) - ascii = ns3.AsciiTraceHelper() + ascii = ns.network.AsciiTraceHelper() csma.EnableAsciiAll(ascii.CreateFileStream("realtime-udp-echo.tr")) csma.EnablePcapAll("realtime-udp-echo", False) @@ -102,8 +105,8 @@ def main(argv): # Now, do the actual simulation. # print ("Run Simulation.") - ns3.Simulator.Run() - ns3.Simulator.Destroy() + ns.core.Simulator.Run() + ns.core.Simulator.Destroy() print ("Done.") if __name__ == '__main__': diff --git a/examples/realtime/wscript b/examples/realtime/wscript index bd2b4e569..95e38398a 100644 --- a/examples/realtime/wscript +++ b/examples/realtime/wscript @@ -3,3 +3,5 @@ def build(bld): obj = bld.create_ns3_program('realtime-udp-echo', ['csma', 'internet']) obj.source = 'realtime-udp-echo.cc' + + bld.register_ns3_script('realtime-udp-echo.py', ['csma', 'internet', 'applications']) diff --git a/src/internet/model/rtt-estimator.cc b/src/internet/model/rtt-estimator.cc index fefa2bf16..57af9915f 100644 --- a/src/internet/model/rtt-estimator.cc +++ b/src/internet/model/rtt-estimator.cc @@ -105,7 +105,8 @@ RttEstimator::RttEstimator () : next (1), history (), RttEstimator::RttEstimator(const RttEstimator& c) : Object (c), next(c.next), history(c.history), - m_maxMultiplier (c.m_maxMultiplier), est(c.est), nSamples(c.nSamples), + m_maxMultiplier (c.m_maxMultiplier), est(c.est), + minrto(c.minrto), nSamples(c.nSamples), multiplier(c.multiplier) {} diff --git a/src/lte/helper/lena-helper.cc b/src/lte/helper/lena-helper.cc index 7f79028b0..a687bf816 100644 --- a/src/lte/helper/lena-helper.cc +++ b/src/lte/helper/lena-helper.cc @@ -272,7 +272,6 @@ LenaHelper::InstallSingleUeDevice (Ptr n) n->AddDevice (dev); dlPhy->SetGenericPhyRxEndOkCallback (MakeCallback (&LteUePhy::PhyPduReceived, phy)); - dev->Start (); return dev; } @@ -306,8 +305,12 @@ LenaHelper::Attach (Ptr ueDevice, Ptr enbDevice) // WILD HACK - should be done through PHY SAP, probably passing by RRC uePhy->SetRnti (rnti); - uePhy->DoSetBandwidth (enbDevice->GetObject ()->GetUlBandwidth (), + uePhy->DoSetBandwidth (enbDevice->GetObject ()->GetUlBandwidth (), enbDevice->GetObject ()->GetDlBandwidth ()); + uePhy->DoSetEarfcn (enbDevice->GetObject ()->GetDlEarfcn (), + enbDevice->GetObject ()->GetUlEarfcn ()); + + ueDevice->Start (); } @@ -347,7 +350,7 @@ LenaHelper::EnableLogComponents (void) LogComponentEnable ("LtePhy", LOG_LEVEL_ALL); LogComponentEnable ("LteEnbPhy", LOG_LEVEL_ALL); LogComponentEnable ("LteUePhy", LOG_LEVEL_ALL); - + LogComponentEnable ("LteSpectrumValueHelper", LOG_LEVEL_ALL); LogComponentEnable ("LteSpectrumPhy", LOG_LEVEL_ALL); LogComponentEnable ("LteInterference", LOG_LEVEL_ALL); LogComponentEnable ("LteSinrChunkProcessor", LOG_LEVEL_ALL); diff --git a/src/lte/model/lte-enb-net-device.cc b/src/lte/model/lte-enb-net-device.cc index 0f2f2d993..df8b996f4 100644 --- a/src/lte/model/lte-enb-net-device.cc +++ b/src/lte/model/lte-enb-net-device.cc @@ -76,13 +76,13 @@ TypeId LteEnbNetDevice::GetTypeId (void) MakePointerAccessor (&LteEnbNetDevice::m_phy), MakePointerChecker ()) .AddAttribute ("UlBandwidth", - "Uplink bandwidth in number of Resource Blocks", + "Uplink Transmission Bandwidth Configuration in number of Resource Blocks", UintegerValue (25), MakeUintegerAccessor (&LteEnbNetDevice::SetUlBandwidth, &LteEnbNetDevice::GetUlBandwidth), MakeUintegerChecker ()) .AddAttribute ("DlBandwidth", - "Downlink bandwidth in number of Resource Blocks", + "Downlink Transmission Bandwidth Configuration in number of Resource Blocks", UintegerValue (25), MakeUintegerAccessor (&LteEnbNetDevice::SetDlBandwidth, &LteEnbNetDevice::GetDlBandwidth), @@ -92,6 +92,18 @@ TypeId LteEnbNetDevice::GetTypeId (void) UintegerValue (0), MakeUintegerAccessor (&LteEnbNetDevice::m_cellId), MakeUintegerChecker ()) + .AddAttribute ("DlEarfcn", + "Downlink E-UTRA Absolute Radio Frequency Channel Number (EARFCN) " + "as per 3GPP 36.101 Section 5.7.3. ", + UintegerValue (100), + MakeUintegerAccessor (&LteEnbNetDevice::m_dlEarfcn), + MakeUintegerChecker ()) + .AddAttribute ("UlEarfcn", + "Uplink E-UTRA Absolute Radio Frequency Channel Number (EARFCN) " + "as per 3GPP 36.101 Section 5.7.3. ", + UintegerValue (18100), + MakeUintegerAccessor (&LteEnbNetDevice::m_ulEarfcn), + MakeUintegerChecker ()) ; return tid; } @@ -220,11 +232,39 @@ LteEnbNetDevice::SetDlBandwidth (uint8_t bw) } } +uint16_t +LteEnbNetDevice::GetDlEarfcn () const +{ + return m_dlEarfcn; +} + +void +LteEnbNetDevice::SetDlEarfcn (uint16_t earfcn) +{ + m_dlEarfcn = earfcn; +} + +uint16_t +LteEnbNetDevice::GetUlEarfcn () const +{ + return m_ulEarfcn; +} + +void +LteEnbNetDevice::SetUlEarfcn (uint16_t earfcn) +{ + m_ulEarfcn = earfcn; +} + + void LteEnbNetDevice::DoStart (void) { m_cellId = ++m_cellIdCounter; - UpdateConfig (); + UpdateConfig (); + m_phy->Start (); + m_mac->Start (); + m_rrc->Start (); } @@ -274,8 +314,10 @@ LteEnbNetDevice::UpdateConfig (void) m_rrc->ConfigureCell (m_ulBandwidth, m_dlBandwidth); - // WILD HACK - should use the PHY SAP instead. Probably should handle this through the RRC + // Configuring directly for now, but ideally we should use the PHY + // SAP instead. Probably should handle this through the RRC. m_phy->DoSetBandwidth (m_ulBandwidth, m_dlBandwidth); + m_phy->DoSetEarfcn (m_dlEarfcn, m_ulEarfcn); m_phy->DoSetCellId (m_cellId); } diff --git a/src/lte/model/lte-enb-net-device.h b/src/lte/model/lte-enb-net-device.h index 684fc5199..33774ff88 100644 --- a/src/lte/model/lte-enb-net-device.h +++ b/src/lte/model/lte-enb-net-device.h @@ -105,6 +105,26 @@ public: */ void SetDlBandwidth (uint8_t bw); + /** + * \return the downlink carrier frequency (EARFCN) + */ + uint16_t GetDlEarfcn () const; + + /** + * \param bw the downlink carrier frequency (EARFCN) + */ + void SetDlEarfcn (uint16_t earfcn); + + /** + * \return the uplink carrier frequency (EARFCN) + */ + uint16_t GetUlEarfcn () const; + + /** + * \param bw the uplink carrier frequency (EARFCN) + */ + void SetUlEarfcn (uint16_t earfcn); + protected: @@ -144,6 +164,9 @@ private: uint8_t m_dlBandwidth; /**< downlink bandwidth in RBs */ uint8_t m_ulBandwidth; /**< uplink bandwidth in RBs */ + + uint16_t m_dlEarfcn; /**< downlink carrier frequency */ + uint16_t m_ulEarfcn; /**< uplink carrier frequency */ }; diff --git a/src/lte/model/lte-enb-phy.cc b/src/lte/model/lte-enb-phy.cc index 9707fefc4..929eea7ef 100644 --- a/src/lte/model/lte-enb-phy.cc +++ b/src/lte/model/lte-enb-phy.cc @@ -158,6 +158,16 @@ LteEnbPhy::DoDispose () LtePhy::DoDispose (); } +void +LteEnbPhy::DoStart () +{ + NS_LOG_FUNCTION (this); + Ptr noisePsd = LteSpectrumValueHelper::CreateNoisePowerSpectralDensity (m_ulEarfcn, m_ulBandwidth, m_noiseFigure); + m_uplinkSpectrumPhy->SetNoisePowerSpectralDensity (noisePsd); + LtePhy::DoStart (); +} + + void LteEnbPhy::SetLteEnbPhySapUser (LteEnbPhySapUser* s) { @@ -189,8 +199,6 @@ LteEnbPhy::SetNoiseFigure (double nf) { NS_LOG_FUNCTION (this << nf); m_noiseFigure = nf; - Ptr noisePsd = LteSpectrumValueHelper::CreateUplinkNoisePowerSpectralDensity (m_noiseFigure); - m_uplinkSpectrumPhy->SetNoisePowerSpectralDensity (noisePsd); } double @@ -268,8 +276,7 @@ LteEnbPhy::CreateTxPowerSpectralDensity () { NS_LOG_FUNCTION (this); - LteSpectrumValueHelper psdHelper; - Ptr psd = psdHelper.CreateDownlinkTxPowerSpectralDensity (GetTxPower (), GetDownlinkSubChannels ()); + Ptr psd = LteSpectrumValueHelper::CreateTxPowerSpectralDensity (m_dlEarfcn, m_dlBandwidth, m_txPower, GetDownlinkSubChannels ()); return psd; } diff --git a/src/lte/model/lte-enb-phy.h b/src/lte/model/lte-enb-phy.h index 8b0f1af70..e83be1e22 100644 --- a/src/lte/model/lte-enb-phy.h +++ b/src/lte/model/lte-enb-phy.h @@ -57,7 +57,9 @@ public: virtual ~LteEnbPhy (); + // inherited from Object static TypeId GetTypeId (void); + virtual void DoStart (void); virtual void DoDispose (void); diff --git a/src/lte/model/lte-phy.cc b/src/lte/model/lte-phy.cc index de3952e91..25d18cb5b 100644 --- a/src/lte/model/lte-phy.cc +++ b/src/lte/model/lte-phy.cc @@ -207,6 +207,12 @@ LtePhy::DoSetBandwidth (uint8_t ulBandwidth, uint8_t dlBandwidth) } } +void +LtePhy::DoSetEarfcn (uint16_t dlEarfcn, uint16_t ulEarfcn) +{ + m_dlEarfcn = dlEarfcn; + m_ulEarfcn = ulEarfcn; +} uint8_t LtePhy::GetRbgSize (void) const diff --git a/src/lte/model/lte-phy.h b/src/lte/model/lte-phy.h index 9b3f1dc81..184070e99 100644 --- a/src/lte/model/lte-phy.h +++ b/src/lte/model/lte-phy.h @@ -159,6 +159,13 @@ public: */ void DoSetBandwidth (uint8_t ulBandwidth, uint8_t dlBandwidth); + /** + * + * \param dlEarfcn the carrier frequency (EARFCN) in downlink + * \param ulEarfcn the carrier frequency (EARFCN) in downlink + */ + virtual void DoSetEarfcn (uint16_t dlEarfcn, uint16_t ulEarfcn); + /** * * \param cellId the Cell Identifier @@ -227,6 +234,9 @@ protected: uint8_t m_ulBandwidth; uint8_t m_dlBandwidth; uint8_t m_rbgSize; + + uint16_t m_dlEarfcn; + uint16_t m_ulEarfcn; std::vector< Ptr > m_packetBurstQueue; std::vector< std::list > > m_controlMessagesQueue; diff --git a/src/lte/model/lte-spectrum-value-helper.cc b/src/lte/model/lte-spectrum-value-helper.cc index 83fbb9df3..8d834c3bb 100644 --- a/src/lte/model/lte-spectrum-value-helper.cc +++ b/src/lte/model/lte-spectrum-value-helper.cc @@ -19,10 +19,10 @@ * Nicola Baldo */ - -#include +#include #include +#include #include "lte-spectrum-value-helper.h" NS_LOG_COMPONENT_DEFINE ("LteSpectrumValueHelper"); @@ -103,7 +103,7 @@ LteSpectrumValueHelper::GetDownlinkCarrierFrequency (uint16_t nDl) (g_eutraChannelNumbers[i].rangeNdl2 >= nDl)) { NS_LOG_LOGIC ("entry " << i << " fDlLow=" << g_eutraChannelNumbers[i].fDlLow); - return g_eutraChannelNumbers[i].fDlLow + 0.1 * (nDl - g_eutraChannelNumbers[i].nOffsDl); + return 1.0e6 * (g_eutraChannelNumbers[i].fDlLow + 0.1 * (nDl - g_eutraChannelNumbers[i].nOffsDl)); } } NS_LOG_ERROR ("invalid EARFCN " << nDl); @@ -120,134 +120,149 @@ LteSpectrumValueHelper::GetUplinkCarrierFrequency (uint16_t nUl) (g_eutraChannelNumbers[i].rangeNul2 >= nUl)) { NS_LOG_LOGIC ("entry " << i << " fUlLow=" << g_eutraChannelNumbers[i].fUlLow); - return g_eutraChannelNumbers[i].fUlLow + 0.1 * (nUl - g_eutraChannelNumbers[i].nOffsUl); + return 1.0e6 * (g_eutraChannelNumbers[i].fUlLow + 0.1 * (nUl - g_eutraChannelNumbers[i].nOffsUl)); } } NS_LOG_ERROR ("invalid EARFCN " << nUl); return 0.0; } - - -Ptr LteDownlinkSpectrumModel; -Ptr LteUplinkSpectrumModel; - -class static_LteDownlinkSpectrumModel_initializer +double +LteSpectrumValueHelper::GetChannelBandwidth (uint8_t transmissionBandwidth) { -public: - static_LteDownlinkSpectrumModel_initializer () - { - - /* - * Operating Bands for the UL: 1920 MHz – 1980 MHz - * see for details TR.36.101 - Tab 5.5-1 - * - */ - - std::vector freqs; - /* WILD HACK - * banwidth 25 - */ - for (int i = 0; i < 25; ++i) - { - - double centralFrequencyOfPRB = 1.920 + (i * 0.00018); - freqs.push_back (centralFrequencyOfPRB * 1e9); - } - - LteDownlinkSpectrumModel = Create (freqs); - } - -} static_LteDownlinkSpectrumModel_initializer_instance; + NS_LOG_FUNCTION ((uint16_t) transmissionBandwidth); + switch (transmissionBandwidth) + { + case 6: + return 1.4e6; + case 15: + return 3.0e6; + case 25: + return 5.0e6; + case 50: + return 10.0e6; + case 75: + return 15.0e6; + case 100: + return 20.0e6; + default: + NS_FATAL_ERROR ("invalid bandwidth value " << (uint16_t) transmissionBandwidth); + } +} -class static_LteUplinkSpectrumModel_initializer + +struct LteSpectrumModelId { -public: - static_LteUplinkSpectrumModel_initializer () - { + LteSpectrumModelId (uint16_t f, uint8_t b); + uint16_t earfcn; + uint8_t bandwidth; +}; - /* - * Operating Bands for the DL: 2110 MHz – 2170 MHz - * see for details TR.36.101 - Tab 5.5-1 - * - */ - - std::vector freqs; - /* WILD HACK - * banwidth 25 - */ - for (int i = 0; i < 25; ++i) - { - - double centralFrequencyOfPRB = 2.110 + (i * 0.00018); - freqs.push_back (centralFrequencyOfPRB * 1e9); - } - - LteUplinkSpectrumModel = Create (freqs); - } - -} static_LteUplinkSpectrumModel_initializer_instance; - - - - -Ptr -LteSpectrumValueHelper::CreateDownlinkTxPowerSpectralDensity (double powerTx, std::vector channels) +LteSpectrumModelId::LteSpectrumModelId (uint16_t f, uint8_t b) + : earfcn (f), + bandwidth (b) { - Ptr txPsd = Create (LteDownlinkSpectrumModel); +} + +bool +operator < (const LteSpectrumModelId& a, const LteSpectrumModelId& b) +{ + return ( (a.earfcn < b.earfcn) || ( (a.earfcn == b.earfcn) && (a.bandwidth < b.bandwidth) ) ); +} + + +static std::map > g_lteSpectrumModelMap; + + +Ptr +LteSpectrumValueHelper::GetSpectrumModel (uint16_t earfcn, uint8_t txBandwidthConfiguration) +{ + NS_LOG_FUNCTION (earfcn << (uint16_t) txBandwidthConfiguration); + Ptr ret; + LteSpectrumModelId key (earfcn, txBandwidthConfiguration); + std::map >::iterator it = g_lteSpectrumModelMap.find (key); + if (it != g_lteSpectrumModelMap.end ()) + { + ret = it->second; + } + else + { + double fc = GetCarrierFrequency (earfcn); + NS_ASSERT_MSG (fc != 0, "invalid EARFCN=" << earfcn); + + double f = fc - (txBandwidthConfiguration * 180e3 / 2.0); + Bands rbs; + for (uint8_t numrb = 0; numrb < txBandwidthConfiguration; ++numrb) + { + BandInfo rb; + rb.fl = f; + f += 90e3; + rb.fc = f; + f += 90e3; + rb.fh = f; + rbs.push_back (rb); + } + ret = Create (rbs); + g_lteSpectrumModelMap.insert (std::pair > (key, ret)); + } + NS_LOG_LOGIC ("returning SpectrumModel::GetUid () == " << ret->GetUid ()); + return ret; +} + +// just needed to log a std::vector properly... +std::ostream& +operator << (std::ostream& os, const std::vector& v) +{ + std::vector::const_iterator it = v.begin (); + while (it != v.end ()) + { + os << *it << " " ; + ++it; + } + os << std::endl; + return os; +} + + +Ptr +LteSpectrumValueHelper::CreateTxPowerSpectralDensity (uint16_t earfcn, uint8_t txBandwidthConfiguration, double powerTx, std::vector activeRbs) +{ + NS_LOG_FUNCTION (earfcn << (uint16_t) txBandwidthConfiguration << powerTx << activeRbs); + + Ptr model = GetSpectrumModel (earfcn, txBandwidthConfiguration); + Ptr txPsd = Create (model); // powerTx is expressed in dBm. We must convert it into natural unit. - powerTx = pow (10., (powerTx - 30) / 10); + double powerTxW = pow (10., (powerTx - 30) / 10); - double txPowerDensity = (powerTx / channels.size ()) / 180000; + double txPowerDensity = (powerTxW / GetChannelBandwidth (txBandwidthConfiguration)); - for (std::vector ::iterator it = channels.begin (); it != channels.end (); it++) + for (std::vector ::iterator it = activeRbs.begin (); it != activeRbs.end (); it++) { - int idSubChannel = (*it); - (*txPsd)[idSubChannel] = txPowerDensity; + int rbId = (*it); + (*txPsd)[rbId] = txPowerDensity; } + NS_LOG_LOGIC (*txPsd); + return txPsd; } Ptr -LteSpectrumValueHelper::CreateUplinkTxPowerSpectralDensity (double powerTx, std::vector channels) +LteSpectrumValueHelper::CreateNoisePowerSpectralDensity (uint16_t earfcn, uint8_t txBandwidthConfiguration, double noiseFigure) { - Ptr txPsd = Create (LteUplinkSpectrumModel); - - // powerTx is expressed in dBm. We must convert it into natural unit. - powerTx = pow (10., (powerTx - 30) / 10); - - double txPowerDensity = (powerTx / channels.size ()) / 180000; - - for (std::vector ::iterator it = channels.begin (); it != channels.end (); it++) - { - int idSubChannel = (*it); - (*txPsd)[idSubChannel] = txPowerDensity; - } - - return txPsd; -} - - -Ptr -LteSpectrumValueHelper::CreateDownlinkNoisePowerSpectralDensity (double noiseFigure) -{ - return CreateNoisePowerSpectralDensity (noiseFigure, LteDownlinkSpectrumModel); -} - -Ptr -LteSpectrumValueHelper::CreateUplinkNoisePowerSpectralDensity (double noiseFigure) -{ - return CreateNoisePowerSpectralDensity (noiseFigure, LteUplinkSpectrumModel); + NS_LOG_FUNCTION (earfcn << (uint16_t) txBandwidthConfiguration << noiseFigure); + Ptr model = GetSpectrumModel (earfcn, txBandwidthConfiguration); + return CreateNoisePowerSpectralDensity (noiseFigure, model); } Ptr LteSpectrumValueHelper::CreateNoisePowerSpectralDensity (double noiseFigureDb, Ptr spectrumModel) { + NS_LOG_FUNCTION (noiseFigureDb << spectrumModel); double noiseFigureLinear = pow (10.0, noiseFigureDb / 10.0); static const double BOLTZMANN = 1.3803e-23; static const double ROOM_TEMPERATURE = 290.0; diff --git a/src/lte/model/lte-spectrum-value-helper.h b/src/lte/model/lte-spectrum-value-helper.h index 9083dc923..70ce046a9 100644 --- a/src/lte/model/lte-spectrum-value-helper.h +++ b/src/lte/model/lte-spectrum-value-helper.h @@ -43,7 +43,7 @@ public: * * \param earfcn the EARFCN * - * \return the carrier frequency in MHz + * \return the carrier frequency in Hz */ static double GetCarrierFrequency (uint16_t earfcn); @@ -54,7 +54,7 @@ public: * * \param earfcn the EARFCN * - * \return the dowlink carrier frequency in MHz + * \return the dowlink carrier frequency in Hz */ static double GetDownlinkCarrierFrequency (uint16_t earfcn); @@ -65,44 +65,63 @@ public: * * \param earfcn the EARFCN * - * \return the uplink carrier frequency in MHz + * \return the uplink carrier frequency in Hz */ static double GetUplinkCarrierFrequency (uint16_t earfcn); - /** - * \brief create spectrum value - * \param powerTx the power transmission in dBm - * \param channels the list of sub channels where the signal will be sent - * \return a Ptr to a newly created SpectrumValue instance + /** + * + * + * \param txBandwidthConf the tranmission bandwidth + * configuration in number of resource blocks + * + * \return the nominal channel bandwidth in Hz as per 3GPP TS 36.101 */ - static Ptr CreateDownlinkTxPowerSpectralDensity (double powerTx, std::vector channels); + static double GetChannelBandwidth (uint8_t txBandwidthConf); + + /** + * + * \param earfcn the carrier frequency (EARFCN) at which reception + * is made + * \param bandwidth the Transmission Bandwidth Configuration in + * number of resource blocks + * + * \return the static SpectrumModel instance corresponding to the + * given carrier frequency and transmission bandwidth + * configuration. If such SpectrumModel does not exist, it is + * created. + */ + static Ptr GetSpectrumModel (uint16_t earfcn, uint8_t bandwdith); + /** - * \brief create spectrum value - * \param powerTx the power transmission in dBm - * \param channels the list of sub channels where the signal will be sent + * create a spectrum value representing the power spectral + * density of a signal to be transmitted. See 3GPP TS 36.101 for + * a definition of most of the parameters described here. + * + * \param earfcn the carrier frequency (EARFCN) of the transmission + * \param bandwidth the Transmission Bandwidth Configuration in + * number of resource blocks + * \param txPower the total power in dBm over the whole bandwidth + * \param ActiveRbs the list of Active Resource Blocks (PRBs) + * * \return a Ptr to a newly created SpectrumValue instance */ - static Ptr CreateUplinkTxPowerSpectralDensity (double powerTx, std::vector channels); + static Ptr CreateTxPowerSpectralDensity (uint16_t earfcn, uint8_t bandwdith, double powerTx, std::vector activeRbs); /** * create a SpectrumValue that models the power spectral density of AWGN * + * \param earfcn the carrier frequency (EARFCN) at which reception + * is made + * \param bandwidth the Transmission Bandwidth Configuration in + * number of resource blocks * \param noiseFigure the noise figure in dB w.r.t. a reference temperature of 290K * * \return a Ptr to a newly created SpectrumValue instance */ - static Ptr CreateDownlinkNoisePowerSpectralDensity (double noiseFigure); - - /** - * create a SpectrumValue that models the power spectral density of AWGN - * - * \param noiseFigure the noise figure in dB w.r.t. a reference temperature of 290K - * - * \return a Ptr to a newly created SpectrumValue instance - */ - static Ptr CreateUplinkNoisePowerSpectralDensity (double noiseFigure); + static Ptr CreateNoisePowerSpectralDensity (uint16_t earfcn, uint8_t bandwdith, double noiseFigure); /** * create a SpectrumValue that models the power spectral density of AWGN diff --git a/src/lte/model/lte-ue-net-device.cc b/src/lte/model/lte-ue-net-device.cc index aceaf3c0c..b7fda8daf 100644 --- a/src/lte/model/lte-ue-net-device.cc +++ b/src/lte/model/lte-ue-net-device.cc @@ -144,7 +144,7 @@ LteUeNetDevice::SetTargetEnb (Ptr enb) NS_LOG_FUNCTION (this << enb); m_targetEnb = enb; - // WILD HACK - should go through RRC and then through PHY SAP + // should go through RRC and then through PHY SAP m_phy->DoSetCellId (enb->GetCellId ()); } @@ -168,6 +168,9 @@ LteUeNetDevice::DoStart (void) { UpdateConfig (); m_imsi = ++m_imsiCounter; + m_phy->Start (); + m_mac->Start (); + m_rrc->Start (); } diff --git a/src/lte/model/lte-ue-phy.cc b/src/lte/model/lte-ue-phy.cc index 3c00b1852..45d4b184a 100644 --- a/src/lte/model/lte-ue-phy.cc +++ b/src/lte/model/lte-ue-phy.cc @@ -153,6 +153,14 @@ LteUePhy::GetTypeId (void) return tid; } +void +LteUePhy::DoStart () +{ + NS_LOG_FUNCTION (this); + Ptr noisePsd = LteSpectrumValueHelper::CreateNoisePowerSpectralDensity (m_dlEarfcn, m_dlBandwidth, m_noiseFigure); + m_downlinkSpectrumPhy->SetNoisePowerSpectralDensity (noisePsd); + LtePhy::DoStart (); +} void LteUePhy::SetLteUePhySapUser (LteUePhySapUser* s) @@ -173,8 +181,6 @@ LteUePhy::SetNoiseFigure (double nf) { NS_LOG_FUNCTION (this << nf); m_noiseFigure = nf; - Ptr noisePsd = LteSpectrumValueHelper::CreateDownlinkNoisePowerSpectralDensity (m_noiseFigure); - m_downlinkSpectrumPhy->SetNoisePowerSpectralDensity (noisePsd); } double @@ -267,7 +273,7 @@ LteUePhy::CreateTxPowerSpectralDensity () { NS_LOG_FUNCTION (this); LteSpectrumValueHelper psdHelper; - Ptr psd = psdHelper.CreateUplinkTxPowerSpectralDensity (GetTxPower (), GetSubChannelsForTransmission ()); + Ptr psd = psdHelper.CreateTxPowerSpectralDensity (m_ulEarfcn, m_ulBandwidth, m_txPower, GetSubChannelsForTransmission ()); return psd; } diff --git a/src/lte/model/lte-ue-phy.h b/src/lte/model/lte-ue-phy.h index 376ca45d5..574ed083e 100644 --- a/src/lte/model/lte-ue-phy.h +++ b/src/lte/model/lte-ue-phy.h @@ -63,9 +63,10 @@ public: virtual ~LteUePhy (); - virtual void DoDispose (); + // inherited from Object static TypeId GetTypeId (void); - + virtual void DoStart (void); + virtual void DoDispose (void); /** * \brief Get the PHY SAP provider diff --git a/src/lte/test/lte-test-downlink-sinr.cc b/src/lte/test/lte-test-downlink-sinr.cc index 5fa0fb69f..ead149851 100644 --- a/src/lte/test/lte-test-downlink-sinr.cc +++ b/src/lte/test/lte-test-downlink-sinr.cc @@ -44,12 +44,12 @@ using namespace ns3; LteDownlinkSinrTestSuite::LteDownlinkSinrTestSuite () : TestSuite ("lte-downlink-sinr", SYSTEM) { - LogLevel logLevel = (LogLevel)(LOG_PREFIX_FUNC | LOG_PREFIX_TIME | LOG_LEVEL_ALL); + // LogLevel logLevel = (LogLevel)(LOG_PREFIX_FUNC | LOG_PREFIX_TIME | LOG_LEVEL_ALL); - LogComponentEnable ("LteTestUePhy", logLevel); - LogComponentEnable ("LteDownlinkSinrTest", logLevel); + // LogComponentEnable ("LteTestUePhy", logLevel); + // LogComponentEnable ("LteDownlinkSinrTest", logLevel); - NS_LOG_INFO ("Creating LteDownlinkSinrTestSuite"); + // NS_LOG_INFO ("Creating LteDownlinkSinrTestSuite"); /** * Build Spectrum Model values for the TX signal diff --git a/src/lte/test/lte-test-earfcn.cc b/src/lte/test/lte-test-earfcn.cc index 755afdfc1..857d29abe 100644 --- a/src/lte/test/lte-test-earfcn.cc +++ b/src/lte/test/lte-test-earfcn.cc @@ -122,32 +122,32 @@ public: static LteEarfcnTestSuite g_lteEarfcnTestSuite; LteEarfcnTestSuite::LteEarfcnTestSuite () - : TestSuite ("lte-earfcn", SYSTEM) + : TestSuite ("lte-earfcn", UNIT) { NS_LOG_FUNCTION (this); - AddTestCase (new LteEarfcnDlTestCase ("DL EARFCN=500", 500, 2110+50)); - AddTestCase (new LteEarfcnDlTestCase ("DL EARFCN=1000", 1000, 1930+(100-60))); - AddTestCase (new LteEarfcnDlTestCase ("DL EARFCN=1301", 1301, 1805+(130.1-120))); + AddTestCase (new LteEarfcnDlTestCase ("DL EARFCN=500", 500, 2160e6)); + AddTestCase (new LteEarfcnDlTestCase ("DL EARFCN=1000", 1000, 1970e6)); + AddTestCase (new LteEarfcnDlTestCase ("DL EARFCN=1301", 1301, 1815.1e6)); AddTestCase (new LteEarfcnDlTestCase ("DL EARFCN=7000", 7000, 0.0)); AddTestCase (new LteEarfcnDlTestCase ("DL EARFCN=20000", 20000, 0.0)); AddTestCase (new LteEarfcnDlTestCase ("DL EARFCN=50000", 50000, 0.0)); - AddTestCase (new LteEarfcnUlTestCase ("UL EARFCN=18100", 18100, 1920 + 1810 - 1800)); - AddTestCase (new LteEarfcnUlTestCase ("UL EARFCN=19000", 19000, 1850 + 1900 - 1860)); - AddTestCase (new LteEarfcnUlTestCase ("UL EARFCN=19400", 19400, 1710 + 1940 - 1920)); + AddTestCase (new LteEarfcnUlTestCase ("UL EARFCN=18100", 18100, 1930e6)); + AddTestCase (new LteEarfcnUlTestCase ("UL EARFCN=19000", 19000, 1890e6)); + AddTestCase (new LteEarfcnUlTestCase ("UL EARFCN=19400", 19400, 1730e6)); AddTestCase (new LteEarfcnUlTestCase ("UL EARFCN=10", 10, 0.0)); AddTestCase (new LteEarfcnUlTestCase ("UL EARFCN=1000", 1000, 0.0)); AddTestCase (new LteEarfcnUlTestCase ("UL EARFCN=50000", 50000, 0.0)); - AddTestCase (new LteEarfcnTestCase ("EARFCN=500", 500, 2110+50)); - AddTestCase (new LteEarfcnTestCase ("EARFCN=1000", 1000, 1930+(100-60))); - AddTestCase (new LteEarfcnTestCase ("EARFCN=1301", 1301, 1805+(130.1-120))); + AddTestCase (new LteEarfcnTestCase ("EARFCN=500", 500, 2160e6)); + AddTestCase (new LteEarfcnTestCase ("EARFCN=1000", 1000, 1970e6)); + AddTestCase (new LteEarfcnTestCase ("EARFCN=1301", 1301, 1815.1e6)); AddTestCase (new LteEarfcnTestCase ("EARFCN=8000", 8000, 0.0)); AddTestCase (new LteEarfcnTestCase ("EARFCN=50000", 50000, 0.0)); - AddTestCase (new LteEarfcnTestCase ("EARFCN=18100", 18100, 1920 + 1810 - 1800)); - AddTestCase (new LteEarfcnTestCase ("EARFCN=19000", 19000, 1850 + 1900 - 1860)); - AddTestCase (new LteEarfcnTestCase ("EARFCN=19400", 19400, 1710 + 1940 - 1920)); + AddTestCase (new LteEarfcnTestCase ("EARFCN=18100", 18100, 1930e6)); + AddTestCase (new LteEarfcnTestCase ("EARFCN=19000", 19000, 1890e6)); + AddTestCase (new LteEarfcnTestCase ("EARFCN=19400", 19400, 1730e6)); AddTestCase (new LteEarfcnTestCase ("EARFCN=50000", 50000, 0.0)); } diff --git a/src/lte/test/lte-test-rr-ff-mac-scheduler.cc b/src/lte/test/lte-test-rr-ff-mac-scheduler.cc index a80759bf2..e9ca591f9 100644 --- a/src/lte/test/lte-test-rr-ff-mac-scheduler.cc +++ b/src/lte/test/lte-test-rr-ff-mac-scheduler.cc @@ -144,7 +144,7 @@ LenaRrFfMacSchedulerTestCase::DoRun (void) mm->SetPosition (Vector (m_dist, 0.0, 0.0)); lena->EnableRlcTraces (); - double simulationTime = 0.040; + double simulationTime = 0.010; Simulator::Stop (Seconds (simulationTime)); Ptr rlcStats = lena->GetRlcStats (); diff --git a/src/lte/test/lte-test-spectrum-value-helper.cc b/src/lte/test/lte-test-spectrum-value-helper.cc new file mode 100644 index 000000000..60f940dfb --- /dev/null +++ b/src/lte/test/lte-test-spectrum-value-helper.cc @@ -0,0 +1,1642 @@ +/* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */ +/* + * Copyright (c) 2011 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC) + * + * 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: Nicola Baldo + */ + + + +#include "ns3/test.h" +#include "ns3/log.h" + +#include "ns3/spectrum-test.h" +#include "ns3/lte-spectrum-value-helper.h" + +NS_LOG_COMPONENT_DEFINE ("LteTestSpectrumValueHelper"); + +namespace ns3 { + +class LteSpectrumModelTestCase : public TestCase +{ +public: + LteSpectrumModelTestCase (const char* str, uint16_t earfcn, uint8_t bw, std::vector fcs); + virtual ~LteSpectrumModelTestCase (); + +protected: + Ptr m_actual; + Ptr m_expected; + + private: + virtual void DoRun (void); +}; + +LteSpectrumModelTestCase::LteSpectrumModelTestCase (const char* str, uint16_t earfcn, uint8_t bw, std::vector fcs) + : TestCase (std::string ("SpectrumModel ") + str) +{ + NS_LOG_FUNCTION (this << str << earfcn << bw); + m_actual = LteSpectrumValueHelper::GetSpectrumModel (earfcn, bw); + m_expected = Create (fcs); +} + +LteSpectrumModelTestCase::~LteSpectrumModelTestCase () +{ +} + +void +LteSpectrumModelTestCase::DoRun (void) +{ + NS_LOG_FUNCTION (this); + NS_TEST_ASSERT_MSG_SPECTRUM_MODEL_EQ_TOL ((*m_actual), (*m_expected), 0.0000001, "spectrum model mismatch"); +} + + + + +class LteNoisePsdTestCase : public TestCase +{ +public: + LteNoisePsdTestCase (const char* str, uint16_t earfcn, uint8_t bw, double noiseFigureDb, SpectrumValue& expected); + virtual ~LteNoisePsdTestCase (); + +protected: + Ptr m_actual; + Ptr m_expected; + + private: + virtual void DoRun (void); +}; + +LteNoisePsdTestCase::LteNoisePsdTestCase (const char* str, uint16_t earfcn, uint8_t bw, double noiseFigureDb, SpectrumValue& expected) + : TestCase (str), + m_actual (LteSpectrumValueHelper::CreateNoisePowerSpectralDensity (earfcn, bw, noiseFigureDb)), + m_expected (Create (expected)) +{ + NS_LOG_FUNCTION (this << str << earfcn << bw << noiseFigureDb); +} + +LteNoisePsdTestCase::~LteNoisePsdTestCase () +{ +} + +void +LteNoisePsdTestCase::DoRun (void) +{ + NS_TEST_ASSERT_MSG_EQ (m_actual->GetSpectrumModelUid (), m_expected->GetSpectrumModelUid (), "SpectrumModel UID mismatch"); + NS_TEST_ASSERT_MSG_SPECTRUM_VALUE_EQ_TOL ((*m_actual), (*m_expected), 0.0000001, GetName ()); +} + + + + + +class LteTxPsdTestCase : public TestCase +{ +public: + LteTxPsdTestCase (const char* str, uint16_t earfcn, uint8_t bw, double txPowerDbm, std::vector activeRbs, SpectrumValue& expected); + virtual ~LteTxPsdTestCase (); + +protected: + Ptr m_actual; + Ptr m_expected; + + private: + virtual void DoRun (void); +}; + +LteTxPsdTestCase::LteTxPsdTestCase (const char* str, uint16_t earfcn, uint8_t bw, double txPowerDbm, std::vector activeRbs, SpectrumValue& expected) + : TestCase (str), + m_actual (LteSpectrumValueHelper::CreateTxPowerSpectralDensity (earfcn, bw, txPowerDbm, activeRbs)), + m_expected (Create (expected)) +{ + NS_LOG_FUNCTION (this << str << earfcn << bw << txPowerDbm); +} + +LteTxPsdTestCase::~LteTxPsdTestCase () +{ +} + +void +LteTxPsdTestCase::DoRun (void) +{ + NS_TEST_ASSERT_MSG_EQ (m_actual->GetSpectrumModelUid (), m_expected->GetSpectrumModelUid (), "SpectrumModel UID mismatch"); + NS_TEST_ASSERT_MSG_SPECTRUM_VALUE_EQ_TOL ((*m_actual), (*m_expected), 0.0000001, GetName ()); +} + + + + +class LteSpectrumValueHelperTestSuite : public TestSuite +{ +public: + LteSpectrumValueHelperTestSuite (); +}; + +static LteSpectrumValueHelperTestSuite g_lteSpectrumValueHelperTestSuite; + +LteSpectrumValueHelperTestSuite::LteSpectrumValueHelperTestSuite () + : TestSuite ("lte-spectrum-value-helper", UNIT) +{ + LogLevel logLevel = (LogLevel)(LOG_PREFIX_FUNC | LOG_PREFIX_TIME | LOG_LEVEL_ALL); + LogComponentEnable ("LteSpectrumModelTestCase", logLevel); + LogComponentEnable ("LteSpectrumValueHelperTestSuite", logLevel); + LogComponentEnable ("LteSpectrumValueHelper", logLevel); + + + NS_LOG_INFO ("Creating LteSpectrumValueHelperTestSuite"); + + + + std::vector fc2160nrb6 (6); + fc2160nrb6[0] = 2.159550000000e+09; + fc2160nrb6[1] = 2.159730000000e+09; + fc2160nrb6[2] = 2.159910000000e+09; + fc2160nrb6[3] = 2.160090000000e+09; + fc2160nrb6[4] = 2.160270000000e+09; + fc2160nrb6[5] = 2.160450000000e+09; + AddTestCase (new LteSpectrumModelTestCase ("fc2160nrb6", 500, 6, fc2160nrb6)); + + std::vector fc2160nrb15 (15); + fc2160nrb15[0] = 2.158740000000e+09; + fc2160nrb15[1] = 2.158920000000e+09; + fc2160nrb15[2] = 2.159100000000e+09; + fc2160nrb15[3] = 2.159280000000e+09; + fc2160nrb15[4] = 2.159460000000e+09; + fc2160nrb15[5] = 2.159640000000e+09; + fc2160nrb15[6] = 2.159820000000e+09; + fc2160nrb15[7] = 2.160000000000e+09; + fc2160nrb15[8] = 2.160180000000e+09; + fc2160nrb15[9] = 2.160360000000e+09; + fc2160nrb15[10] = 2.160540000000e+09; + fc2160nrb15[11] = 2.160720000000e+09; + fc2160nrb15[12] = 2.160900000000e+09; + fc2160nrb15[13] = 2.161080000000e+09; + fc2160nrb15[14] = 2.161260000000e+09; + AddTestCase (new LteSpectrumModelTestCase ("fc2160nrb15", 500, 15, fc2160nrb15)); + + std::vector fc2160nrb25 (25); + fc2160nrb25[0] = 2.157840000000e+09; + fc2160nrb25[1] = 2.158020000000e+09; + fc2160nrb25[2] = 2.158200000000e+09; + fc2160nrb25[3] = 2.158380000000e+09; + fc2160nrb25[4] = 2.158560000000e+09; + fc2160nrb25[5] = 2.158740000000e+09; + fc2160nrb25[6] = 2.158920000000e+09; + fc2160nrb25[7] = 2.159100000000e+09; + fc2160nrb25[8] = 2.159280000000e+09; + fc2160nrb25[9] = 2.159460000000e+09; + fc2160nrb25[10] = 2.159640000000e+09; + fc2160nrb25[11] = 2.159820000000e+09; + fc2160nrb25[12] = 2.160000000000e+09; + fc2160nrb25[13] = 2.160180000000e+09; + fc2160nrb25[14] = 2.160360000000e+09; + fc2160nrb25[15] = 2.160540000000e+09; + fc2160nrb25[16] = 2.160720000000e+09; + fc2160nrb25[17] = 2.160900000000e+09; + fc2160nrb25[18] = 2.161080000000e+09; + fc2160nrb25[19] = 2.161260000000e+09; + fc2160nrb25[20] = 2.161440000000e+09; + fc2160nrb25[21] = 2.161620000000e+09; + fc2160nrb25[22] = 2.161800000000e+09; + fc2160nrb25[23] = 2.161980000000e+09; + fc2160nrb25[24] = 2.162160000000e+09; + AddTestCase (new LteSpectrumModelTestCase ("fc2160nrb25", 500, 25, fc2160nrb25)); + + std::vector fc2160nrb50 (50); + fc2160nrb50[0] = 2.155590000000e+09; + fc2160nrb50[1] = 2.155770000000e+09; + fc2160nrb50[2] = 2.155950000000e+09; + fc2160nrb50[3] = 2.156130000000e+09; + fc2160nrb50[4] = 2.156310000000e+09; + fc2160nrb50[5] = 2.156490000000e+09; + fc2160nrb50[6] = 2.156670000000e+09; + fc2160nrb50[7] = 2.156850000000e+09; + fc2160nrb50[8] = 2.157030000000e+09; + fc2160nrb50[9] = 2.157210000000e+09; + fc2160nrb50[10] = 2.157390000000e+09; + fc2160nrb50[11] = 2.157570000000e+09; + fc2160nrb50[12] = 2.157750000000e+09; + fc2160nrb50[13] = 2.157930000000e+09; + fc2160nrb50[14] = 2.158110000000e+09; + fc2160nrb50[15] = 2.158290000000e+09; + fc2160nrb50[16] = 2.158470000000e+09; + fc2160nrb50[17] = 2.158650000000e+09; + fc2160nrb50[18] = 2.158830000000e+09; + fc2160nrb50[19] = 2.159010000000e+09; + fc2160nrb50[20] = 2.159190000000e+09; + fc2160nrb50[21] = 2.159370000000e+09; + fc2160nrb50[22] = 2.159550000000e+09; + fc2160nrb50[23] = 2.159730000000e+09; + fc2160nrb50[24] = 2.159910000000e+09; + fc2160nrb50[25] = 2.160090000000e+09; + fc2160nrb50[26] = 2.160270000000e+09; + fc2160nrb50[27] = 2.160450000000e+09; + fc2160nrb50[28] = 2.160630000000e+09; + fc2160nrb50[29] = 2.160810000000e+09; + fc2160nrb50[30] = 2.160990000000e+09; + fc2160nrb50[31] = 2.161170000000e+09; + fc2160nrb50[32] = 2.161350000000e+09; + fc2160nrb50[33] = 2.161530000000e+09; + fc2160nrb50[34] = 2.161710000000e+09; + fc2160nrb50[35] = 2.161890000000e+09; + fc2160nrb50[36] = 2.162070000000e+09; + fc2160nrb50[37] = 2.162250000000e+09; + fc2160nrb50[38] = 2.162430000000e+09; + fc2160nrb50[39] = 2.162610000000e+09; + fc2160nrb50[40] = 2.162790000000e+09; + fc2160nrb50[41] = 2.162970000000e+09; + fc2160nrb50[42] = 2.163150000000e+09; + fc2160nrb50[43] = 2.163330000000e+09; + fc2160nrb50[44] = 2.163510000000e+09; + fc2160nrb50[45] = 2.163690000000e+09; + fc2160nrb50[46] = 2.163870000000e+09; + fc2160nrb50[47] = 2.164050000000e+09; + fc2160nrb50[48] = 2.164230000000e+09; + fc2160nrb50[49] = 2.164410000000e+09; + AddTestCase (new LteSpectrumModelTestCase ("fc2160nrb50", 500, 50, fc2160nrb50)); + + std::vector fc2160nrb75 (75); + fc2160nrb75[0] = 2.153340000000e+09; + fc2160nrb75[1] = 2.153520000000e+09; + fc2160nrb75[2] = 2.153700000000e+09; + fc2160nrb75[3] = 2.153880000000e+09; + fc2160nrb75[4] = 2.154060000000e+09; + fc2160nrb75[5] = 2.154240000000e+09; + fc2160nrb75[6] = 2.154420000000e+09; + fc2160nrb75[7] = 2.154600000000e+09; + fc2160nrb75[8] = 2.154780000000e+09; + fc2160nrb75[9] = 2.154960000000e+09; + fc2160nrb75[10] = 2.155140000000e+09; + fc2160nrb75[11] = 2.155320000000e+09; + fc2160nrb75[12] = 2.155500000000e+09; + fc2160nrb75[13] = 2.155680000000e+09; + fc2160nrb75[14] = 2.155860000000e+09; + fc2160nrb75[15] = 2.156040000000e+09; + fc2160nrb75[16] = 2.156220000000e+09; + fc2160nrb75[17] = 2.156400000000e+09; + fc2160nrb75[18] = 2.156580000000e+09; + fc2160nrb75[19] = 2.156760000000e+09; + fc2160nrb75[20] = 2.156940000000e+09; + fc2160nrb75[21] = 2.157120000000e+09; + fc2160nrb75[22] = 2.157300000000e+09; + fc2160nrb75[23] = 2.157480000000e+09; + fc2160nrb75[24] = 2.157660000000e+09; + fc2160nrb75[25] = 2.157840000000e+09; + fc2160nrb75[26] = 2.158020000000e+09; + fc2160nrb75[27] = 2.158200000000e+09; + fc2160nrb75[28] = 2.158380000000e+09; + fc2160nrb75[29] = 2.158560000000e+09; + fc2160nrb75[30] = 2.158740000000e+09; + fc2160nrb75[31] = 2.158920000000e+09; + fc2160nrb75[32] = 2.159100000000e+09; + fc2160nrb75[33] = 2.159280000000e+09; + fc2160nrb75[34] = 2.159460000000e+09; + fc2160nrb75[35] = 2.159640000000e+09; + fc2160nrb75[36] = 2.159820000000e+09; + fc2160nrb75[37] = 2.160000000000e+09; + fc2160nrb75[38] = 2.160180000000e+09; + fc2160nrb75[39] = 2.160360000000e+09; + fc2160nrb75[40] = 2.160540000000e+09; + fc2160nrb75[41] = 2.160720000000e+09; + fc2160nrb75[42] = 2.160900000000e+09; + fc2160nrb75[43] = 2.161080000000e+09; + fc2160nrb75[44] = 2.161260000000e+09; + fc2160nrb75[45] = 2.161440000000e+09; + fc2160nrb75[46] = 2.161620000000e+09; + fc2160nrb75[47] = 2.161800000000e+09; + fc2160nrb75[48] = 2.161980000000e+09; + fc2160nrb75[49] = 2.162160000000e+09; + fc2160nrb75[50] = 2.162340000000e+09; + fc2160nrb75[51] = 2.162520000000e+09; + fc2160nrb75[52] = 2.162700000000e+09; + fc2160nrb75[53] = 2.162880000000e+09; + fc2160nrb75[54] = 2.163060000000e+09; + fc2160nrb75[55] = 2.163240000000e+09; + fc2160nrb75[56] = 2.163420000000e+09; + fc2160nrb75[57] = 2.163600000000e+09; + fc2160nrb75[58] = 2.163780000000e+09; + fc2160nrb75[59] = 2.163960000000e+09; + fc2160nrb75[60] = 2.164140000000e+09; + fc2160nrb75[61] = 2.164320000000e+09; + fc2160nrb75[62] = 2.164500000000e+09; + fc2160nrb75[63] = 2.164680000000e+09; + fc2160nrb75[64] = 2.164860000000e+09; + fc2160nrb75[65] = 2.165040000000e+09; + fc2160nrb75[66] = 2.165220000000e+09; + fc2160nrb75[67] = 2.165400000000e+09; + fc2160nrb75[68] = 2.165580000000e+09; + fc2160nrb75[69] = 2.165760000000e+09; + fc2160nrb75[70] = 2.165940000000e+09; + fc2160nrb75[71] = 2.166120000000e+09; + fc2160nrb75[72] = 2.166300000000e+09; + fc2160nrb75[73] = 2.166480000000e+09; + fc2160nrb75[74] = 2.166660000000e+09; + AddTestCase (new LteSpectrumModelTestCase ("fc2160nrb75", 500, 75, fc2160nrb75)); + + std::vector fc2160nrb100 (100); + fc2160nrb100[0] = 2.151090000000e+09; + fc2160nrb100[1] = 2.151270000000e+09; + fc2160nrb100[2] = 2.151450000000e+09; + fc2160nrb100[3] = 2.151630000000e+09; + fc2160nrb100[4] = 2.151810000000e+09; + fc2160nrb100[5] = 2.151990000000e+09; + fc2160nrb100[6] = 2.152170000000e+09; + fc2160nrb100[7] = 2.152350000000e+09; + fc2160nrb100[8] = 2.152530000000e+09; + fc2160nrb100[9] = 2.152710000000e+09; + fc2160nrb100[10] = 2.152890000000e+09; + fc2160nrb100[11] = 2.153070000000e+09; + fc2160nrb100[12] = 2.153250000000e+09; + fc2160nrb100[13] = 2.153430000000e+09; + fc2160nrb100[14] = 2.153610000000e+09; + fc2160nrb100[15] = 2.153790000000e+09; + fc2160nrb100[16] = 2.153970000000e+09; + fc2160nrb100[17] = 2.154150000000e+09; + fc2160nrb100[18] = 2.154330000000e+09; + fc2160nrb100[19] = 2.154510000000e+09; + fc2160nrb100[20] = 2.154690000000e+09; + fc2160nrb100[21] = 2.154870000000e+09; + fc2160nrb100[22] = 2.155050000000e+09; + fc2160nrb100[23] = 2.155230000000e+09; + fc2160nrb100[24] = 2.155410000000e+09; + fc2160nrb100[25] = 2.155590000000e+09; + fc2160nrb100[26] = 2.155770000000e+09; + fc2160nrb100[27] = 2.155950000000e+09; + fc2160nrb100[28] = 2.156130000000e+09; + fc2160nrb100[29] = 2.156310000000e+09; + fc2160nrb100[30] = 2.156490000000e+09; + fc2160nrb100[31] = 2.156670000000e+09; + fc2160nrb100[32] = 2.156850000000e+09; + fc2160nrb100[33] = 2.157030000000e+09; + fc2160nrb100[34] = 2.157210000000e+09; + fc2160nrb100[35] = 2.157390000000e+09; + fc2160nrb100[36] = 2.157570000000e+09; + fc2160nrb100[37] = 2.157750000000e+09; + fc2160nrb100[38] = 2.157930000000e+09; + fc2160nrb100[39] = 2.158110000000e+09; + fc2160nrb100[40] = 2.158290000000e+09; + fc2160nrb100[41] = 2.158470000000e+09; + fc2160nrb100[42] = 2.158650000000e+09; + fc2160nrb100[43] = 2.158830000000e+09; + fc2160nrb100[44] = 2.159010000000e+09; + fc2160nrb100[45] = 2.159190000000e+09; + fc2160nrb100[46] = 2.159370000000e+09; + fc2160nrb100[47] = 2.159550000000e+09; + fc2160nrb100[48] = 2.159730000000e+09; + fc2160nrb100[49] = 2.159910000000e+09; + fc2160nrb100[50] = 2.160090000000e+09; + fc2160nrb100[51] = 2.160270000000e+09; + fc2160nrb100[52] = 2.160450000000e+09; + fc2160nrb100[53] = 2.160630000000e+09; + fc2160nrb100[54] = 2.160810000000e+09; + fc2160nrb100[55] = 2.160990000000e+09; + fc2160nrb100[56] = 2.161170000000e+09; + fc2160nrb100[57] = 2.161350000000e+09; + fc2160nrb100[58] = 2.161530000000e+09; + fc2160nrb100[59] = 2.161710000000e+09; + fc2160nrb100[60] = 2.161890000000e+09; + fc2160nrb100[61] = 2.162070000000e+09; + fc2160nrb100[62] = 2.162250000000e+09; + fc2160nrb100[63] = 2.162430000000e+09; + fc2160nrb100[64] = 2.162610000000e+09; + fc2160nrb100[65] = 2.162790000000e+09; + fc2160nrb100[66] = 2.162970000000e+09; + fc2160nrb100[67] = 2.163150000000e+09; + fc2160nrb100[68] = 2.163330000000e+09; + fc2160nrb100[69] = 2.163510000000e+09; + fc2160nrb100[70] = 2.163690000000e+09; + fc2160nrb100[71] = 2.163870000000e+09; + fc2160nrb100[72] = 2.164050000000e+09; + fc2160nrb100[73] = 2.164230000000e+09; + fc2160nrb100[74] = 2.164410000000e+09; + fc2160nrb100[75] = 2.164590000000e+09; + fc2160nrb100[76] = 2.164770000000e+09; + fc2160nrb100[77] = 2.164950000000e+09; + fc2160nrb100[78] = 2.165130000000e+09; + fc2160nrb100[79] = 2.165310000000e+09; + fc2160nrb100[80] = 2.165490000000e+09; + fc2160nrb100[81] = 2.165670000000e+09; + fc2160nrb100[82] = 2.165850000000e+09; + fc2160nrb100[83] = 2.166030000000e+09; + fc2160nrb100[84] = 2.166210000000e+09; + fc2160nrb100[85] = 2.166390000000e+09; + fc2160nrb100[86] = 2.166570000000e+09; + fc2160nrb100[87] = 2.166750000000e+09; + fc2160nrb100[88] = 2.166930000000e+09; + fc2160nrb100[89] = 2.167110000000e+09; + fc2160nrb100[90] = 2.167290000000e+09; + fc2160nrb100[91] = 2.167470000000e+09; + fc2160nrb100[92] = 2.167650000000e+09; + fc2160nrb100[93] = 2.167830000000e+09; + fc2160nrb100[94] = 2.168010000000e+09; + fc2160nrb100[95] = 2.168190000000e+09; + fc2160nrb100[96] = 2.168370000000e+09; + fc2160nrb100[97] = 2.168550000000e+09; + fc2160nrb100[98] = 2.168730000000e+09; + fc2160nrb100[99] = 2.168910000000e+09; + AddTestCase (new LteSpectrumModelTestCase ("fc2160nrb100", 500, 100, fc2160nrb100)); + + std::vector fc1730nrb6 (6); + fc1730nrb6[0] = 1.729550000000e+09; + fc1730nrb6[1] = 1.729730000000e+09; + fc1730nrb6[2] = 1.729910000000e+09; + fc1730nrb6[3] = 1.730090000000e+09; + fc1730nrb6[4] = 1.730270000000e+09; + fc1730nrb6[5] = 1.730450000000e+09; + AddTestCase (new LteSpectrumModelTestCase ("fc1730nrb6", 19400, 6, fc1730nrb6)); + + std::vector fc1730nrb15 (15); + fc1730nrb15[0] = 1.728740000000e+09; + fc1730nrb15[1] = 1.728920000000e+09; + fc1730nrb15[2] = 1.729100000000e+09; + fc1730nrb15[3] = 1.729280000000e+09; + fc1730nrb15[4] = 1.729460000000e+09; + fc1730nrb15[5] = 1.729640000000e+09; + fc1730nrb15[6] = 1.729820000000e+09; + fc1730nrb15[7] = 1.730000000000e+09; + fc1730nrb15[8] = 1.730180000000e+09; + fc1730nrb15[9] = 1.730360000000e+09; + fc1730nrb15[10] = 1.730540000000e+09; + fc1730nrb15[11] = 1.730720000000e+09; + fc1730nrb15[12] = 1.730900000000e+09; + fc1730nrb15[13] = 1.731080000000e+09; + fc1730nrb15[14] = 1.731260000000e+09; + AddTestCase (new LteSpectrumModelTestCase ("fc1730nrb15", 19400, 15, fc1730nrb15)); + + std::vector fc1730nrb25 (25); + fc1730nrb25[0] = 1.727840000000e+09; + fc1730nrb25[1] = 1.728020000000e+09; + fc1730nrb25[2] = 1.728200000000e+09; + fc1730nrb25[3] = 1.728380000000e+09; + fc1730nrb25[4] = 1.728560000000e+09; + fc1730nrb25[5] = 1.728740000000e+09; + fc1730nrb25[6] = 1.728920000000e+09; + fc1730nrb25[7] = 1.729100000000e+09; + fc1730nrb25[8] = 1.729280000000e+09; + fc1730nrb25[9] = 1.729460000000e+09; + fc1730nrb25[10] = 1.729640000000e+09; + fc1730nrb25[11] = 1.729820000000e+09; + fc1730nrb25[12] = 1.730000000000e+09; + fc1730nrb25[13] = 1.730180000000e+09; + fc1730nrb25[14] = 1.730360000000e+09; + fc1730nrb25[15] = 1.730540000000e+09; + fc1730nrb25[16] = 1.730720000000e+09; + fc1730nrb25[17] = 1.730900000000e+09; + fc1730nrb25[18] = 1.731080000000e+09; + fc1730nrb25[19] = 1.731260000000e+09; + fc1730nrb25[20] = 1.731440000000e+09; + fc1730nrb25[21] = 1.731620000000e+09; + fc1730nrb25[22] = 1.731800000000e+09; + fc1730nrb25[23] = 1.731980000000e+09; + fc1730nrb25[24] = 1.732160000000e+09; + AddTestCase (new LteSpectrumModelTestCase ("fc1730nrb25", 19400, 25, fc1730nrb25)); + + std::vector fc1730nrb50 (50); + fc1730nrb50[0] = 1.725590000000e+09; + fc1730nrb50[1] = 1.725770000000e+09; + fc1730nrb50[2] = 1.725950000000e+09; + fc1730nrb50[3] = 1.726130000000e+09; + fc1730nrb50[4] = 1.726310000000e+09; + fc1730nrb50[5] = 1.726490000000e+09; + fc1730nrb50[6] = 1.726670000000e+09; + fc1730nrb50[7] = 1.726850000000e+09; + fc1730nrb50[8] = 1.727030000000e+09; + fc1730nrb50[9] = 1.727210000000e+09; + fc1730nrb50[10] = 1.727390000000e+09; + fc1730nrb50[11] = 1.727570000000e+09; + fc1730nrb50[12] = 1.727750000000e+09; + fc1730nrb50[13] = 1.727930000000e+09; + fc1730nrb50[14] = 1.728110000000e+09; + fc1730nrb50[15] = 1.728290000000e+09; + fc1730nrb50[16] = 1.728470000000e+09; + fc1730nrb50[17] = 1.728650000000e+09; + fc1730nrb50[18] = 1.728830000000e+09; + fc1730nrb50[19] = 1.729010000000e+09; + fc1730nrb50[20] = 1.729190000000e+09; + fc1730nrb50[21] = 1.729370000000e+09; + fc1730nrb50[22] = 1.729550000000e+09; + fc1730nrb50[23] = 1.729730000000e+09; + fc1730nrb50[24] = 1.729910000000e+09; + fc1730nrb50[25] = 1.730090000000e+09; + fc1730nrb50[26] = 1.730270000000e+09; + fc1730nrb50[27] = 1.730450000000e+09; + fc1730nrb50[28] = 1.730630000000e+09; + fc1730nrb50[29] = 1.730810000000e+09; + fc1730nrb50[30] = 1.730990000000e+09; + fc1730nrb50[31] = 1.731170000000e+09; + fc1730nrb50[32] = 1.731350000000e+09; + fc1730nrb50[33] = 1.731530000000e+09; + fc1730nrb50[34] = 1.731710000000e+09; + fc1730nrb50[35] = 1.731890000000e+09; + fc1730nrb50[36] = 1.732070000000e+09; + fc1730nrb50[37] = 1.732250000000e+09; + fc1730nrb50[38] = 1.732430000000e+09; + fc1730nrb50[39] = 1.732610000000e+09; + fc1730nrb50[40] = 1.732790000000e+09; + fc1730nrb50[41] = 1.732970000000e+09; + fc1730nrb50[42] = 1.733150000000e+09; + fc1730nrb50[43] = 1.733330000000e+09; + fc1730nrb50[44] = 1.733510000000e+09; + fc1730nrb50[45] = 1.733690000000e+09; + fc1730nrb50[46] = 1.733870000000e+09; + fc1730nrb50[47] = 1.734050000000e+09; + fc1730nrb50[48] = 1.734230000000e+09; + fc1730nrb50[49] = 1.734410000000e+09; + AddTestCase (new LteSpectrumModelTestCase ("fc1730nrb50", 19400, 50, fc1730nrb50)); + + std::vector fc1730nrb75 (75); + fc1730nrb75[0] = 1.723340000000e+09; + fc1730nrb75[1] = 1.723520000000e+09; + fc1730nrb75[2] = 1.723700000000e+09; + fc1730nrb75[3] = 1.723880000000e+09; + fc1730nrb75[4] = 1.724060000000e+09; + fc1730nrb75[5] = 1.724240000000e+09; + fc1730nrb75[6] = 1.724420000000e+09; + fc1730nrb75[7] = 1.724600000000e+09; + fc1730nrb75[8] = 1.724780000000e+09; + fc1730nrb75[9] = 1.724960000000e+09; + fc1730nrb75[10] = 1.725140000000e+09; + fc1730nrb75[11] = 1.725320000000e+09; + fc1730nrb75[12] = 1.725500000000e+09; + fc1730nrb75[13] = 1.725680000000e+09; + fc1730nrb75[14] = 1.725860000000e+09; + fc1730nrb75[15] = 1.726040000000e+09; + fc1730nrb75[16] = 1.726220000000e+09; + fc1730nrb75[17] = 1.726400000000e+09; + fc1730nrb75[18] = 1.726580000000e+09; + fc1730nrb75[19] = 1.726760000000e+09; + fc1730nrb75[20] = 1.726940000000e+09; + fc1730nrb75[21] = 1.727120000000e+09; + fc1730nrb75[22] = 1.727300000000e+09; + fc1730nrb75[23] = 1.727480000000e+09; + fc1730nrb75[24] = 1.727660000000e+09; + fc1730nrb75[25] = 1.727840000000e+09; + fc1730nrb75[26] = 1.728020000000e+09; + fc1730nrb75[27] = 1.728200000000e+09; + fc1730nrb75[28] = 1.728380000000e+09; + fc1730nrb75[29] = 1.728560000000e+09; + fc1730nrb75[30] = 1.728740000000e+09; + fc1730nrb75[31] = 1.728920000000e+09; + fc1730nrb75[32] = 1.729100000000e+09; + fc1730nrb75[33] = 1.729280000000e+09; + fc1730nrb75[34] = 1.729460000000e+09; + fc1730nrb75[35] = 1.729640000000e+09; + fc1730nrb75[36] = 1.729820000000e+09; + fc1730nrb75[37] = 1.730000000000e+09; + fc1730nrb75[38] = 1.730180000000e+09; + fc1730nrb75[39] = 1.730360000000e+09; + fc1730nrb75[40] = 1.730540000000e+09; + fc1730nrb75[41] = 1.730720000000e+09; + fc1730nrb75[42] = 1.730900000000e+09; + fc1730nrb75[43] = 1.731080000000e+09; + fc1730nrb75[44] = 1.731260000000e+09; + fc1730nrb75[45] = 1.731440000000e+09; + fc1730nrb75[46] = 1.731620000000e+09; + fc1730nrb75[47] = 1.731800000000e+09; + fc1730nrb75[48] = 1.731980000000e+09; + fc1730nrb75[49] = 1.732160000000e+09; + fc1730nrb75[50] = 1.732340000000e+09; + fc1730nrb75[51] = 1.732520000000e+09; + fc1730nrb75[52] = 1.732700000000e+09; + fc1730nrb75[53] = 1.732880000000e+09; + fc1730nrb75[54] = 1.733060000000e+09; + fc1730nrb75[55] = 1.733240000000e+09; + fc1730nrb75[56] = 1.733420000000e+09; + fc1730nrb75[57] = 1.733600000000e+09; + fc1730nrb75[58] = 1.733780000000e+09; + fc1730nrb75[59] = 1.733960000000e+09; + fc1730nrb75[60] = 1.734140000000e+09; + fc1730nrb75[61] = 1.734320000000e+09; + fc1730nrb75[62] = 1.734500000000e+09; + fc1730nrb75[63] = 1.734680000000e+09; + fc1730nrb75[64] = 1.734860000000e+09; + fc1730nrb75[65] = 1.735040000000e+09; + fc1730nrb75[66] = 1.735220000000e+09; + fc1730nrb75[67] = 1.735400000000e+09; + fc1730nrb75[68] = 1.735580000000e+09; + fc1730nrb75[69] = 1.735760000000e+09; + fc1730nrb75[70] = 1.735940000000e+09; + fc1730nrb75[71] = 1.736120000000e+09; + fc1730nrb75[72] = 1.736300000000e+09; + fc1730nrb75[73] = 1.736480000000e+09; + fc1730nrb75[74] = 1.736660000000e+09; + AddTestCase (new LteSpectrumModelTestCase ("fc1730nrb75", 19400, 75, fc1730nrb75)); + + std::vector fc1730nrb100 (100); + fc1730nrb100[0] = 1.721090000000e+09; + fc1730nrb100[1] = 1.721270000000e+09; + fc1730nrb100[2] = 1.721450000000e+09; + fc1730nrb100[3] = 1.721630000000e+09; + fc1730nrb100[4] = 1.721810000000e+09; + fc1730nrb100[5] = 1.721990000000e+09; + fc1730nrb100[6] = 1.722170000000e+09; + fc1730nrb100[7] = 1.722350000000e+09; + fc1730nrb100[8] = 1.722530000000e+09; + fc1730nrb100[9] = 1.722710000000e+09; + fc1730nrb100[10] = 1.722890000000e+09; + fc1730nrb100[11] = 1.723070000000e+09; + fc1730nrb100[12] = 1.723250000000e+09; + fc1730nrb100[13] = 1.723430000000e+09; + fc1730nrb100[14] = 1.723610000000e+09; + fc1730nrb100[15] = 1.723790000000e+09; + fc1730nrb100[16] = 1.723970000000e+09; + fc1730nrb100[17] = 1.724150000000e+09; + fc1730nrb100[18] = 1.724330000000e+09; + fc1730nrb100[19] = 1.724510000000e+09; + fc1730nrb100[20] = 1.724690000000e+09; + fc1730nrb100[21] = 1.724870000000e+09; + fc1730nrb100[22] = 1.725050000000e+09; + fc1730nrb100[23] = 1.725230000000e+09; + fc1730nrb100[24] = 1.725410000000e+09; + fc1730nrb100[25] = 1.725590000000e+09; + fc1730nrb100[26] = 1.725770000000e+09; + fc1730nrb100[27] = 1.725950000000e+09; + fc1730nrb100[28] = 1.726130000000e+09; + fc1730nrb100[29] = 1.726310000000e+09; + fc1730nrb100[30] = 1.726490000000e+09; + fc1730nrb100[31] = 1.726670000000e+09; + fc1730nrb100[32] = 1.726850000000e+09; + fc1730nrb100[33] = 1.727030000000e+09; + fc1730nrb100[34] = 1.727210000000e+09; + fc1730nrb100[35] = 1.727390000000e+09; + fc1730nrb100[36] = 1.727570000000e+09; + fc1730nrb100[37] = 1.727750000000e+09; + fc1730nrb100[38] = 1.727930000000e+09; + fc1730nrb100[39] = 1.728110000000e+09; + fc1730nrb100[40] = 1.728290000000e+09; + fc1730nrb100[41] = 1.728470000000e+09; + fc1730nrb100[42] = 1.728650000000e+09; + fc1730nrb100[43] = 1.728830000000e+09; + fc1730nrb100[44] = 1.729010000000e+09; + fc1730nrb100[45] = 1.729190000000e+09; + fc1730nrb100[46] = 1.729370000000e+09; + fc1730nrb100[47] = 1.729550000000e+09; + fc1730nrb100[48] = 1.729730000000e+09; + fc1730nrb100[49] = 1.729910000000e+09; + fc1730nrb100[50] = 1.730090000000e+09; + fc1730nrb100[51] = 1.730270000000e+09; + fc1730nrb100[52] = 1.730450000000e+09; + fc1730nrb100[53] = 1.730630000000e+09; + fc1730nrb100[54] = 1.730810000000e+09; + fc1730nrb100[55] = 1.730990000000e+09; + fc1730nrb100[56] = 1.731170000000e+09; + fc1730nrb100[57] = 1.731350000000e+09; + fc1730nrb100[58] = 1.731530000000e+09; + fc1730nrb100[59] = 1.731710000000e+09; + fc1730nrb100[60] = 1.731890000000e+09; + fc1730nrb100[61] = 1.732070000000e+09; + fc1730nrb100[62] = 1.732250000000e+09; + fc1730nrb100[63] = 1.732430000000e+09; + fc1730nrb100[64] = 1.732610000000e+09; + fc1730nrb100[65] = 1.732790000000e+09; + fc1730nrb100[66] = 1.732970000000e+09; + fc1730nrb100[67] = 1.733150000000e+09; + fc1730nrb100[68] = 1.733330000000e+09; + fc1730nrb100[69] = 1.733510000000e+09; + fc1730nrb100[70] = 1.733690000000e+09; + fc1730nrb100[71] = 1.733870000000e+09; + fc1730nrb100[72] = 1.734050000000e+09; + fc1730nrb100[73] = 1.734230000000e+09; + fc1730nrb100[74] = 1.734410000000e+09; + fc1730nrb100[75] = 1.734590000000e+09; + fc1730nrb100[76] = 1.734770000000e+09; + fc1730nrb100[77] = 1.734950000000e+09; + fc1730nrb100[78] = 1.735130000000e+09; + fc1730nrb100[79] = 1.735310000000e+09; + fc1730nrb100[80] = 1.735490000000e+09; + fc1730nrb100[81] = 1.735670000000e+09; + fc1730nrb100[82] = 1.735850000000e+09; + fc1730nrb100[83] = 1.736030000000e+09; + fc1730nrb100[84] = 1.736210000000e+09; + fc1730nrb100[85] = 1.736390000000e+09; + fc1730nrb100[86] = 1.736570000000e+09; + fc1730nrb100[87] = 1.736750000000e+09; + fc1730nrb100[88] = 1.736930000000e+09; + fc1730nrb100[89] = 1.737110000000e+09; + fc1730nrb100[90] = 1.737290000000e+09; + fc1730nrb100[91] = 1.737470000000e+09; + fc1730nrb100[92] = 1.737650000000e+09; + fc1730nrb100[93] = 1.737830000000e+09; + fc1730nrb100[94] = 1.738010000000e+09; + fc1730nrb100[95] = 1.738190000000e+09; + fc1730nrb100[96] = 1.738370000000e+09; + fc1730nrb100[97] = 1.738550000000e+09; + fc1730nrb100[98] = 1.738730000000e+09; + fc1730nrb100[99] = 1.738910000000e+09; + AddTestCase (new LteSpectrumModelTestCase ("fc1730nrb100", 19400, 100, fc1730nrb100)); + + + SpectrumValue nfdB0earfcn500nrb6 (LteSpectrumValueHelper::GetSpectrumModel (500, 6)); + nfdB0earfcn500nrb6[0] = 4.002000000000e-21; + nfdB0earfcn500nrb6[1] = 4.002000000000e-21; + nfdB0earfcn500nrb6[2] = 4.002000000000e-21; + nfdB0earfcn500nrb6[3] = 4.002000000000e-21; + nfdB0earfcn500nrb6[4] = 4.002000000000e-21; + nfdB0earfcn500nrb6[5] = 4.002000000000e-21; + AddTestCase (new LteNoisePsdTestCase ("nfdB0earfcn500nrb6", 500, 6, 0.000000, nfdB0earfcn500nrb6)); + + SpectrumValue nfdB5earfcn500nrb6 (LteSpectrumValueHelper::GetSpectrumModel (500, 6)); + nfdB5earfcn500nrb6[0] = 1.265543519599e-20; + nfdB5earfcn500nrb6[1] = 1.265543519599e-20; + nfdB5earfcn500nrb6[2] = 1.265543519599e-20; + nfdB5earfcn500nrb6[3] = 1.265543519599e-20; + nfdB5earfcn500nrb6[4] = 1.265543519599e-20; + nfdB5earfcn500nrb6[5] = 1.265543519599e-20; + AddTestCase (new LteNoisePsdTestCase ("nfdB5earfcn500nrb6", 500, 6, 5.000000, nfdB5earfcn500nrb6)); + + SpectrumValue nfdB10earfcn500nrb6 (LteSpectrumValueHelper::GetSpectrumModel (500, 6)); + nfdB10earfcn500nrb6[0] = 4.002000000000e-20; + nfdB10earfcn500nrb6[1] = 4.002000000000e-20; + nfdB10earfcn500nrb6[2] = 4.002000000000e-20; + nfdB10earfcn500nrb6[3] = 4.002000000000e-20; + nfdB10earfcn500nrb6[4] = 4.002000000000e-20; + nfdB10earfcn500nrb6[5] = 4.002000000000e-20; + AddTestCase (new LteNoisePsdTestCase ("nfdB10earfcn500nrb6", 500, 6, 10.000000, nfdB10earfcn500nrb6)); + + SpectrumValue nfdB0earfcn500nrb15 (LteSpectrumValueHelper::GetSpectrumModel (500, 15)); + nfdB0earfcn500nrb15[0] = 4.002000000000e-21; + nfdB0earfcn500nrb15[1] = 4.002000000000e-21; + nfdB0earfcn500nrb15[2] = 4.002000000000e-21; + nfdB0earfcn500nrb15[3] = 4.002000000000e-21; + nfdB0earfcn500nrb15[4] = 4.002000000000e-21; + nfdB0earfcn500nrb15[5] = 4.002000000000e-21; + nfdB0earfcn500nrb15[6] = 4.002000000000e-21; + nfdB0earfcn500nrb15[7] = 4.002000000000e-21; + nfdB0earfcn500nrb15[8] = 4.002000000000e-21; + nfdB0earfcn500nrb15[9] = 4.002000000000e-21; + nfdB0earfcn500nrb15[10] = 4.002000000000e-21; + nfdB0earfcn500nrb15[11] = 4.002000000000e-21; + nfdB0earfcn500nrb15[12] = 4.002000000000e-21; + nfdB0earfcn500nrb15[13] = 4.002000000000e-21; + nfdB0earfcn500nrb15[14] = 4.002000000000e-21; + AddTestCase (new LteNoisePsdTestCase ("nfdB0earfcn500nrb15", 500, 15, 0.000000, nfdB0earfcn500nrb15)); + + SpectrumValue nfdB5earfcn500nrb15 (LteSpectrumValueHelper::GetSpectrumModel (500, 15)); + nfdB5earfcn500nrb15[0] = 1.265543519599e-20; + nfdB5earfcn500nrb15[1] = 1.265543519599e-20; + nfdB5earfcn500nrb15[2] = 1.265543519599e-20; + nfdB5earfcn500nrb15[3] = 1.265543519599e-20; + nfdB5earfcn500nrb15[4] = 1.265543519599e-20; + nfdB5earfcn500nrb15[5] = 1.265543519599e-20; + nfdB5earfcn500nrb15[6] = 1.265543519599e-20; + nfdB5earfcn500nrb15[7] = 1.265543519599e-20; + nfdB5earfcn500nrb15[8] = 1.265543519599e-20; + nfdB5earfcn500nrb15[9] = 1.265543519599e-20; + nfdB5earfcn500nrb15[10] = 1.265543519599e-20; + nfdB5earfcn500nrb15[11] = 1.265543519599e-20; + nfdB5earfcn500nrb15[12] = 1.265543519599e-20; + nfdB5earfcn500nrb15[13] = 1.265543519599e-20; + nfdB5earfcn500nrb15[14] = 1.265543519599e-20; + AddTestCase (new LteNoisePsdTestCase ("nfdB5earfcn500nrb15", 500, 15, 5.000000, nfdB5earfcn500nrb15)); + + SpectrumValue nfdB10earfcn500nrb15 (LteSpectrumValueHelper::GetSpectrumModel (500, 15)); + nfdB10earfcn500nrb15[0] = 4.002000000000e-20; + nfdB10earfcn500nrb15[1] = 4.002000000000e-20; + nfdB10earfcn500nrb15[2] = 4.002000000000e-20; + nfdB10earfcn500nrb15[3] = 4.002000000000e-20; + nfdB10earfcn500nrb15[4] = 4.002000000000e-20; + nfdB10earfcn500nrb15[5] = 4.002000000000e-20; + nfdB10earfcn500nrb15[6] = 4.002000000000e-20; + nfdB10earfcn500nrb15[7] = 4.002000000000e-20; + nfdB10earfcn500nrb15[8] = 4.002000000000e-20; + nfdB10earfcn500nrb15[9] = 4.002000000000e-20; + nfdB10earfcn500nrb15[10] = 4.002000000000e-20; + nfdB10earfcn500nrb15[11] = 4.002000000000e-20; + nfdB10earfcn500nrb15[12] = 4.002000000000e-20; + nfdB10earfcn500nrb15[13] = 4.002000000000e-20; + nfdB10earfcn500nrb15[14] = 4.002000000000e-20; + + + + std::vector activeRbs_txpowdB10nrb6run1earfcn500 (2); + activeRbs_txpowdB10nrb6run1earfcn500[0] = 0.000000000000e+00; + activeRbs_txpowdB10nrb6run1earfcn500[1] = 2.000000000000e+00; + SpectrumValue spectrumValue_txpowdB10nrb6run1earfcn500 (LteSpectrumValueHelper::GetSpectrumModel (500, 6)); + spectrumValue_txpowdB10nrb6run1earfcn500[0] = 7.142857142857e-09; + spectrumValue_txpowdB10nrb6run1earfcn500[1] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb6run1earfcn500[2] = 7.142857142857e-09; + spectrumValue_txpowdB10nrb6run1earfcn500[3] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb6run1earfcn500[4] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb6run1earfcn500[5] = 0.000000000000e+00; + AddTestCase (new LteTxPsdTestCase ("txpowdB10nrb6run1earfcn500", 500, 6, 10.000000, activeRbs_txpowdB10nrb6run1earfcn500, spectrumValue_txpowdB10nrb6run1earfcn500)); + + std::vector activeRbs_txpowdB30nrb6run1earfcn500 (3); + activeRbs_txpowdB30nrb6run1earfcn500[0] = 0.000000000000e+00; + activeRbs_txpowdB30nrb6run1earfcn500[1] = 2.000000000000e+00; + activeRbs_txpowdB30nrb6run1earfcn500[2] = 4.000000000000e+00; + SpectrumValue spectrumValue_txpowdB30nrb6run1earfcn500 (LteSpectrumValueHelper::GetSpectrumModel (500, 6)); + spectrumValue_txpowdB30nrb6run1earfcn500[0] = 7.142857142857e-07; + spectrumValue_txpowdB30nrb6run1earfcn500[1] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb6run1earfcn500[2] = 7.142857142857e-07; + spectrumValue_txpowdB30nrb6run1earfcn500[3] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb6run1earfcn500[4] = 7.142857142857e-07; + spectrumValue_txpowdB30nrb6run1earfcn500[5] = 0.000000000000e+00; + AddTestCase (new LteTxPsdTestCase ("txpowdB30nrb6run1earfcn500", 500, 6, 30.000000, activeRbs_txpowdB30nrb6run1earfcn500, spectrumValue_txpowdB30nrb6run1earfcn500)); + + std::vector activeRbs_txpowdB10nrb25run1earfcn500 (12); + activeRbs_txpowdB10nrb25run1earfcn500[0] = 3.000000000000e+00; + activeRbs_txpowdB10nrb25run1earfcn500[1] = 4.000000000000e+00; + activeRbs_txpowdB10nrb25run1earfcn500[2] = 6.000000000000e+00; + activeRbs_txpowdB10nrb25run1earfcn500[3] = 7.000000000000e+00; + activeRbs_txpowdB10nrb25run1earfcn500[4] = 9.000000000000e+00; + activeRbs_txpowdB10nrb25run1earfcn500[5] = 1.000000000000e+01; + activeRbs_txpowdB10nrb25run1earfcn500[6] = 1.200000000000e+01; + activeRbs_txpowdB10nrb25run1earfcn500[7] = 1.600000000000e+01; + activeRbs_txpowdB10nrb25run1earfcn500[8] = 1.700000000000e+01; + activeRbs_txpowdB10nrb25run1earfcn500[9] = 1.900000000000e+01; + activeRbs_txpowdB10nrb25run1earfcn500[10] = 2.000000000000e+01; + activeRbs_txpowdB10nrb25run1earfcn500[11] = 2.100000000000e+01; + SpectrumValue spectrumValue_txpowdB10nrb25run1earfcn500 (LteSpectrumValueHelper::GetSpectrumModel (500, 25)); + spectrumValue_txpowdB10nrb25run1earfcn500[0] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb25run1earfcn500[1] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb25run1earfcn500[2] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb25run1earfcn500[3] = 2.000000000000e-09; + spectrumValue_txpowdB10nrb25run1earfcn500[4] = 2.000000000000e-09; + spectrumValue_txpowdB10nrb25run1earfcn500[5] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb25run1earfcn500[6] = 2.000000000000e-09; + spectrumValue_txpowdB10nrb25run1earfcn500[7] = 2.000000000000e-09; + spectrumValue_txpowdB10nrb25run1earfcn500[8] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb25run1earfcn500[9] = 2.000000000000e-09; + spectrumValue_txpowdB10nrb25run1earfcn500[10] = 2.000000000000e-09; + spectrumValue_txpowdB10nrb25run1earfcn500[11] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb25run1earfcn500[12] = 2.000000000000e-09; + spectrumValue_txpowdB10nrb25run1earfcn500[13] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb25run1earfcn500[14] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb25run1earfcn500[15] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb25run1earfcn500[16] = 2.000000000000e-09; + spectrumValue_txpowdB10nrb25run1earfcn500[17] = 2.000000000000e-09; + spectrumValue_txpowdB10nrb25run1earfcn500[18] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb25run1earfcn500[19] = 2.000000000000e-09; + spectrumValue_txpowdB10nrb25run1earfcn500[20] = 2.000000000000e-09; + spectrumValue_txpowdB10nrb25run1earfcn500[21] = 2.000000000000e-09; + spectrumValue_txpowdB10nrb25run1earfcn500[22] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb25run1earfcn500[23] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb25run1earfcn500[24] = 0.000000000000e+00; + AddTestCase (new LteTxPsdTestCase ("txpowdB10nrb25run1earfcn500", 500, 25, 10.000000, activeRbs_txpowdB10nrb25run1earfcn500, spectrumValue_txpowdB10nrb25run1earfcn500)); + + std::vector activeRbs_txpowdB30nrb25run1earfcn500 (16); + activeRbs_txpowdB30nrb25run1earfcn500[0] = 0.000000000000e+00; + activeRbs_txpowdB30nrb25run1earfcn500[1] = 1.000000000000e+00; + activeRbs_txpowdB30nrb25run1earfcn500[2] = 2.000000000000e+00; + activeRbs_txpowdB30nrb25run1earfcn500[3] = 3.000000000000e+00; + activeRbs_txpowdB30nrb25run1earfcn500[4] = 5.000000000000e+00; + activeRbs_txpowdB30nrb25run1earfcn500[5] = 6.000000000000e+00; + activeRbs_txpowdB30nrb25run1earfcn500[6] = 7.000000000000e+00; + activeRbs_txpowdB30nrb25run1earfcn500[7] = 8.000000000000e+00; + activeRbs_txpowdB30nrb25run1earfcn500[8] = 9.000000000000e+00; + activeRbs_txpowdB30nrb25run1earfcn500[9] = 1.000000000000e+01; + activeRbs_txpowdB30nrb25run1earfcn500[10] = 1.200000000000e+01; + activeRbs_txpowdB30nrb25run1earfcn500[11] = 1.400000000000e+01; + activeRbs_txpowdB30nrb25run1earfcn500[12] = 1.500000000000e+01; + activeRbs_txpowdB30nrb25run1earfcn500[13] = 1.900000000000e+01; + activeRbs_txpowdB30nrb25run1earfcn500[14] = 2.000000000000e+01; + activeRbs_txpowdB30nrb25run1earfcn500[15] = 2.200000000000e+01; + SpectrumValue spectrumValue_txpowdB30nrb25run1earfcn500 (LteSpectrumValueHelper::GetSpectrumModel (500, 25)); + spectrumValue_txpowdB30nrb25run1earfcn500[0] = 2.000000000000e-07; + spectrumValue_txpowdB30nrb25run1earfcn500[1] = 2.000000000000e-07; + spectrumValue_txpowdB30nrb25run1earfcn500[2] = 2.000000000000e-07; + spectrumValue_txpowdB30nrb25run1earfcn500[3] = 2.000000000000e-07; + spectrumValue_txpowdB30nrb25run1earfcn500[4] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb25run1earfcn500[5] = 2.000000000000e-07; + spectrumValue_txpowdB30nrb25run1earfcn500[6] = 2.000000000000e-07; + spectrumValue_txpowdB30nrb25run1earfcn500[7] = 2.000000000000e-07; + spectrumValue_txpowdB30nrb25run1earfcn500[8] = 2.000000000000e-07; + spectrumValue_txpowdB30nrb25run1earfcn500[9] = 2.000000000000e-07; + spectrumValue_txpowdB30nrb25run1earfcn500[10] = 2.000000000000e-07; + spectrumValue_txpowdB30nrb25run1earfcn500[11] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb25run1earfcn500[12] = 2.000000000000e-07; + spectrumValue_txpowdB30nrb25run1earfcn500[13] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb25run1earfcn500[14] = 2.000000000000e-07; + spectrumValue_txpowdB30nrb25run1earfcn500[15] = 2.000000000000e-07; + spectrumValue_txpowdB30nrb25run1earfcn500[16] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb25run1earfcn500[17] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb25run1earfcn500[18] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb25run1earfcn500[19] = 2.000000000000e-07; + spectrumValue_txpowdB30nrb25run1earfcn500[20] = 2.000000000000e-07; + spectrumValue_txpowdB30nrb25run1earfcn500[21] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb25run1earfcn500[22] = 2.000000000000e-07; + spectrumValue_txpowdB30nrb25run1earfcn500[23] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb25run1earfcn500[24] = 0.000000000000e+00; + AddTestCase (new LteTxPsdTestCase ("txpowdB30nrb25run1earfcn500", 500, 25, 30.000000, activeRbs_txpowdB30nrb25run1earfcn500, spectrumValue_txpowdB30nrb25run1earfcn500)); + + std::vector activeRbs_txpowdB10nrb100run1earfcn500 (47); + activeRbs_txpowdB10nrb100run1earfcn500[0] = 0.000000000000e+00; + activeRbs_txpowdB10nrb100run1earfcn500[1] = 2.000000000000e+00; + activeRbs_txpowdB10nrb100run1earfcn500[2] = 3.000000000000e+00; + activeRbs_txpowdB10nrb100run1earfcn500[3] = 4.000000000000e+00; + activeRbs_txpowdB10nrb100run1earfcn500[4] = 6.000000000000e+00; + activeRbs_txpowdB10nrb100run1earfcn500[5] = 9.000000000000e+00; + activeRbs_txpowdB10nrb100run1earfcn500[6] = 1.600000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[7] = 1.700000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[8] = 1.800000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[9] = 2.200000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[10] = 2.300000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[11] = 2.900000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[12] = 3.200000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[13] = 3.300000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[14] = 3.500000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[15] = 3.800000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[16] = 3.900000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[17] = 4.000000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[18] = 4.100000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[19] = 4.500000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[20] = 4.600000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[21] = 4.800000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[22] = 5.000000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[23] = 5.300000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[24] = 5.400000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[25] = 5.800000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[26] = 5.900000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[27] = 6.000000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[28] = 6.200000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[29] = 6.600000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[30] = 6.800000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[31] = 7.100000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[32] = 7.200000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[33] = 7.400000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[34] = 7.600000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[35] = 7.700000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[36] = 8.100000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[37] = 8.200000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[38] = 8.300000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[39] = 8.400000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[40] = 8.800000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[41] = 9.200000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[42] = 9.300000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[43] = 9.500000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[44] = 9.600000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[45] = 9.700000000000e+01; + activeRbs_txpowdB10nrb100run1earfcn500[46] = 9.800000000000e+01; + SpectrumValue spectrumValue_txpowdB10nrb100run1earfcn500 (LteSpectrumValueHelper::GetSpectrumModel (500, 100)); + spectrumValue_txpowdB10nrb100run1earfcn500[0] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[1] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[2] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[3] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[4] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[5] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[6] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[7] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[8] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[9] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[10] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[11] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[12] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[13] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[14] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[15] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[16] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[17] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[18] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[19] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[20] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[21] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[22] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[23] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[24] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[25] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[26] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[27] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[28] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[29] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[30] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[31] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[32] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[33] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[34] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[35] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[36] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[37] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[38] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[39] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[40] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[41] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[42] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[43] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[44] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[45] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[46] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[47] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[48] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[49] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[50] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[51] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[52] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[53] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[54] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[55] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[56] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[57] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[58] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[59] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[60] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[61] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[62] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[63] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[64] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[65] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[66] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[67] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[68] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[69] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[70] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[71] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[72] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[73] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[74] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[75] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[76] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[77] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[78] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[79] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[80] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[81] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[82] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[83] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[84] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[85] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[86] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[87] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[88] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[89] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[90] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[91] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[92] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[93] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[94] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run1earfcn500[95] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[96] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[97] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[98] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run1earfcn500[99] = 0.000000000000e+00; + AddTestCase (new LteTxPsdTestCase ("txpowdB10nrb100run1earfcn500", 500, 100, 10.000000, activeRbs_txpowdB10nrb100run1earfcn500, spectrumValue_txpowdB10nrb100run1earfcn500)); + + std::vector activeRbs_txpowdB30nrb100run1earfcn500 (45); + activeRbs_txpowdB30nrb100run1earfcn500[0] = 0.000000000000e+00; + activeRbs_txpowdB30nrb100run1earfcn500[1] = 1.000000000000e+00; + activeRbs_txpowdB30nrb100run1earfcn500[2] = 6.000000000000e+00; + activeRbs_txpowdB30nrb100run1earfcn500[3] = 9.000000000000e+00; + activeRbs_txpowdB30nrb100run1earfcn500[4] = 1.100000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[5] = 1.300000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[6] = 1.400000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[7] = 1.600000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[8] = 1.700000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[9] = 2.300000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[10] = 2.500000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[11] = 2.700000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[12] = 3.000000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[13] = 3.100000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[14] = 3.400000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[15] = 3.900000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[16] = 4.100000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[17] = 4.300000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[18] = 4.600000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[19] = 4.700000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[20] = 4.800000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[21] = 5.000000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[22] = 5.200000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[23] = 5.300000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[24] = 5.500000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[25] = 5.600000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[26] = 5.700000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[27] = 5.800000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[28] = 5.900000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[29] = 6.300000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[30] = 6.400000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[31] = 6.500000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[32] = 6.700000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[33] = 7.000000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[34] = 7.200000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[35] = 7.300000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[36] = 8.400000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[37] = 8.900000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[38] = 9.000000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[39] = 9.100000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[40] = 9.200000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[41] = 9.300000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[42] = 9.400000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[43] = 9.500000000000e+01; + activeRbs_txpowdB30nrb100run1earfcn500[44] = 9.900000000000e+01; + SpectrumValue spectrumValue_txpowdB30nrb100run1earfcn500 (LteSpectrumValueHelper::GetSpectrumModel (500, 100)); + spectrumValue_txpowdB30nrb100run1earfcn500[0] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[1] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[2] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[3] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[4] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[5] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[6] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[7] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[8] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[9] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[10] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[11] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[12] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[13] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[14] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[15] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[16] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[17] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[18] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[19] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[20] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[21] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[22] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[23] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[24] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[25] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[26] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[27] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[28] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[29] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[30] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[31] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[32] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[33] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[34] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[35] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[36] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[37] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[38] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[39] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[40] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[41] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[42] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[43] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[44] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[45] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[46] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[47] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[48] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[49] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[50] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[51] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[52] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[53] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[54] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[55] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[56] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[57] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[58] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[59] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[60] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[61] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[62] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[63] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[64] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[65] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[66] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[67] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[68] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[69] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[70] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[71] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[72] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[73] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[74] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[75] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[76] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[77] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[78] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[79] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[80] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[81] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[82] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[83] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[84] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[85] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[86] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[87] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[88] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[89] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[90] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[91] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[92] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[93] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[94] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[95] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run1earfcn500[96] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[97] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[98] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run1earfcn500[99] = 5.000000000000e-08; + AddTestCase (new LteTxPsdTestCase ("txpowdB30nrb100run1earfcn500", 500, 100, 30.000000, activeRbs_txpowdB30nrb100run1earfcn500, spectrumValue_txpowdB30nrb100run1earfcn500)); + + std::vector activeRbs_txpowdB10nrb6run2earfcn500 (2); + activeRbs_txpowdB10nrb6run2earfcn500[0] = 0.000000000000e+00; + activeRbs_txpowdB10nrb6run2earfcn500[1] = 3.000000000000e+00; + SpectrumValue spectrumValue_txpowdB10nrb6run2earfcn500 (LteSpectrumValueHelper::GetSpectrumModel (500, 6)); + spectrumValue_txpowdB10nrb6run2earfcn500[0] = 7.142857142857e-09; + spectrumValue_txpowdB10nrb6run2earfcn500[1] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb6run2earfcn500[2] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb6run2earfcn500[3] = 7.142857142857e-09; + spectrumValue_txpowdB10nrb6run2earfcn500[4] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb6run2earfcn500[5] = 0.000000000000e+00; + AddTestCase (new LteTxPsdTestCase ("txpowdB10nrb6run2earfcn500", 500, 6, 10.000000, activeRbs_txpowdB10nrb6run2earfcn500, spectrumValue_txpowdB10nrb6run2earfcn500)); + + std::vector activeRbs_txpowdB30nrb6run2earfcn500 (4); + activeRbs_txpowdB30nrb6run2earfcn500[0] = 0.000000000000e+00; + activeRbs_txpowdB30nrb6run2earfcn500[1] = 1.000000000000e+00; + activeRbs_txpowdB30nrb6run2earfcn500[2] = 2.000000000000e+00; + activeRbs_txpowdB30nrb6run2earfcn500[3] = 4.000000000000e+00; + SpectrumValue spectrumValue_txpowdB30nrb6run2earfcn500 (LteSpectrumValueHelper::GetSpectrumModel (500, 6)); + spectrumValue_txpowdB30nrb6run2earfcn500[0] = 7.142857142857e-07; + spectrumValue_txpowdB30nrb6run2earfcn500[1] = 7.142857142857e-07; + spectrumValue_txpowdB30nrb6run2earfcn500[2] = 7.142857142857e-07; + spectrumValue_txpowdB30nrb6run2earfcn500[3] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb6run2earfcn500[4] = 7.142857142857e-07; + spectrumValue_txpowdB30nrb6run2earfcn500[5] = 0.000000000000e+00; + AddTestCase (new LteTxPsdTestCase ("txpowdB30nrb6run2earfcn500", 500, 6, 30.000000, activeRbs_txpowdB30nrb6run2earfcn500, spectrumValue_txpowdB30nrb6run2earfcn500)); + + std::vector activeRbs_txpowdB10nrb25run2earfcn500 (8); + activeRbs_txpowdB10nrb25run2earfcn500[0] = 3.000000000000e+00; + activeRbs_txpowdB10nrb25run2earfcn500[1] = 5.000000000000e+00; + activeRbs_txpowdB10nrb25run2earfcn500[2] = 7.000000000000e+00; + activeRbs_txpowdB10nrb25run2earfcn500[3] = 1.200000000000e+01; + activeRbs_txpowdB10nrb25run2earfcn500[4] = 1.400000000000e+01; + activeRbs_txpowdB10nrb25run2earfcn500[5] = 1.500000000000e+01; + activeRbs_txpowdB10nrb25run2earfcn500[6] = 1.600000000000e+01; + activeRbs_txpowdB10nrb25run2earfcn500[7] = 2.200000000000e+01; + SpectrumValue spectrumValue_txpowdB10nrb25run2earfcn500 (LteSpectrumValueHelper::GetSpectrumModel (500, 25)); + spectrumValue_txpowdB10nrb25run2earfcn500[0] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb25run2earfcn500[1] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb25run2earfcn500[2] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb25run2earfcn500[3] = 2.000000000000e-09; + spectrumValue_txpowdB10nrb25run2earfcn500[4] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb25run2earfcn500[5] = 2.000000000000e-09; + spectrumValue_txpowdB10nrb25run2earfcn500[6] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb25run2earfcn500[7] = 2.000000000000e-09; + spectrumValue_txpowdB10nrb25run2earfcn500[8] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb25run2earfcn500[9] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb25run2earfcn500[10] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb25run2earfcn500[11] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb25run2earfcn500[12] = 2.000000000000e-09; + spectrumValue_txpowdB10nrb25run2earfcn500[13] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb25run2earfcn500[14] = 2.000000000000e-09; + spectrumValue_txpowdB10nrb25run2earfcn500[15] = 2.000000000000e-09; + spectrumValue_txpowdB10nrb25run2earfcn500[16] = 2.000000000000e-09; + spectrumValue_txpowdB10nrb25run2earfcn500[17] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb25run2earfcn500[18] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb25run2earfcn500[19] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb25run2earfcn500[20] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb25run2earfcn500[21] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb25run2earfcn500[22] = 2.000000000000e-09; + spectrumValue_txpowdB10nrb25run2earfcn500[23] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb25run2earfcn500[24] = 0.000000000000e+00; + AddTestCase (new LteTxPsdTestCase ("txpowdB10nrb25run2earfcn500", 500, 25, 10.000000, activeRbs_txpowdB10nrb25run2earfcn500, spectrumValue_txpowdB10nrb25run2earfcn500)); + + std::vector activeRbs_txpowdB30nrb25run2earfcn500 (11); + activeRbs_txpowdB30nrb25run2earfcn500[0] = 4.000000000000e+00; + activeRbs_txpowdB30nrb25run2earfcn500[1] = 6.000000000000e+00; + activeRbs_txpowdB30nrb25run2earfcn500[2] = 8.000000000000e+00; + activeRbs_txpowdB30nrb25run2earfcn500[3] = 9.000000000000e+00; + activeRbs_txpowdB30nrb25run2earfcn500[4] = 1.000000000000e+01; + activeRbs_txpowdB30nrb25run2earfcn500[5] = 1.100000000000e+01; + activeRbs_txpowdB30nrb25run2earfcn500[6] = 1.400000000000e+01; + activeRbs_txpowdB30nrb25run2earfcn500[7] = 1.500000000000e+01; + activeRbs_txpowdB30nrb25run2earfcn500[8] = 1.600000000000e+01; + activeRbs_txpowdB30nrb25run2earfcn500[9] = 2.200000000000e+01; + activeRbs_txpowdB30nrb25run2earfcn500[10] = 2.400000000000e+01; + SpectrumValue spectrumValue_txpowdB30nrb25run2earfcn500 (LteSpectrumValueHelper::GetSpectrumModel (500, 25)); + spectrumValue_txpowdB30nrb25run2earfcn500[0] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb25run2earfcn500[1] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb25run2earfcn500[2] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb25run2earfcn500[3] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb25run2earfcn500[4] = 2.000000000000e-07; + spectrumValue_txpowdB30nrb25run2earfcn500[5] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb25run2earfcn500[6] = 2.000000000000e-07; + spectrumValue_txpowdB30nrb25run2earfcn500[7] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb25run2earfcn500[8] = 2.000000000000e-07; + spectrumValue_txpowdB30nrb25run2earfcn500[9] = 2.000000000000e-07; + spectrumValue_txpowdB30nrb25run2earfcn500[10] = 2.000000000000e-07; + spectrumValue_txpowdB30nrb25run2earfcn500[11] = 2.000000000000e-07; + spectrumValue_txpowdB30nrb25run2earfcn500[12] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb25run2earfcn500[13] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb25run2earfcn500[14] = 2.000000000000e-07; + spectrumValue_txpowdB30nrb25run2earfcn500[15] = 2.000000000000e-07; + spectrumValue_txpowdB30nrb25run2earfcn500[16] = 2.000000000000e-07; + spectrumValue_txpowdB30nrb25run2earfcn500[17] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb25run2earfcn500[18] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb25run2earfcn500[19] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb25run2earfcn500[20] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb25run2earfcn500[21] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb25run2earfcn500[22] = 2.000000000000e-07; + spectrumValue_txpowdB30nrb25run2earfcn500[23] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb25run2earfcn500[24] = 2.000000000000e-07; + AddTestCase (new LteTxPsdTestCase ("txpowdB30nrb25run2earfcn500", 500, 25, 30.000000, activeRbs_txpowdB30nrb25run2earfcn500, spectrumValue_txpowdB30nrb25run2earfcn500)); + + std::vector activeRbs_txpowdB10nrb100run2earfcn500 (42); + activeRbs_txpowdB10nrb100run2earfcn500[0] = 1.000000000000e+00; + activeRbs_txpowdB10nrb100run2earfcn500[1] = 2.000000000000e+00; + activeRbs_txpowdB10nrb100run2earfcn500[2] = 5.000000000000e+00; + activeRbs_txpowdB10nrb100run2earfcn500[3] = 6.000000000000e+00; + activeRbs_txpowdB10nrb100run2earfcn500[4] = 1.100000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[5] = 1.300000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[6] = 1.500000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[7] = 1.600000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[8] = 1.700000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[9] = 1.800000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[10] = 2.300000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[11] = 2.400000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[12] = 2.500000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[13] = 3.300000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[14] = 3.400000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[15] = 3.500000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[16] = 3.600000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[17] = 3.800000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[18] = 3.900000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[19] = 4.400000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[20] = 4.900000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[21] = 5.000000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[22] = 5.100000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[23] = 5.600000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[24] = 5.700000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[25] = 5.900000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[26] = 6.100000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[27] = 6.200000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[28] = 6.400000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[29] = 6.500000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[30] = 6.800000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[31] = 6.900000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[32] = 7.700000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[33] = 8.000000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[34] = 8.100000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[35] = 8.200000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[36] = 8.300000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[37] = 8.400000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[38] = 8.700000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[39] = 9.100000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[40] = 9.600000000000e+01; + activeRbs_txpowdB10nrb100run2earfcn500[41] = 9.900000000000e+01; + SpectrumValue spectrumValue_txpowdB10nrb100run2earfcn500 (LteSpectrumValueHelper::GetSpectrumModel (500, 100)); + spectrumValue_txpowdB10nrb100run2earfcn500[0] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[1] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[2] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[3] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[4] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[5] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[6] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[7] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[8] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[9] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[10] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[11] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[12] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[13] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[14] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[15] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[16] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[17] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[18] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[19] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[20] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[21] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[22] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[23] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[24] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[25] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[26] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[27] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[28] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[29] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[30] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[31] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[32] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[33] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[34] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[35] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[36] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[37] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[38] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[39] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[40] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[41] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[42] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[43] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[44] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[45] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[46] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[47] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[48] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[49] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[50] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[51] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[52] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[53] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[54] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[55] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[56] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[57] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[58] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[59] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[60] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[61] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[62] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[63] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[64] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[65] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[66] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[67] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[68] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[69] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[70] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[71] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[72] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[73] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[74] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[75] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[76] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[77] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[78] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[79] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[80] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[81] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[82] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[83] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[84] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[85] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[86] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[87] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[88] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[89] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[90] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[91] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[92] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[93] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[94] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[95] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[96] = 5.000000000000e-10; + spectrumValue_txpowdB10nrb100run2earfcn500[97] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[98] = 0.000000000000e+00; + spectrumValue_txpowdB10nrb100run2earfcn500[99] = 5.000000000000e-10; + AddTestCase (new LteTxPsdTestCase ("txpowdB10nrb100run2earfcn500", 500, 100, 10.000000, activeRbs_txpowdB10nrb100run2earfcn500, spectrumValue_txpowdB10nrb100run2earfcn500)); + + std::vector activeRbs_txpowdB30nrb100run2earfcn500 (49); + activeRbs_txpowdB30nrb100run2earfcn500[0] = 1.000000000000e+00; + activeRbs_txpowdB30nrb100run2earfcn500[1] = 2.000000000000e+00; + activeRbs_txpowdB30nrb100run2earfcn500[2] = 4.000000000000e+00; + activeRbs_txpowdB30nrb100run2earfcn500[3] = 5.000000000000e+00; + activeRbs_txpowdB30nrb100run2earfcn500[4] = 6.000000000000e+00; + activeRbs_txpowdB30nrb100run2earfcn500[5] = 9.000000000000e+00; + activeRbs_txpowdB30nrb100run2earfcn500[6] = 1.300000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[7] = 1.600000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[8] = 2.000000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[9] = 2.100000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[10] = 2.200000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[11] = 2.300000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[12] = 2.500000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[13] = 2.700000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[14] = 3.200000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[15] = 3.300000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[16] = 3.700000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[17] = 3.800000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[18] = 3.900000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[19] = 4.000000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[20] = 4.100000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[21] = 4.500000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[22] = 4.800000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[23] = 5.000000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[24] = 5.100000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[25] = 5.600000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[26] = 5.700000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[27] = 5.900000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[28] = 6.300000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[29] = 6.700000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[30] = 6.800000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[31] = 7.200000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[32] = 7.300000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[33] = 7.800000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[34] = 7.900000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[35] = 8.200000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[36] = 8.300000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[37] = 8.400000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[38] = 8.500000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[39] = 8.700000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[40] = 8.800000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[41] = 8.900000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[42] = 9.000000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[43] = 9.100000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[44] = 9.200000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[45] = 9.300000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[46] = 9.400000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[47] = 9.700000000000e+01; + activeRbs_txpowdB30nrb100run2earfcn500[48] = 9.900000000000e+01; + SpectrumValue spectrumValue_txpowdB30nrb100run2earfcn500 (LteSpectrumValueHelper::GetSpectrumModel (500, 100)); + spectrumValue_txpowdB30nrb100run2earfcn500[0] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[1] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[2] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[3] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[4] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[5] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[6] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[7] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[8] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[9] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[10] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[11] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[12] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[13] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[14] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[15] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[16] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[17] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[18] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[19] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[20] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[21] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[22] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[23] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[24] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[25] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[26] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[27] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[28] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[29] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[30] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[31] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[32] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[33] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[34] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[35] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[36] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[37] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[38] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[39] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[40] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[41] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[42] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[43] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[44] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[45] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[46] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[47] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[48] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[49] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[50] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[51] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[52] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[53] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[54] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[55] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[56] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[57] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[58] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[59] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[60] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[61] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[62] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[63] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[64] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[65] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[66] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[67] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[68] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[69] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[70] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[71] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[72] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[73] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[74] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[75] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[76] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[77] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[78] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[79] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[80] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[81] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[82] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[83] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[84] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[85] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[86] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[87] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[88] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[89] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[90] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[91] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[92] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[93] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[94] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[95] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[96] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[97] = 5.000000000000e-08; + spectrumValue_txpowdB30nrb100run2earfcn500[98] = 0.000000000000e+00; + spectrumValue_txpowdB30nrb100run2earfcn500[99] = 5.000000000000e-08; + AddTestCase (new LteTxPsdTestCase ("txpowdB30nrb100run2earfcn500", 500, 100, 30.000000, activeRbs_txpowdB30nrb100run2earfcn500, spectrumValue_txpowdB30nrb100run2earfcn500)); + + + +} + + +} // namespace ns3 diff --git a/src/lte/test/lte-test-uplink-sinr.cc b/src/lte/test/lte-test-uplink-sinr.cc index bfbc45383..927b9044c 100644 --- a/src/lte/test/lte-test-uplink-sinr.cc +++ b/src/lte/test/lte-test-uplink-sinr.cc @@ -43,12 +43,12 @@ using namespace ns3; LteUplinkSinrTestSuite::LteUplinkSinrTestSuite () : TestSuite ("lte-uplink-sinr", SYSTEM) { - LogLevel logLevel = (LogLevel)(LOG_PREFIX_FUNC | LOG_PREFIX_TIME | LOG_LEVEL_ALL); + // LogLevel logLevel = (LogLevel)(LOG_PREFIX_FUNC | LOG_PREFIX_TIME | LOG_LEVEL_ALL); - LogComponentEnable ("LteTestUePhy", logLevel); - LogComponentEnable ("LteUplinkSinrTest", logLevel); + // LogComponentEnable ("LteTestUePhy", logLevel); + // LogComponentEnable ("LteUplinkSinrTest", logLevel); - NS_LOG_INFO ("Creating LteUplinkSinrTestSuite"); + // NS_LOG_INFO ("Creating LteUplinkSinrTestSuite"); /** * Build Spectrum Model values for the TX signal diff --git a/src/lte/wscript b/src/lte/wscript index af8bc8d98..cae9dada4 100644 --- a/src/lte/wscript +++ b/src/lte/wscript @@ -57,6 +57,7 @@ def build(bld): 'test/lte-test-rr-ff-mac-scheduler.cc', 'test/lte-test-pf-ff-mac-scheduler.cc', 'test/lte-test-earfcn.cc', + 'test/lte-test-spectrum-value-helper.cc', ] headers = bld.new_task_gen('ns3header') diff --git a/src/spectrum/test/spectrum-test.h b/src/spectrum/test/spectrum-test.h new file mode 100644 index 000000000..aab736c0b --- /dev/null +++ b/src/spectrum/test/spectrum-test.h @@ -0,0 +1,152 @@ +/* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */ +/* + * Copyright (c) 2009 University of Washington + * Copyright (c) 2011 CTTC + * + * 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: Nicola Baldo + * part of the code copied from test.h + */ + +#include +#include + + +/** + * \brief Test if two SpectrumModel instances are equal within a given tolerance. + * + * This test compares component-by-component the two SpectrumModel + * instances; if any pair of components differs by more than the given + * tolerance, the test fails. + * + * \param actual the actual value obtained by the simulator + * \param expected the expected value obtained by off-line calculations + * \param tol the tolerance + * \param msg the message to print if the test fails + * + */ +#define NS_TEST_ASSERT_MSG_SPECTRUM_MODEL_EQ_TOL(actual, expected, tol, msg) \ + NS_TEST_ASSERT_MSG_SPECTRUM_MODEL_EQ_TOL_INTERNAL(actual, expected, tol, msg, __FILE__, __LINE__) + + +/** + * \internal + */ +#define NS_TEST_ASSERT_MSG_SPECTRUM_MODEL_EQ_TOL_INTERNAL(actual, expected, tol, msg, file, line) \ + do \ + { \ + Bands::const_iterator i = (actual).Begin (); \ + Bands::const_iterator j = (expected).Begin (); \ + uint32_t k = 0; \ + while (i != (actual).End () && j != (expected).End ()) \ + { \ + if ((i->fl > j->fl + (tol)) || (i->fl < j->fl - (tol)) || \ + (i->fc > j->fc + (tol)) || (i->fc < j->fc - (tol)) || \ + (i->fh > j->fh + (tol)) || (i->fh < j->fh - (tol))) \ + { \ + if (gBreakOnFailure) {*(int *)0 = 0;} \ + std::ostringstream indexStream; \ + indexStream << "[" << k << "]"; \ + std::ostringstream msgStream; \ + msgStream << (msg); \ + std::ostringstream actualStream; \ + actualStream << i->fl << " <-- " << i->fc << " --> " << i->fh; \ + std::ostringstream expectedStream; \ + expectedStream << j->fl << " <-- " << j->fc << " --> " << j->fh; \ + ReportTestFailure (std::string (#actual) + indexStream.str () + " == " + std::string (#expected) + indexStream.str (), \ + actualStream.str (), expectedStream.str (), msgStream.str (), (file), (line)); \ + } \ + ++i; \ + ++j; \ + ++k; \ + } \ + if (i != (actual).End () || j != (expected).End ()) \ + { \ + std::ostringstream msgStream; \ + msgStream << (msg); \ + std::ostringstream actualStream; \ + actualStream << (i != (actual).End ()); \ + std::ostringstream expectedStream; \ + expectedStream << (j != (expected).End ()); \ + ReportTestFailure ("Bands::iterator == End ()" , \ + actualStream.str (), expectedStream.str (), msgStream.str (), (file), (line)); \ + } \ + } \ + while (false); \ + + +/** + * \brief Test if two SpectrumValue instances are equal within a given tolerance. + * + * This test compares component-by-component the two SpectrumValue + * instances; if any pair of components differs by more than the given + * tolerance, the test fails. + * + * \param actual the actual value obtained by the simulator + * \param expected the expected value obtained by off-line calculations + * \param tol the tolerance + * \param msg the message to print if the test fails + * + */ +#define NS_TEST_ASSERT_MSG_SPECTRUM_VALUE_EQ_TOL(actual, expected, tol, msg) \ + NS_TEST_ASSERT_MSG_SPECTRUM_VALUE_EQ_TOL_INTERNAL(actual, expected, tol, msg, __FILE__, __LINE__) + + +/** + * \internal + */ +#define NS_TEST_ASSERT_MSG_SPECTRUM_VALUE_EQ_TOL_INTERNAL(actual, expected, tol, msg, file, line) \ + do \ + { \ + Values::const_iterator i = (actual).ConstValuesBegin (); \ + Values::const_iterator j = (expected).ConstValuesBegin (); \ + uint32_t k = 0; \ + while (i != (actual).ConstValuesEnd () && j != (expected).ConstValuesEnd ()) \ + { \ + if ((*i) > (*j) + (tol) || (*i) < (*j) - (tol)) \ + { \ + if (gBreakOnFailure) {*(int *)0 = 0;} \ + std::ostringstream indexStream; \ + indexStream << "[" << k << "]"; \ + std::ostringstream msgStream; \ + msgStream << msg; \ + std::ostringstream actualStream; \ + actualStream << actual; \ + std::ostringstream expectedStream; \ + expectedStream << expected; \ + ReportTestFailure (std::string (#actual) + indexStream.str () + " == " + std::string (#expected) + indexStream.str (), \ + actualStream.str (), expectedStream.str (), msgStream.str (), file, line); \ + } \ + ++i; \ + ++j; \ + ++k; \ + } \ + if (i != (actual).ConstValuesEnd () || j != (expected).ConstValuesEnd ()) \ + { \ + std::ostringstream msgStream; \ + msgStream << (msg); \ + std::ostringstream actualStream; \ + actualStream << (i != (actual).ConstValuesEnd ()); \ + std::ostringstream expectedStream; \ + expectedStream << (j != (expected).ConstValuesEnd ()); \ + ReportTestFailure ("Values::const_iterator == ConstValuesEnd ()" , \ + actualStream.str (), expectedStream.str (), msgStream.str (), (file), (line)); \ + } \ + } \ + while (false); \ + + + + diff --git a/src/spectrum/test/spectrum-value-test.cc b/src/spectrum/test/spectrum-value-test.cc index 5d279ac3d..3f825c7ea 100644 --- a/src/spectrum/test/spectrum-value-test.cc +++ b/src/spectrum/test/spectrum-value-test.cc @@ -26,7 +26,7 @@ #include #include -#include "spectrum-value-test.h" +#include "spectrum-test.h" // NS_LOG_COMPONENT_DEFINE ("SpectrumValueTest"); @@ -72,6 +72,7 @@ SpectrumValueTestCase::MoreOrLessEqual (SpectrumValue x, SpectrumValue y) void SpectrumValueTestCase::DoRun (void) { + NS_TEST_ASSERT_MSG_SPECTRUM_MODEL_EQ_TOL (*m_a.GetSpectrumModel (), *m_b.GetSpectrumModel (), TOLERANCE, GetName ()); NS_TEST_ASSERT_MSG_SPECTRUM_VALUE_EQ_TOL (m_a, m_b, TOLERANCE, GetName ()); } diff --git a/src/spectrum/test/spectrum-value-test.h b/src/spectrum/test/spectrum-value-test.h deleted file mode 100644 index 367421b68..000000000 --- a/src/spectrum/test/spectrum-value-test.h +++ /dev/null @@ -1,77 +0,0 @@ -/* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */ -/* - * Copyright (c) 2009 University of Washington - * Copyright (c) 2011 CTTC - * - * 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: Nicola Baldo - * part of the code copied from test.h - */ - -#include -#include - -/** - * \brief Test if two SpectrumValue instances are equal within a given tolerance. - * - * This test compares component-by-component the two SpectrumValue - * instances; if any pair of components differs by more than the given - * tolerance, the test fails. - * - * \param actual the actual value obtained by the simulator - * \param expected the expected value obtained by off-line calculations - * \param tol the tolerance - * \param msg the message to print if the test fails - * - */ -#define NS_TEST_ASSERT_MSG_SPECTRUM_VALUE_EQ_TOL(actual, expected, tol, msg) \ - NS_TEST_ASSERT_MSG_SPECTRUM_VALUE_EQ_TOL_INTERNAL(actual, expected, tol, msg, __FILE__, __LINE__) - - -/** - * \internal - */ -#define NS_TEST_ASSERT_MSG_SPECTRUM_VALUE_EQ_TOL_INTERNAL(actual, expected, tol, msg, file, line) \ - do \ - { \ - Values::const_iterator i = actual.ConstValuesBegin (); \ - Values::const_iterator j = expected.ConstValuesBegin (); \ - uint32_t k = 0; \ - while (i != actual.ConstValuesEnd () && j != expected.ConstValuesEnd ()) \ - { \ - if ((*i) > (*j) + (tol) || (*i) < (*j) - (tol)) \ - { \ - if (gBreakOnFailure) {*(int *)0 = 0;} \ - std::ostringstream indexStream; \ - indexStream << "[" << k << "]"; \ - std::ostringstream msgStream; \ - msgStream << msg; \ - std::ostringstream actualStream; \ - actualStream << actual; \ - std::ostringstream expectedStream; \ - expectedStream << expected; \ - ReportTestFailure (std::string (#actual) + indexStream.str () + " == " + std::string (#expected) + indexStream.str (), \ - actualStream.str (), expectedStream.str (), msgStream.str (), file, line); \ - } \ - ++i; \ - ++j; \ - ++k; \ - } \ - } \ - while (false); \ - - - - diff --git a/src/spectrum/wscript b/src/spectrum/wscript index 348444743..c396aea22 100644 --- a/src/spectrum/wscript +++ b/src/spectrum/wscript @@ -67,7 +67,7 @@ def build(bld): 'helper/adhoc-aloha-noack-ideal-phy-helper.h', 'helper/waveform-generator-helper.h', 'helper/spectrum-analyzer-helper.h', - 'test/spectrum-value-test.h', + 'test/spectrum-test.h', ] if (bld.env['ENABLE_EXAMPLES']): diff --git a/src/tap-bridge/examples/tap-csma-virtual-machine.py b/src/tap-bridge/examples/tap-csma-virtual-machine.py index 10c812841..2dd130895 100644 --- a/src/tap-bridge/examples/tap-csma-virtual-machine.py +++ b/src/tap-bridge/examples/tap-csma-virtual-machine.py @@ -17,7 +17,12 @@ # import sys -import ns3 + +import ns.core +import ns.csma +import ns.internet +import ns.network +import ns.tap_bridge def main(argv): # @@ -25,15 +30,15 @@ def main(argv): # interact in real-time and therefore we have to use the real-time simulator # and take the time to calculate checksums. # - ns3.GlobalValue.Bind("SimulatorImplementationType", ns3.StringValue("ns3::RealtimeSimulatorImpl")) - ns3.GlobalValue.Bind("ChecksumEnabled", ns3.BooleanValue("true")) + ns.core.GlobalValue.Bind("SimulatorImplementationType", ns.core.StringValue("ns3::RealtimeSimulatorImpl")) + ns.core.GlobalValue.Bind("ChecksumEnabled", ns.core.BooleanValue("true")) # # Create two ghost nodes. The first will represent the virtual machine host # on the left side of the network; and the second will represent the VM on # the right side. # - nodes = ns3.NodeContainer() + nodes = ns.network.NodeContainer() nodes.Create (2) # @@ -41,7 +46,7 @@ def main(argv): # devices installed on both of the nodes. The data rate and delay for the # channel can be set through the command-line parser. # - csma = ns3.CsmaHelper() + csma = ns.csma.CsmaHelper() devices = csma.Install(nodes) # @@ -52,24 +57,24 @@ def main(argv): # only see traffic from one other device on that bridge. That is the case # for this configuration. # - tapBridge = ns3.TapBridgeHelper() - tapBridge.SetAttribute ("Mode", ns3.StringValue ("UseLocal")) - tapBridge.SetAttribute ("DeviceName", ns3.StringValue ("tap-left")) + tapBridge = ns.tap_bridge.TapBridgeHelper() + tapBridge.SetAttribute ("Mode", ns.core.StringValue ("UseLocal")) + tapBridge.SetAttribute ("DeviceName", ns.core.StringValue ("tap-left")) tapBridge.Install (nodes.Get (0), devices.Get (0)) # # Connect the right side tap to the right side wifi device on the right-side # ghost node. # - tapBridge.SetAttribute ("DeviceName", ns3.StringValue ("tap-right")) + tapBridge.SetAttribute ("DeviceName", ns.core.StringValue ("tap-right")) tapBridge.Install (nodes.Get (1), devices.Get (1)) # # Run the simulation for ten minutes to give the user time to play around # - ns3.Simulator.Stop (ns3.Seconds (600)) - ns3.Simulator.Run(signal_check_frequency = -1) - ns3.Simulator.Destroy() + ns.core.Simulator.Stop (ns.core.Seconds (600)) + ns.core.Simulator.Run(signal_check_frequency = -1) + ns.core.Simulator.Destroy() return 0 if __name__ == '__main__': diff --git a/src/tap-bridge/examples/tap-wifi-virtual-machine.py b/src/tap-bridge/examples/tap-wifi-virtual-machine.py index 7e7fcd76a..045a7a16e 100644 --- a/src/tap-bridge/examples/tap-wifi-virtual-machine.py +++ b/src/tap-bridge/examples/tap-wifi-virtual-machine.py @@ -17,7 +17,12 @@ # import sys -import ns3 +import ns.core +import ns.internet +import ns.mobility +import ns.network +import ns.tap_bridge +import ns.wifi def main(argv): # @@ -25,35 +30,35 @@ def main(argv): # interact in real-time and therefore we have to use the real-time simulator # and take the time to calculate checksums. # - ns3.GlobalValue.Bind("SimulatorImplementationType", ns3.StringValue("ns3::RealtimeSimulatorImpl")) - ns3.GlobalValue.Bind("ChecksumEnabled", ns3.BooleanValue("true")) + ns.core.GlobalValue.Bind("SimulatorImplementationType", ns.core.StringValue("ns3::RealtimeSimulatorImpl")) + ns.core.GlobalValue.Bind("ChecksumEnabled", ns.core.BooleanValue("true")) # # Create two ghost nodes. The first will represent the virtual machine host # on the left side of the network; and the second will represent the VM on # the right side. # - nodes = ns3.NodeContainer() + nodes = ns.network.NodeContainer() nodes.Create (2); # # We're going to use 802.11 A so set up a wifi helper to reflect that. # - wifi = ns3.WifiHelper.Default() - wifi.SetStandard (ns3.WIFI_PHY_STANDARD_80211a); - wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager", "DataMode", ns3.StringValue ("OfdmRate54Mbps")); + wifi = ns.wifi.WifiHelper.Default() + wifi.SetStandard (ns.wifi.WIFI_PHY_STANDARD_80211a); + wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager", "DataMode", ns.core.StringValue ("OfdmRate54Mbps")); # # No reason for pesky access points, so we'll use an ad-hoc network. # - wifiMac = ns3.NqosWifiMacHelper.Default() + wifiMac = ns.wifi.NqosWifiMacHelper.Default() wifiMac.SetType ("ns3::AdhocWifiMac"); # # Configure the physcial layer. # - wifiChannel = ns3.YansWifiChannelHelper.Default() - wifiPhy = ns3.YansWifiPhyHelper.Default() + wifiChannel = ns.wifi.YansWifiChannelHelper.Default() + wifiPhy = ns.wifi.YansWifiPhyHelper.Default() wifiPhy.SetChannel(wifiChannel.Create()) # @@ -65,10 +70,10 @@ def main(argv): # We need location information since we are talking about wifi, so add a # constant position to the ghost nodes. # - mobility = ns3.MobilityHelper() - positionAlloc = ns3.ListPositionAllocator() - positionAlloc.Add(ns3.Vector(0.0, 0.0, 0.0)) - positionAlloc.Add(ns3.Vector(5.0, 0.0, 0.0)) + mobility = ns.mobility.MobilityHelper() + positionAlloc = ns.mobility.ListPositionAllocator() + positionAlloc.Add(ns.core.Vector(0.0, 0.0, 0.0)) + positionAlloc.Add(ns.core.Vector(5.0, 0.0, 0.0)) mobility.SetPositionAllocator(positionAlloc) mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel") mobility.Install(nodes) @@ -81,24 +86,24 @@ def main(argv): # only see traffic from one other device on that bridge. That is the case # for this configuration. # - tapBridge = ns3.TapBridgeHelper() - tapBridge.SetAttribute ("Mode", ns3.StringValue ("UseLocal")); - tapBridge.SetAttribute ("DeviceName", ns3.StringValue ("tap-left")); + tapBridge = ns.tap_bridge.TapBridgeHelper() + tapBridge.SetAttribute ("Mode", ns.core.StringValue ("UseLocal")); + tapBridge.SetAttribute ("DeviceName", ns.core.StringValue ("tap-left")); tapBridge.Install (nodes.Get (0), devices.Get (0)); # # Connect the right side tap to the right side wifi device on the right-side # ghost node. # - tapBridge.SetAttribute ("DeviceName", ns3.StringValue ("tap-right")); + tapBridge.SetAttribute ("DeviceName", ns.core.StringValue ("tap-right")); tapBridge.Install (nodes.Get (1), devices.Get (1)); # # Run the simulation for ten minutes to give the user time to play around # - ns3.Simulator.Stop (ns3.Seconds (600)); - ns3.Simulator.Run(signal_check_frequency = -1) - ns3.Simulator.Destroy() + ns.core.Simulator.Stop (ns.core.Seconds (600)); + ns.core.Simulator.Run(signal_check_frequency = -1) + ns.core.Simulator.Destroy() return 0 if __name__ == '__main__': diff --git a/src/visualizer/visualizer/core.py b/src/visualizer/visualizer/core.py index c505cb079..9ab7367cc 100644 --- a/src/visualizer/visualizer/core.py +++ b/src/visualizer/visualizer/core.py @@ -156,6 +156,7 @@ class Node(PyVizObject): try: ns3_node = ns3.NodeList.GetNode(self.node_index) ipv4 = ns3_node.GetObject(ns3.Ipv4.GetTypeId()) + ipv6 = ns3_node.GetObject(ns3.Ipv6.GetTypeId()) lines = ['Node %i' % self.node_index] lines.append('') @@ -174,6 +175,7 @@ class Node(PyVizObject): lines.append(' Name: %s' % name) devname = dev.GetInstanceTypeId().GetName() lines.append(' Type: %s' % devname) + if ipv4 is not None: ipv4_idx = ipv4.GetInterfaceForDevice(dev) if ipv4_idx != -1: @@ -182,6 +184,15 @@ class Node(PyVizObject): ipv4.GetAddress(ipv4_idx, i).GetMask()) for i in range(ipv4.GetNAddresses(ipv4_idx))] lines.append(' IPv4 Addresses: %s' % '; '.join(addresses)) + + if ipv6 is not None: + ipv6_idx = ipv6.GetInterfaceForDevice(dev) + if ipv6_idx != -1: + addresses = [ + '%s/%s' % (ipv6.GetAddress(ipv6_idx, i).GetAddress(), + ipv6.GetAddress(ipv6_idx, i).GetPrefix()) + for i in range(ipv6.GetNAddresses(ipv4_idx))] + lines.append(' IPv6 Addresses: %s' % '; '.join(addresses)) lines.append(' MAC Address: %s' % (dev.GetAddress(),))