TypeId
FriisPropagationLossModel::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::FriisPropagationLossModel")
.SetParent<PropagationLossModel> ()
.AddConstructor<FriisPropagationLossModel> ()
.AddAttribute ("Frequency",
"The carrier frequency (in Hz) at which propagation occurs (default is 5.15 GHz).",
DoubleValue (5.150e9),
MakeDoubleAccessor (&FriisPropagationLossModel::SetFrequency,
&FriisPropagationLossModel::GetFrequency),
MakeDoubleChecker<double> ())
.AddAttribute ("SystemLoss", "The system loss",
DoubleValue (1.0),
MakeDoubleAccessor (&FriisPropagationLossModel::m_systemLoss),
MakeDoubleChecker<double> ())
.AddAttribute ("MinDistance",
"The distance under which the propagation model refuses to give results (m)",
DoubleValue (0.5),
MakeDoubleAccessor (&FriisPropagationLossModel::SetMinDistance,
&FriisPropagationLossModel::GetMinDistance),
MakeDoubleChecker<double> ())
;
return tid;
}
void
BuildingsPathlossTestCase::DoRun (void)
{
NS_LOG_FUNCTION (this);
// the building basically occupies the negative x plane, so any node
// in this area will fall in the building
Ptr<Building> building1 = CreateObject<Building> ();
building1->SetBoundaries (Box (-3000, -1, -4000, 4000.0, 0.0, 12));
building1->SetBuildingType (Building::Residential);
building1->SetExtWallsType (Building::ConcreteWithWindows);
building1->SetNFloors (3);
Ptr<MobilityModel> mma = CreateMobilityModel (m_mobilityModelIndex1);
Ptr<MobilityModel> mmb = CreateMobilityModel (m_mobilityModelIndex2);
Ptr<HybridBuildingsPropagationLossModel> propagationLossModel = CreateObject<HybridBuildingsPropagationLossModel> ();
propagationLossModel->SetAttribute ("Frequency", DoubleValue (m_freq));
propagationLossModel->SetAttribute ("Environment", EnumValue (m_env));
propagationLossModel->SetAttribute ("CitySize", EnumValue (m_city));
// cancel shadowing effect
propagationLossModel->SetAttribute ("ShadowSigmaOutdoor", DoubleValue (0.0));
propagationLossModel->SetAttribute ("ShadowSigmaIndoor", DoubleValue (0.0));
propagationLossModel->SetAttribute ("ShadowSigmaExtWalls", DoubleValue (0.0));
double loss = propagationLossModel->GetLoss (mma, mmb);
NS_LOG_INFO ("Calculated loss: " << loss);
NS_LOG_INFO ("Theoretical loss: " << m_lossRef);
NS_TEST_ASSERT_MSG_EQ_TOL (loss, m_lossRef, 0.1, "Wrong loss !");
Simulator::Destroy ();
}
TypeId
TwoRayGroundPropagationLossModel::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::TwoRayGroundPropagationLossModel")
.SetParent<PropagationLossModel> ()
.AddConstructor<TwoRayGroundPropagationLossModel> ()
.AddAttribute ("Frequency",
"The carrier frequency (in Hz) at which propagation occurs (default is 5.15 GHz).",
DoubleValue (5.150e9),
MakeDoubleAccessor (&TwoRayGroundPropagationLossModel::SetFrequency,
&TwoRayGroundPropagationLossModel::GetFrequency),
MakeDoubleChecker<double> ())
.AddAttribute ("SystemLoss", "The system loss",
DoubleValue (1.0),
MakeDoubleAccessor (&TwoRayGroundPropagationLossModel::m_systemLoss),
MakeDoubleChecker<double> ())
.AddAttribute ("MinDistance",
"The distance under which the propagation model refuses to give results (m)",
DoubleValue (0.5),
MakeDoubleAccessor (&TwoRayGroundPropagationLossModel::SetMinDistance,
&TwoRayGroundPropagationLossModel::GetMinDistance),
MakeDoubleChecker<double> ())
.AddAttribute ("HeightAboveZ",
"The height of the antenna (m) above the node's Z coordinate",
DoubleValue (0),
MakeDoubleAccessor (&TwoRayGroundPropagationLossModel::m_heightAboveZ),
MakeDoubleChecker<double> ())
;
return tid;
}
TypeId
LogDistancePropagationLossModel::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::LogDistancePropagationLossModel")
.SetParent<PropagationLossModel> ()
.AddConstructor<LogDistancePropagationLossModel> ()
.AddAttribute ("Exponent",
"The exponent of the Path Loss propagation model",
DoubleValue (3.0),
MakeDoubleAccessor (&LogDistancePropagationLossModel::m_exponent),
MakeDoubleChecker<double> ())
.AddAttribute ("ReferenceDistance",
"The distance at which the reference loss is calculated (m)",
DoubleValue (1.0),
MakeDoubleAccessor (&LogDistancePropagationLossModel::m_referenceDistance),
MakeDoubleChecker<double> ())
.AddAttribute ("ReferenceLoss",
"The reference loss at reference distance (dB). (Default is Friis at 1m with 5.15 GHz)",
DoubleValue (46.6777),
MakeDoubleAccessor (&LogDistancePropagationLossModel::m_referenceLoss),
MakeDoubleChecker<double> ())
;
return tid;
}
void UpsamplingParaDlg::getRadiusValues(double _val)
{
m_paras->upsampling.setValue("CGrid Radius",DoubleValue(_val));
m_paras->setGlobalParameter("CGrid Radius", DoubleValue(_val));
// for debug
cout << m_paras->upsampling.getDouble("CGrid Radius") << endl;
area->updateGL();
}
bool VanishesBeforeMatcher<T>::MatchAndExplain(
quantities::Quantity<Dimensions> const& actual,
testing::MatchResultListener* listener) const {
std::int64_t const distance =
ULPDistance(DoubleValue(reference_), DoubleValue(actual + reference_));
bool const matches = min_ulps_ <= distance && distance <= max_ulps_;
if (!matches) {
*listener << "the numbers are separated by " << distance << " ulps";
}
return matches;
}
const wxString ecConfigItem::StringValue (CdlValueSource source /* = CdlValueSource_Current */ ) const
{
// wxASSERT (!IsPackage()); // not a package item
const CdlValuable valuable = GetCdlValuable();
wxASSERT (valuable);
wxString strValue (wxT(""));
switch (valuable->get_flavor ())
{
case CdlValueFlavor_Data:
case CdlValueFlavor_BoolData:
case CdlValueFlavor_None: // a package
if (m_optionType == ecLong)
strValue = ecUtils::IntToStr (Value (), wxGetApp().GetSettings().m_bHex);
else if (m_optionType == ecDouble)
strValue = ecUtils::DoubleToStr (DoubleValue ());
else
strValue = valuable->get_value (source).c_str ();
break;
default:
wxASSERT (0); // specified flavor not supported
}
return strValue;
}
bool BooleanValue::convert(Value& Val) const
{
if (Val.getType() == Value::DOUBLE)
{
Val = DoubleValue(m_Value);
return true;
}
else if (Val.getType() == Value::INTEGER)
{
Val = IntegerValue(m_Value);
return true;
}
else if (Val.getType() == Value::VECTOR)
{
Val = VectorValue(1,m_Value);
return true;
}
else if (Val.getType() == Value::MATRIX)
{
Val = MatrixValue(1,1,m_Value);
return true;
}
return false;
}
TypeId
NakagamiPropagationLossModel::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::NakagamiPropagationLossModel")
.SetParent<PropagationLossModel> ()
.AddConstructor<NakagamiPropagationLossModel> ()
.AddAttribute ("Distance1",
"Beginning of the second distance field. Default is 80m.",
DoubleValue (80.0),
MakeDoubleAccessor (&NakagamiPropagationLossModel::m_distance1),
MakeDoubleChecker<double> ())
.AddAttribute ("Distance2",
"Beginning of the third distance field. Default is 200m.",
DoubleValue (200.0),
MakeDoubleAccessor (&NakagamiPropagationLossModel::m_distance2),
MakeDoubleChecker<double> ())
.AddAttribute ("m0",
"m0 for distances smaller than Distance1. Default is 1.5.",
DoubleValue (1.5),
MakeDoubleAccessor (&NakagamiPropagationLossModel::m_m0),
MakeDoubleChecker<double> ())
.AddAttribute ("m1",
"m1 for distances smaller than Distance2. Default is 0.75.",
DoubleValue (0.75),
MakeDoubleAccessor (&NakagamiPropagationLossModel::m_m1),
MakeDoubleChecker<double> ())
.AddAttribute ("m2",
"m2 for distances greater than Distance2. Default is 0.75.",
DoubleValue (0.75),
MakeDoubleAccessor (&NakagamiPropagationLossModel::m_m2),
MakeDoubleChecker<double> ())
.AddAttribute ("ErlangRv",
"Access to the underlying ErlangRandomVariable",
StringValue ("ns3::ErlangRandomVariable"),
MakePointerAccessor (&NakagamiPropagationLossModel::m_erlangRandomVariable),
MakePointerChecker<ErlangRandomVariable> ())
.AddAttribute ("GammaRv",
"Access to the underlying GammaRandomVariable",
StringValue ("ns3::GammaRandomVariable"),
MakePointerAccessor (&NakagamiPropagationLossModel::m_gammaRandomVariable),
MakePointerChecker<GammaRandomVariable> ());
;
return tid;
}
TypeId
ConstantSpeedPropagationDelayModel::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::ConstantSpeedPropagationDelayModel")
.SetParent<PropagationDelayModel> ()
.AddConstructor<ConstantSpeedPropagationDelayModel> ()
.AddAttribute ("Speed", "The speed (m/s)",
DoubleValue (300000000.0),
MakeDoubleAccessor (&ConstantSpeedPropagationDelayModel::m_speed),
MakeDoubleChecker<double> ())
;
return tid;
}
TypeId
FixedRssLossModel::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::FixedRssLossModel")
.SetParent<PropagationLossModel> ()
.AddConstructor<FixedRssLossModel> ()
.AddAttribute ("Rss", "The fixed receiver Rss.",
DoubleValue (-150.0),
MakeDoubleAccessor (&FixedRssLossModel::m_rss),
MakeDoubleChecker<double> ())
;
return tid;
}
TypeId
MatrixPropagationLossModel::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::MatrixPropagationLossModel")
.SetParent<PropagationLossModel> ()
.AddConstructor<MatrixPropagationLossModel> ()
.AddAttribute ("DefaultLoss", "The default value for propagation loss, dB.",
DoubleValue (std::numeric_limits<double>::max ()),
MakeDoubleAccessor (&MatrixPropagationLossModel::m_default),
MakeDoubleChecker<double> ())
;
return tid;
}
/*virtual*/ void DiscrepancyNorm::Deserialize (const std::string& serialization_data) {
std::stringstream ss(serialization_data);
try {
ss >> _factor >> _inplace;
Arguments params = GetParameterSignature();
DoubleValue(params[0]).SetData (_factor);
BoolValue(params[1]).SetData (_inplace);
Initialize (params);
} catch (...) {
throw exception::DeserializationException("Edge/DiscrepancyNorm deserialization failed.");
}
}
TypeId
IdealWifiManager::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::IdealWifiManager")
.SetParent<WifiRemoteStationManager> ()
.AddConstructor<IdealWifiManager> ()
.AddAttribute ("BerThreshold",
"The maximum Bit Error Rate acceptable at any transmission mode",
DoubleValue (10e-6),
MakeDoubleAccessor (&IdealWifiManager::m_ber),
MakeDoubleChecker<double> ())
;
return tid;
}
TypeId
RangePropagationLossModel::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::RangePropagationLossModel")
.SetParent<PropagationLossModel> ()
.AddConstructor<RangePropagationLossModel> ()
.AddAttribute ("MaxRange",
"Maximum Transmission Range (meters)",
DoubleValue (250),
MakeDoubleAccessor (&RangePropagationLossModel::m_range),
MakeDoubleChecker<double> ())
;
return tid;
}
void
LinkControlHelper::setErrorRate(Ptr<Node> node1, Ptr<Node> node2, double errorRate)
{
NS_LOG_FUNCTION(node1 << node2 << errorRate);
NS_ASSERT(node1 != nullptr && node2 != nullptr);
NS_ASSERT(errorRate <= 1.0);
Ptr<ndn::L3Protocol> ndn1 = node1->GetObject<ndn::L3Protocol>();
Ptr<ndn::L3Protocol> ndn2 = node2->GetObject<ndn::L3Protocol>();
NS_ASSERT(ndn1 != nullptr && ndn2 != nullptr);
// iterate over all faces to find the right one
for (const auto& face : ndn1->getForwarder()->getFaceTable()) {
auto transport = dynamic_cast<NetDeviceTransport*>(face.getTransport());
if (transport == nullptr)
continue;
Ptr<PointToPointNetDevice> nd1 = transport->GetNetDevice()->GetObject<PointToPointNetDevice>();
if (nd1 == nullptr)
continue;
Ptr<Channel> channel = nd1->GetChannel();
if (channel == nullptr)
continue;
Ptr<PointToPointChannel> ppChannel = DynamicCast<PointToPointChannel>(channel);
Ptr<NetDevice> nd2 = ppChannel->GetDevice(0);
if (nd2->GetNode() == node1)
nd2 = ppChannel->GetDevice(1);
if (nd2->GetNode() == node2) {
ObjectFactory errorFactory("ns3::RateErrorModel");
errorFactory.Set("ErrorUnit", StringValue("ERROR_UNIT_PACKET"));
errorFactory.Set("ErrorRate", DoubleValue(errorRate));
if (errorRate <= 0) {
errorFactory.Set("IsEnabled", BooleanValue(false));
}
nd1->SetAttribute("ReceiveErrorModel", PointerValue(errorFactory.Create<ErrorModel>()));
nd2->SetAttribute("ReceiveErrorModel", PointerValue(errorFactory.Create<ErrorModel>()));
return;
}
}
NS_FATAL_ERROR("There is no link to fail between the requested nodes");
}
TypeId
ThreeLogDistancePropagationLossModel::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::ThreeLogDistancePropagationLossModel")
.SetParent<PropagationLossModel> ()
.AddConstructor<ThreeLogDistancePropagationLossModel> ()
.AddAttribute ("Distance0",
"Beginning of the first (near) distance field",
DoubleValue (1.0),
MakeDoubleAccessor (&ThreeLogDistancePropagationLossModel::m_distance0),
MakeDoubleChecker<double> ())
.AddAttribute ("Distance1",
"Beginning of the second (middle) distance field.",
DoubleValue (200.0),
MakeDoubleAccessor (&ThreeLogDistancePropagationLossModel::m_distance1),
MakeDoubleChecker<double> ())
.AddAttribute ("Distance2",
"Beginning of the third (far) distance field.",
DoubleValue (500.0),
MakeDoubleAccessor (&ThreeLogDistancePropagationLossModel::m_distance2),
MakeDoubleChecker<double> ())
.AddAttribute ("Exponent0",
"The exponent for the first field.",
DoubleValue (1.9),
MakeDoubleAccessor (&ThreeLogDistancePropagationLossModel::m_exponent0),
MakeDoubleChecker<double> ())
.AddAttribute ("Exponent1",
"The exponent for the second field.",
DoubleValue (3.8),
MakeDoubleAccessor (&ThreeLogDistancePropagationLossModel::m_exponent1),
MakeDoubleChecker<double> ())
.AddAttribute ("Exponent2",
"The exponent for the third field.",
DoubleValue (3.8),
MakeDoubleAccessor (&ThreeLogDistancePropagationLossModel::m_exponent2),
MakeDoubleChecker<double> ())
.AddAttribute ("ReferenceLoss",
"The reference loss at distance d0 (dB). (Default is Friis at 1m with 5.15 GHz)",
DoubleValue (46.6777),
MakeDoubleAccessor (&ThreeLogDistancePropagationLossModel::m_referenceLoss),
MakeDoubleChecker<double> ())
;
return tid;
}
MagicNumbersCheck::MagicNumbersCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context),
IgnoreAllFloatingPointValues(
Options.get("IgnoreAllFloatingPointValues", false)),
IgnorePowersOf2IntegerValues(
Options.get("IgnorePowersOf2IntegerValues", false)) {
// Process the set of ignored integer values.
const std::vector<std::string> IgnoredIntegerValuesInput =
utils::options::parseStringList(
Options.get("IgnoredIntegerValues", DefaultIgnoredIntegerValues));
IgnoredIntegerValues.resize(IgnoredIntegerValuesInput.size());
llvm::transform(IgnoredIntegerValuesInput, IgnoredIntegerValues.begin(),
[](const std::string &Value) { return std::stoll(Value); });
llvm::sort(IgnoredIntegerValues);
if (!IgnoreAllFloatingPointValues) {
// Process the set of ignored floating point values.
const std::vector<std::string> IgnoredFloatingPointValuesInput =
utils::options::parseStringList(Options.get(
"IgnoredFloatingPointValues", DefaultIgnoredFloatingPointValues));
IgnoredFloatingPointValues.reserve(IgnoredFloatingPointValuesInput.size());
IgnoredDoublePointValues.reserve(IgnoredFloatingPointValuesInput.size());
for (const auto &InputValue : IgnoredFloatingPointValuesInput) {
llvm::APFloat FloatValue(llvm::APFloat::IEEEsingle());
FloatValue.convertFromString(InputValue, DefaultRoundingMode);
IgnoredFloatingPointValues.push_back(FloatValue.convertToFloat());
llvm::APFloat DoubleValue(llvm::APFloat::IEEEdouble());
DoubleValue.convertFromString(InputValue, DefaultRoundingMode);
IgnoredDoublePointValues.push_back(DoubleValue.convertToDouble());
}
llvm::sort(IgnoredFloatingPointValues.begin(),
IgnoredFloatingPointValues.end());
llvm::sort(IgnoredDoublePointValues.begin(),
IgnoredDoublePointValues.end());
}
}
void
LenaPssFfMacSchedulerTestCase2::DoRun (void)
{
if (!m_errorModelEnabled)
{
Config::SetDefault ("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue (false));
Config::SetDefault ("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue (false));
}
Config::SetDefault ("ns3::LteHelper::UseIdealRrc", BooleanValue (true));
Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();
Ptr<PointToPointEpcHelper> epcHelper = CreateObject<PointToPointEpcHelper> ();
lteHelper->SetEpcHelper (epcHelper);
Ptr<Node> pgw = epcHelper->GetPgwNode ();
// Create a single RemoteHost
NodeContainer remoteHostContainer;
remoteHostContainer.Create (1);
Ptr<Node> remoteHost = remoteHostContainer.Get (0);
InternetStackHelper internet;
internet.Install (remoteHostContainer);
// Create the Internet
PointToPointHelper p2ph;
p2ph.SetDeviceAttribute ("DataRate", DataRateValue (DataRate ("100Gb/s")));
p2ph.SetDeviceAttribute ("Mtu", UintegerValue (1500));
p2ph.SetChannelAttribute ("Delay", TimeValue (Seconds (0.001)));
NetDeviceContainer internetDevices = p2ph.Install (pgw, remoteHost);
Ipv4AddressHelper ipv4h;
ipv4h.SetBase ("1.0.0.0", "255.0.0.0");
Ipv4InterfaceContainer internetIpIfaces = ipv4h.Assign (internetDevices);
// interface 0 is localhost, 1 is the p2p device
Ipv4Address remoteHostAddr = internetIpIfaces.GetAddress (1);
Ipv4StaticRoutingHelper ipv4RoutingHelper;
Ptr<Ipv4StaticRouting> remoteHostStaticRouting = ipv4RoutingHelper.GetStaticRouting (remoteHost->GetObject<Ipv4> ());
remoteHostStaticRouting->AddNetworkRouteTo (Ipv4Address ("7.0.0.0"), Ipv4Mask ("255.0.0.0"), 1);
// LogComponentDisableAll (LOG_LEVEL_ALL);
//LogComponentEnable ("LenaTestPssFfMacCheduler", LOG_LEVEL_ALL);
lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::FriisSpectrumPropagationLossModel"));
// Create Nodes: eNodeB and UE
NodeContainer enbNodes;
NodeContainer ueNodes;
enbNodes.Create (1);
ueNodes.Create (m_nUser);
// Install Mobility Model
MobilityHelper mobility;
mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
mobility.Install (enbNodes);
mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
mobility.Install (ueNodes);
// Create Devices and install them in the Nodes (eNB and UE)
NetDeviceContainer enbDevs;
NetDeviceContainer ueDevs;
lteHelper->SetSchedulerType ("ns3::PssFfMacScheduler");
enbDevs = lteHelper->InstallEnbDevice (enbNodes);
ueDevs = lteHelper->InstallUeDevice (ueNodes);
Ptr<LteEnbNetDevice> lteEnbDev = enbDevs.Get (0)->GetObject<LteEnbNetDevice> ();
Ptr<LteEnbPhy> enbPhy = lteEnbDev->GetPhy ();
enbPhy->SetAttribute ("TxPower", DoubleValue (30.0));
enbPhy->SetAttribute ("NoiseFigure", DoubleValue (5.0));
// Set UEs' position and power
for (int i = 0; i < m_nUser; i++)
{
Ptr<ConstantPositionMobilityModel> mm = ueNodes.Get (i)->GetObject<ConstantPositionMobilityModel> ();
mm->SetPosition (Vector (m_dist.at (i), 0.0, 0.0));
Ptr<LteUeNetDevice> lteUeDev = ueDevs.Get (i)->GetObject<LteUeNetDevice> ();
Ptr<LteUePhy> uePhy = lteUeDev->GetPhy ();
uePhy->SetAttribute ("TxPower", DoubleValue (23.0));
uePhy->SetAttribute ("NoiseFigure", DoubleValue (9.0));
}
// Install the IP stack on the UEs
internet.Install (ueNodes);
Ipv4InterfaceContainer ueIpIface;
ueIpIface = epcHelper->AssignUeIpv4Address (NetDeviceContainer (ueDevs));
// Assign IP address to UEs
for (uint32_t u = 0; u < ueNodes.GetN (); ++u)
{
Ptr<Node> ueNode = ueNodes.Get (u);
// Set the default gateway for the UE
Ptr<Ipv4StaticRouting> ueStaticRouting = ipv4RoutingHelper.GetStaticRouting (ueNode->GetObject<Ipv4> ());
ueStaticRouting->SetDefaultRoute (epcHelper->GetUeDefaultGatewayAddress (), 1);
}
// Attach a UE to a eNB
lteHelper->Attach (ueDevs, enbDevs.Get (0));
// Activate an EPS bearer on all UEs
for (uint32_t u = 0; u < ueNodes.GetN (); ++u)
{
Ptr<NetDevice> ueDevice = ueDevs.Get (u);
GbrQosInformation qos;
qos.gbrDl = (m_packetSize.at (u) + 32) * (1000 / m_interval) * 8; // bit/s, considering IP, UDP, RLC, PDCP header size
qos.gbrUl = (m_packetSize.at (u) + 32) * (1000 / m_interval) * 8;
qos.mbrDl = qos.gbrDl;
qos.mbrUl = qos.gbrUl;
enum EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
EpsBearer bearer (q, qos);
lteHelper->ActivateDedicatedEpsBearer (ueDevice, bearer, EpcTft::Default ());
}
// Install downlind and uplink applications
uint16_t dlPort = 1234;
uint16_t ulPort = 2000;
PacketSinkHelper dlPacketSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), dlPort));
PacketSinkHelper ulPacketSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), ulPort));
ApplicationContainer clientApps;
ApplicationContainer serverApps;
for (uint32_t u = 0; u < ueNodes.GetN (); ++u)
{
++ulPort;
serverApps.Add (dlPacketSinkHelper.Install (ueNodes.Get (u))); // receive packets from remotehost
serverApps.Add (ulPacketSinkHelper.Install (remoteHost)); // receive packets from UEs
UdpClientHelper dlClient (ueIpIface.GetAddress (u), dlPort); // uplink packets generator
dlClient.SetAttribute ("Interval", TimeValue (MilliSeconds (m_interval)));
dlClient.SetAttribute ("MaxPackets", UintegerValue (1000000));
dlClient.SetAttribute ("PacketSize", UintegerValue (m_packetSize.at (u)));
UdpClientHelper ulClient (remoteHostAddr, ulPort); // downlink packets generator
ulClient.SetAttribute ("Interval", TimeValue (MilliSeconds (m_interval)));
ulClient.SetAttribute ("MaxPackets", UintegerValue (1000000));
ulClient.SetAttribute ("PacketSize", UintegerValue (m_packetSize.at (u)));
clientApps.Add (dlClient.Install (remoteHost));
clientApps.Add (ulClient.Install (ueNodes.Get (u)));
}
serverApps.Start (Seconds (0.030));
clientApps.Start (Seconds (0.030));
double statsStartTime = 0.04; // need to allow for RRC connection establishment + SRS
double statsDuration = 0.5;
double tolerance = 0.1;
Simulator::Stop (Seconds (statsStartTime + statsDuration - 0.0001));
lteHelper->EnableRlcTraces ();
Ptr<RadioBearerStatsCalculator> rlcStats = lteHelper->GetRlcStats ();
rlcStats->SetAttribute ("StartTime", TimeValue (Seconds (statsStartTime)));
rlcStats->SetAttribute ("EpochDuration", TimeValue (Seconds (statsDuration)));
Simulator::Run ();
/**
* Check that the downlink assignation is done in a "token bank fair queue" manner
*/
NS_LOG_INFO ("DL - Test with " << m_nUser << " user(s)");
std::vector <uint64_t> dlDataRxed;
for (int i = 0; i < m_nUser; i++)
{
// get the imsi
uint64_t imsi = ueDevs.Get (i)->GetObject<LteUeNetDevice> ()->GetImsi ();
// get the lcId
uint8_t lcId = 4;
dlDataRxed.push_back (rlcStats->GetDlRxData (imsi, lcId));
NS_LOG_INFO ("\tUser " << i << " dist " << m_dist.at (i) << " imsi " << imsi << " bytes rxed " << (double)dlDataRxed.at (i) << " thr " << (double)dlDataRxed.at (i) / statsDuration << " ref " << m_estThrPssDl.at (i));
}
for (int i = 0; i < m_nUser; i++)
{
NS_TEST_ASSERT_MSG_EQ_TOL ((double)dlDataRxed.at (i) / statsDuration, m_estThrPssDl.at (i), m_estThrPssDl.at (i) * tolerance, " Unfair Throughput!");
}
Simulator::Destroy ();
}
float TiXmlAttribute::FloatValue() const
{
return (float)(DoubleValue());
}
double WLOP::iterate()
{
Timer time;
initVertexes();
time.start("Sample Original Neighbor Tree!!!");
GlobalFun::computeBallNeighbors(samples, original,
para->getDouble("CGrid Radius"), box);
time.end();
time.start("Sample Sample Neighbor Tree");
GlobalFun::computeBallNeighbors(samples, NULL,
para->getDouble("CGrid Radius"), samples->bbox);
time.end();
if (nTimeIterated == 0)
{
if (para->getBool("Need Compute Density"))
{
double local_density_para = 0.95;
time.start("Original Original Neighbor Tree");
GlobalFun::computeBallNeighbors(original, NULL,
para->getDouble("CGrid Radius") * local_density_para, original->bbox);
time.end();
time.start("Compute Original Density");
original_density.assign(original->vn, 0);
computeDensity(true, para->getDouble("CGrid Radius") * local_density_para);
time.end();
}
}
if (para->getBool("Need Compute Density"))
{
time.start("Compute Density For Sample");
computeDensity(false, para->getDouble("CGrid Radius"));
time.end();
}
time.start("Sample Original Neighbor Tree!!!");
GlobalFun::computeBallNeighbors(samples, original,
para->getDouble("CGrid Radius"), box);
time.end();
time.start("Compute Average Term");
computeAverageTerm(samples, original);
time.end();
time.start("Compute Repulsion Term");
computeRepulsionTerm(samples);
time.end();
double mu = para->getDouble("Repulsion Mu");
Point3f c;
for(int i = 0; i < samples->vert.size(); i++)
{
CVertex& v = samples->vert[i];
c = v.P();
if (average_weight_sum[i] > 1e-20)
{
v.P() = average[i] / average_weight_sum[i];
}
if (repulsion_weight_sum[i] > 1e-20 && mu >= 0)
{
v.P() += repulsion[i] * (mu / repulsion_weight_sum[i]);
}
if (average_weight_sum[i] > 1e-20 && repulsion_weight_sum[i] > 1e-20 )
{
Point3f diff = v.P() - c;
double move_error = sqrt(diff.SquaredNorm());
error_x += move_error;
}
}
error_x = error_x / samples->vn;
para->setValue("Current Movement Error", DoubleValue(error_x));
cout << "****finished compute WLOP error: " << error_x << endl;
if (para->getBool("Need Compute PCA"))
{
time.start("Recompute PCA");
recomputePCA_Normal();
time.end();
}
return error_x;
}
int
main(int argc, char* argv[])
{
// setting default parameters for Wifi
// enable rts cts all the time.
Config::SetDefault ("ns3::WifiRemoteStationManager::RtsCtsThreshold", StringValue ("0"));
// disable fragmentation
Config::SetDefault ("ns3::WifiRemoteStationManager::FragmentationThreshold", StringValue ("2200"));
Config::SetDefault("ns3::WifiRemoteStationManager::NonUnicastMode",
StringValue("OfdmRate24Mbps"));
// setting default parameters for PointToPoint links and channels
Config::SetDefault("ns3::PointToPointNetDevice::DataRate", StringValue("1Mbps"));
Config::SetDefault("ns3::PointToPointChannel::Delay", StringValue("10ms"));
Config::SetDefault("ns3::DropTailQueue::MaxPackets", StringValue("20"));
std::uint32_t max_routers = 1;
std::string cSize = "100";
std::string cSplit = "75";
// Read optional command-line parameters (e.g., enable visualizer with ./waf --run=<> --visualize
CommandLine cmd;
cmd.AddValue("cSize", "Cache Size", cSize);
cmd.AddValue("cSplit", "Cache Split", cSplit);
cmd.AddValue("routers", "number of routers", max_routers);
cmd.Parse(argc, argv);
Packet::EnablePrinting ();
// Wifi config
WifiHelper wifi = WifiHelper::Default ();
// Nodes
NodeContainer sta_consumers;
NodeContainer sta_mobile_consumers;
NodeContainer ap;
NodeContainer routers;
NodeContainer producers;
// ??
NetDeviceContainer staDevs;
PacketSocketHelper packetSocket;
// 5 stationary consumers, 5 mobile, 4 APs and 1 router
sta_consumers.Create(3*max_routers);
sta_mobile_consumers.Create(7*max_routers);
ap.Create (5*max_routers);
routers.Create(max_routers);
producers.Create(1);
// give packet socket powers to nodes.
packetSocket.Install(sta_mobile_consumers);
packetSocket.Install(sta_consumers);
packetSocket.Install (ap);
// Wifi Config
NqosWifiMacHelper wifiMac = NqosWifiMacHelper::Default ();
YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default ();
YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();
wifiPhy.SetChannel (wifiChannel.Create ());
wifiPhy.Set("TxPowerStart", DoubleValue(5));
wifiPhy.Set("TxPowerEnd", DoubleValue(5));
Ssid ssid = Ssid ("wifi-default");
wifi.SetRemoteStationManager ("ns3::ArfWifiManager");
// setup stas.
wifiMac.SetType ("ns3::StaWifiMac",
"Ssid", SsidValue (ssid),
"ActiveProbing", BooleanValue (false));
// install wifi
wifi.Install(wifiPhy, wifiMac, sta_mobile_consumers);
wifi.Install(wifiPhy, wifiMac, sta_consumers);
// setup ap.
wifiMac.SetType ("ns3::ApWifiMac",
"Ssid", SsidValue (ssid));
wifi.Install (wifiPhy, wifiMac, ap);
// Mobility config -- Change max_routers value to change size of sim
int number_rows = sqrt(max_routers);
int x = 0;
int y = 0;
int pos_counter = 0;
Ptr<UniformRandomVariable> randomizerX = CreateObject<UniformRandomVariable>();
Ptr<UniformRandomVariable> randomizerY = CreateObject<UniformRandomVariable>();
MobilityHelper stationary_mobility;
stationary_mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
MobilityHelper mobility;
mobility.SetMobilityModel("ns3::GaussMarkovMobilityModel", "Bounds", BoxValue(Box (0, number_rows*10, 0, number_rows*10, 0, 0)),
"TimeStep", TimeValue(Seconds(1)));
// Place router in center of box
randomizerX->SetAttribute("Min", DoubleValue(5));
randomizerX->SetAttribute("Max", DoubleValue(5));
randomizerY->SetAttribute("Min", DoubleValue(5));
randomizerY->SetAttribute("Max", DoubleValue(5));
stationary_mobility.SetPositionAllocator("ns3::RandomBoxPositionAllocator", "X", PointerValue(randomizerX),
"Y", PointerValue(randomizerY));
// Install on routers
stationary_mobility.Install(producers.Get(0));
// p2p helper
PointToPointHelper p2p;
// for each row
for (int i=0; i < number_rows; i++)
{
x = i * 10 + 5;
// for each column
for (int j=0; j < number_rows; j++)
{
y = j * 10 + 5;
// Place router in center of box
randomizerX->SetAttribute("Min", DoubleValue(x));
randomizerX->SetAttribute("Max", DoubleValue(x));
randomizerY->SetAttribute("Min", DoubleValue(y));
randomizerY->SetAttribute("Max", DoubleValue(y));
stationary_mobility.SetPositionAllocator("ns3::RandomBoxPositionAllocator", "X", PointerValue(randomizerX),
"Y", PointerValue(randomizerY));
// Install on routers
stationary_mobility.Install(routers.Get(pos_counter));
// Set box (center +/-5)
randomizerX->SetAttribute("Min", DoubleValue(x-5));
randomizerX->SetAttribute("Max", DoubleValue(x+5));
randomizerY->SetAttribute("Min", DoubleValue(y-5));
randomizerY->SetAttribute("Max", DoubleValue(y+5));
// Connect router to previous if not 1
if (pos_counter == 0)
{
p2p.Install(routers.Get(0), producers.Get(0));
}
else // Otherwise connect to router behind you
{
p2p.Install(routers.Get(pos_counter), routers.Get(pos_counter-1));
}
// APs
for (int k=0; k < 5; k++)
{
stationary_mobility.SetPositionAllocator("ns3::RandomBoxPositionAllocator", "X", PointerValue(randomizerX),
"Y", PointerValue(randomizerY));
stationary_mobility.Install(ap.Get(pos_counter * 5 + k));
p2p.Install(routers.Get(pos_counter), ap.Get(pos_counter * 5 + k));
}
// Consumers (stationary)
for (int l=0; l < 3; l++)
{
stationary_mobility.SetPositionAllocator("ns3::RandomBoxPositionAllocator", "X", PointerValue(randomizerX),
"Y", PointerValue(randomizerY));
stationary_mobility.Install(sta_consumers.Get(pos_counter * 3 + l));
}
// Consumers (Mobile)
for (int m=0; m < 7; m++)
{
mobility.SetPositionAllocator("ns3::RandomBoxPositionAllocator", "X", PointerValue(randomizerX),
"Y", PointerValue(randomizerY));
mobility.Install(sta_mobile_consumers.Get(pos_counter * 7 + m));
}
// Keep track of overall position
pos_counter++;
}
}
// Install NDN stack on all nodes
ndn::StackHelper ndnHelper;
ndnHelper.SetDefaultRoutes(true);
ndnHelper.SetOldContentStore("ns3::ndn::cs::Splitcache",
"NormalPolicy", "ns3::ndn::cs::Lru",
"SpecialPolicy", "ns3::ndn::cs::Lfu",
"TotalCacheSize", cSize,
"Configure", cSplit);
// Percentage Special^
//ndnHelper.SetOldContentStore("ns3::ndn::cs::Lru");
ndnHelper.Install(ap);
ndnHelper.Install(routers);
ndnHelper.SetOldContentStore("ns3::ndn::cs::Nocache");
ndnHelper.Install(sta_consumers);
ndnHelper.Install(sta_mobile_consumers);
ndnHelper.Install(producers);
// Choosing forwarding strategy
ndn::StrategyChoiceHelper::Install(sta_consumers, "/", "/localhost/nfd/strategy/best-route");
ndn::StrategyChoiceHelper::Install(sta_mobile_consumers, "/", "/localhost/nfd/strategy/best-route");
ndn::StrategyChoiceHelper::Install(ap, "/", "/localhost/nfd/strategy/best-route");
ndn::StrategyChoiceHelper::Install(routers, "/", "/localhost/nfd/strategy/best-route");
ndn::StrategyChoiceHelper::Install(producers, "/", "/localhost/nfd/strategy/best-route");
// Installing applications
// Consumer (basic and special data)
ndn::AppHelper consumerHelper("ns3::ndn::ConsumerZipfMandelbrot");
consumerHelper.SetAttribute("NumberOfContents", StringValue("100")); // 10 different contents
// Consumer will request /prefix/0, /prefix/1, ...
// Basic consumers request basic data (and pumpkin spice coffee)
consumerHelper.SetPrefix("data/basic");
consumerHelper.SetAttribute("Frequency", StringValue("10")); // 1 interests a second
consumerHelper.Install(sta_consumers);
// Mobile consumers request special data only
consumerHelper.SetPrefix("data/special");
consumerHelper.SetAttribute("Frequency", StringValue("10")); // 2 interests a second
consumerHelper.Install(sta_mobile_consumers);
// Producer
ndn::AppHelper producerHelper("ns3::ndn::Producer");
// Producer will reply to all requests starting with /prefix
producerHelper.SetPrefix("/data");
producerHelper.SetAttribute("PayloadSize", StringValue("1024"));
producerHelper.SetAttribute("Freshness", TimeValue(Seconds(-1.0))); // unlimited freshness
producerHelper.Install(producers);
// Tracers 'n stuff
//AthstatsHelper athstats;
//athstats.EnableAthstats("athstats-sta", sta_mobile_consumers);
//athstats.EnableAthstats("athstats-sta", sta_consumers);
//athstats.EnableAthstats ("athstats-ap", ap);
ndn::AppDelayTracer::Install(sta_consumers, "app-delays-trace-stationary-03.txt");
ndn::AppDelayTracer::Install(sta_mobile_consumers, "app-delays-trace-mobile-03.txt");
ndn::CsTracer::Install(ap, "cs-trace-ap-03.txt", Seconds(1));
ndn::CsTracer::Install(routers, "cs-trace-routers-03.txt", Seconds(1));
// 10 min
Simulator::Stop(Seconds(600.0));
Simulator::Run();
Simulator::Destroy();
return 0;
}
void UpsamplingParaDlg::setThreshold(double _val)
{
m_paras->upsampling.setValue("Dist Threshold",DoubleValue(_val));
}
void UpsamplingParaDlg::setEdgeParameter(double _val)
{
m_paras->upsampling.setValue("Edge Parameter",DoubleValue(_val));
}
void UpsamplingParaDlg::getSnapShotIndex(double _val)
{
m_paras->glarea.setValue("Snapshot Index", DoubleValue(_val));
area->updateGL();
}
void UpsamplingParaDlg::getSigma(double _val)
{
m_paras->upsampling.setValue("Feature Sigma",DoubleValue(_val));
}
void InvertedPendulum::createCart() {
CollisionManager *cm = Physics::getCollisionManager();
PhysicsManager *pm = Physics::getPhysicsManager();
SimObject *box = pm->getPrototype(SimulationConstants::PROTOTYPE_BOX_BODY);
SimObject *cylinder = pm->getPrototype(SimulationConstants::PROTOTYPE_CYLINDER_BODY);
SimObject *servo = pm->getPrototype(SimulationConstants::PROTOTYPE_SERVO_MOTOR);
SimObject *fix = pm->getPrototype(SimulationConstants::PROTOTYPE_FIXED_JOINT);
SimObject *hinge = pm->getPrototype(SimulationConstants::PROTOTYPE_HINGE_JOINT);
SimObject *other;
INIT_PARAMS;
SimBody *body = dynamic_cast<SimBody*>(box->createCopy());
mAgent->addObject(body);
MAKE_CURRENT(body);
SETP("Name", mNamePrefix + "Cart");
SETP("Mass", QString::number(0.05));
SETP("Position", Vector3DValue(0.0, mHalfBodyWidth, 0.0).getValueAsString());
SETP("CenterOfMass", "(0,0,0)");
SETP("Orientation", "(0,0,0)");
SETP("Dynamic", "true");
SETP("Width", DoubleValue(mBodyLength).getValueAsString());
SETP("Height", DoubleValue(mHalfBodyWidth * 2.0).getValueAsString());
SETP("Depth", DoubleValue(mHalfBodyWidth * 2.0).getValueAsString());
SETP("Color", "red");
SETP("Material", "ABS");
other = cylinder->createCopy();
mAgent->addObject(other);
MAKE_CURRENT(other);
SETP("Name", mNamePrefix + "RightWheel");
SETP("Color", "(96, 96, 96)");
SETP("Position", Vector3DValue(mBodyLength / 2.0, -0.01, 0.0).getValueAsString());
SETP("Radius", "0.01");
SETP("Length", DoubleValue(mHalfBodyWidth * 2.0).getValueAsString());
SETP("Orientation", "(0, 0, 0)");
SETP("Mass", "0.01");
SETP("CenterOfMass", "(0, 0, 0)");
SETP("Dynamic", "true");
cm->disableCollisions(
dynamic_cast<SimBody*>(body)->getCollisionObjects(),
dynamic_cast<SimBody*>(other)->getCollisionObjects(),
true);
other = cylinder->createCopy();
mAgent->addObject(other);
MAKE_CURRENT(other);
SETP("Name", mNamePrefix + "LeftWheel");
SETP("Color", "(96, 96, 96)");
SETP("Position", Vector3DValue(-mBodyLength / 2.0, -0.01, 0.0).getValueAsString());
SETP("Radius", "0.01");
SETP("Length", DoubleValue(mHalfBodyWidth * 2.0).getValueAsString());
SETP("Orientation", "(0, 0, 0)");
SETP("Mass", "0.01");
SETP("CenterOfMass", "(0, 0, 0)");
SETP("Dynamic", "true");
other = servo->createCopy();
mAgent->addObject(other);
MAKE_CURRENT(other);
SETP("MaxForce", "10.0");
SETP("MaxTorque", "10.0");
PARAM(StringValue, other, "Name")->set("/RightMotor");
PARAM(Vector3DValue, other, "AxisPoint1")->set(mBodyLength / 2.0, -0.01, -1);
PARAM(Vector3DValue, other, "AxisPoint2")->set(mBodyLength / 2.0, -0.01, 1);
PARAM(BoolValue, other, "IsAngularMotor")->set(false);
PARAM(StringValue, other, "FirstBody")->set(mGroupPrefix + "/Cart");
PARAM(StringValue, other, "SecondBody")->set(mGroupPrefix + "/RightWheel");
other = servo->createCopy();
mAgent->addObject(other);
MAKE_CURRENT(other);
SETP("MaxForce", "10.0");
SETP("MaxTorque", "10.0");
PARAM(StringValue, other, "Name")->set("/LeftMotor");
PARAM(Vector3DValue, other, "AxisPoint1")->set(-mBodyLength / 2.0, -0.01, -1);
PARAM(Vector3DValue, other, "AxisPoint2")->set(-mBodyLength / 2.0, -0.01, 1);
PARAM(BoolValue, other, "IsAngularMotor")->set(false);
PARAM(StringValue, other, "FirstBody")->set(mGroupPrefix + "/Cart");
PARAM(StringValue, other, "SecondBody")->set(mGroupPrefix + "/LeftWheel");
SimObject *stick = box->createCopy();
mAgent->addObject(stick);
MAKE_CURRENT(stick);
SETP("Name", mNamePrefix + "Stick");
SETP("Mass", QString::number(0.00002));
SETP("Position", Vector3DValue(0.0, mHalfBodyWidth * 2.0 + mStickLength / 2.0, 0.0).getValueAsString());
SETP("CenterOfMass", "(0,0,0)");
SETP("Orientation", "(0,0,0)");
SETP("Dynamic", "true");
SETP("Width", DoubleValue(0.005).getValueAsString());
SETP("Height", DoubleValue(mStickLength).getValueAsString());
SETP("Depth", DoubleValue(mHalfBodyWidth * 2.0).getValueAsString());
SETP("Color", "blue");
other = hinge->createCopy();
mAgent->addObject(other);
PARAM(StringValue, other, "Name")->set("/StickToBody");
PARAM(Vector3DValue, other, "AxisPoint1")->set(0, mHalfBodyWidth * 2.0, -1);
PARAM(Vector3DValue, other, "AxisPoint2")->set(0, mHalfBodyWidth * 2.0, 1);
PARAM(StringValue, other, "FirstBody")->set(mGroupPrefix + "/Cart");
PARAM(StringValue, other, "SecondBody")->set(mGroupPrefix + "/Stick");
SimObject *bob = cylinder->createCopy();
mAgent->addObject(bob);
MAKE_CURRENT(bob);
SETP("Name", mNamePrefix + "Bob");
SETP("Position", Vector3DValue(0, mHalfBodyWidth * 2.0 + mStickLength, 0.0).getValueAsString());
SETP("Radius", "0.01");
SETP("Length", DoubleValue(mHalfBodyWidth * 2.0).getValueAsString());
SETP("Orientation", "(0, 0, 0)");
SETP("Mass", "0.0005");
SETP("CenterOfMass", "(0, 0, 0)");
SETP("Dynamic", "true");
SETP("Color", "blue");
other = fix->createCopy();
mAgent->addObject(other);
PARAM(StringValue, other, "Name")->set("/BobFix");
PARAM(StringValue, other, "FirstBody")->set(mGroupPrefix + "/Stick");
PARAM(StringValue, other, "SecondBody")->set(mGroupPrefix + "/Bob");
cm->disableCollisions(
dynamic_cast<SimBody*>(body)->getCollisionObjects(),
dynamic_cast<SimBody*>(stick)->getCollisionObjects(),
true);
cm->disableCollisions(
dynamic_cast<SimBody*>(stick)->getCollisionObjects(),
dynamic_cast<SimBody*>(bob)->getCollisionObjects(),
true);
}
JakesPropagationLossModel::JakesPropagationLossModel()
{
m_uniformVariable = CreateObject<UniformRandomVariable> ();
m_uniformVariable->SetAttribute ("Min", DoubleValue (-1.0 * PI));
m_uniformVariable->SetAttribute ("Max", DoubleValue (PI));
}
int
main(int argc, char* argv[])
{
// Read optional command-line parameters (e.g., enable visualizer with ./waf --run=<> --visualize
CommandLine cmd;
cmd.Parse(argc, argv);
AnnotatedTopologyReader topologyReader("", 1);
topologyReader.SetFileName("src/ndnSIM/examples/topologies/Geant2012.txt");
topologyReader.Read();
// topologyReader.ApplySettings();
topologyReader.SaveGraphviz("src/ndnSIM/examples/topologies/GeantGraph.dot");
// Install NDN stack on all nodes
ndn::StackHelper ndnHelper;
ndnHelper.disableRibManager();
//ndnHelper.disableFaceManager();
ndnHelper.InstallAll();
// Choosing forwarding strategy for all
ndn::StrategyChoiceHelper::InstallAll("/", "/localhost/nfd/strategy/multicast");
// Installing applications
////////////////////////////////////////////////////////////////
//from 5 file logs, i assign to five consumer each ONE file//
///////////////////////////////////////////////////////////////
size_t nConsumers = 5;
// Consumer (DE-4, DK-2, CH-8, NL-0, CZ-5)
std::string consArray[] ={"id4", "id2", "id8", "id0", "id5"} ;
NS_LOG_UNCOND ("The "<<nConsumers<<" consumers are: ");
for (size_t i = 0; i < nConsumers; i++) {
NS_LOG_UNCOND (consArray[i]);
}
// Producers (FI-37, ES-25, GR-15)
size_t nProducers = 3;
string prodArray[] = {"id37", "id25", "id15"};
NS_LOG_UNCOND ("The "<<nProducers<<" producers are: ");
for (size_t i = 0; i < nProducers; i++) {
NS_LOG_UNCOND (prodArray[i]);
}
ndn::AppHelper consumerHelper("ns3::ndn::ConsumerCbr");
std:: string consumerPath= "/home/ali/GitHub/Datasets/test/fifty/consumers/5F-5C-3P/";
size_t consIndex=0;
size_t fileCounter=0;
DIR *dir;
struct dirent *ent;
//This is to avoid collision !
double l = 0;
double s = 0.01;
Ptr<UniformRandomVariable> uniVar;
uniVar=CreateObject<UniformRandomVariable> ();
uniVar->SetAttribute ("Min", DoubleValue (l));
uniVar->SetAttribute ("Max", DoubleValue (s));
if ((dir = opendir (consumerPath.c_str())) != NULL) {
/* Go read each of files in this directory */
const char* invalidFileName1 = ".";
const char* invalidFileName2 = "..";
while ((ent = readdir (dir)) != NULL) {
if (ent->d_name != invalidFileName1 && ent->d_name != invalidFileName2){
//avoid . and ..
std::string str1 = ent->d_name;
if (str1[0]!='U'){
continue;
}
std::string path = consumerPath + ent->d_name;
//NS_LOG_UNCOND("path.c_str() = "<<path.c_str());
ifstream inFile(path.c_str());
NS_LOG_UNCOND ("for node "<<consArray[consIndex]<<", inFile is "<< path.c_str());
string line;
if (inFile.is_open())
{
//NS_LOG_UNCOND ("salam!");
while(getline (inFile,line))
{
consumerHelper.SetPrefix(line);
//NS_LOG_UNCOND ("file line = "<<line);
consumerHelper.SetAttribute("Frequency", StringValue("1")); // 1 interests per five second
//we care about collision!
consumerHelper.Install(Names::Find<Node>(consArray[consIndex])).Start (Seconds(consStart + uniVar->GetValue(0.0, 0.01)));
}//while
inFile.close();
consIndex++;
++fileCounter;
if(fileCounter==5){
break;
}
}
else{
NS_LOG_UNCOND("UNABLE TO OPEN FILE "<<ent->d_name);
}
}
}//Dirent while
}//dirent
// Producers (FI-37, ES-25, GR-15)
std:: string producerPath= "/home/ali/GitHub/Datasets/test/fifty/producers/server_dataset/5F-5C-3P/";
ndn::AppHelper producerHelper("ns3::ndn::Producer");
// Producer will reply to all requests starting with /videos/myvideos/video1
producerHelper.SetPrefix("/");
producerHelper.SetAttribute("PayloadSize", StringValue("1024"));
producerHelper.Install(Names::Find<Node>(prodArray[0])).Start (Seconds(prodStart));
producerHelper.Install(Names::Find<Node>(prodArray[1])).Start (Seconds(prodStart));
producerHelper.Install(Names::Find<Node>(prodArray[2])).Start (Seconds(prodStart));
//install advertiser app on the server
consumerHelper.SetAttribute("Frequency", StringValue("0.2")); // 1 advert per 5 second
consumerHelper.SetPrefix ("/ContentAdVert/FE");
consumerHelper.Install(Names::Find<Node>(prodArray[0])).Start (Seconds(advertStart));
consumerHelper.SetPrefix ("/ContentAdVert/ES");
consumerHelper.Install(Names::Find<Node>(prodArray[1])).Start (Seconds(advertStart + uniVar->GetValue(0.0, 0.001)));
consumerHelper.SetPrefix ("/ContentAdVert/GR");
consumerHelper.Install(Names::Find<Node>(prodArray[2])).Start (Seconds(advertStart + uniVar->GetValue(0.0, 0.001)));
// Schedule simulation time and run the simulation
Simulator::Stop(Seconds(simulationTime));
Simulator::Run();
Simulator::Destroy();
return 0;
}//ns3::main
void
LenaMimoTestCase::DoRun (void)
{
NS_LOG_FUNCTION (this << GetName ());
Config::SetDefault ("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue (false));
Config::SetDefault ("ns3::LteAmc::AmcModel", EnumValue (LteAmc::PiroEW2010));
Config::SetDefault ("ns3::LteHelper::UseIdealRrc", BooleanValue (m_useIdealRrc));
/**
* Initialize Simulation Scenario: 1 eNB and m_nUser UEs
*/
Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();
Config::SetDefault ("ns3::RrFfMacScheduler::HarqEnabled", BooleanValue (false));
Config::SetDefault ("ns3::PfFfMacScheduler::HarqEnabled", BooleanValue (false));
// lteHelper->SetSchedulerAttribute ("HarqEnabled", BooleanValue (false));
lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::HybridBuildingsPropagationLossModel"));
lteHelper->SetPathlossModelAttribute ("ShadowSigmaOutdoor", DoubleValue (0.0));
lteHelper->SetPathlossModelAttribute ("ShadowSigmaIndoor", DoubleValue (0.0));
lteHelper->SetPathlossModelAttribute ("ShadowSigmaExtWalls", DoubleValue (0.0));
// lteHelper->EnableLogComponents ();
// Create Nodes: eNodeB and UE
NodeContainer enbNodes;
NodeContainer ueNodes;
enbNodes.Create (1);
ueNodes.Create (1);
// Install Mobility Model
MobilityHelper mobility;
mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
mobility.Install (enbNodes);
BuildingsHelper::Install (enbNodes);
mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
mobility.Install (ueNodes);
BuildingsHelper::Install (ueNodes);
// Create Devices and install them in the Nodes (eNB and UE)
NetDeviceContainer enbDevs;
NetDeviceContainer ueDevs;
lteHelper->SetSchedulerType (m_schedulerType);
enbDevs = lteHelper->InstallEnbDevice (enbNodes);
ueDevs = lteHelper->InstallUeDevice (ueNodes);
// Attach a UE to a eNB
lteHelper->Attach (ueDevs, enbDevs.Get (0));
// Activate an EPS bearer
enum EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
EpsBearer bearer (q);
lteHelper->ActivateDataRadioBearer (ueDevs, bearer);
Ptr<LteEnbNetDevice> lteEnbDev = enbDevs.Get (0)->GetObject<LteEnbNetDevice> ();
Ptr<LteEnbPhy> enbPhy = lteEnbDev->GetPhy ();
enbPhy->SetAttribute ("TxPower", DoubleValue (46.0));
enbPhy->SetAttribute ("NoiseFigure", DoubleValue (5.0));
Ptr<MobilityModel> mmenb = enbNodes.Get (0)->GetObject<MobilityModel> ();
mmenb->SetPosition (Vector (0.0, 0.0, 30.0));
// Set UE's position and power
Ptr<MobilityModel> mmue = ueNodes.Get (0)->GetObject<MobilityModel> ();
mmue->SetPosition (Vector (m_dist, 0.0, 1.0));
Ptr<LteUeNetDevice> lteUeDev = ueDevs.Get (0)->GetObject<LteUeNetDevice> ();
Ptr<LteUePhy> uePhy = lteUeDev->GetPhy ();
uePhy->SetAttribute ("TxPower", DoubleValue (23.0));
uePhy->SetAttribute ("NoiseFigure", DoubleValue (9.0));
// need to allow for RRC connection establishment + SRS before enabling traces
lteHelper->EnableRlcTraces ();
lteHelper->EnableMacTraces ();
double simulationTime = 0.6;
double tolerance = 0.1;
uint8_t rnti = 1;
Ptr<LteEnbNetDevice> enbNetDev = enbDevs.Get (0)->GetObject<LteEnbNetDevice> ();
PointerValue ptrval;
enbNetDev->GetAttribute ("FfMacScheduler", ptrval);
Ptr<PfFfMacScheduler> pfsched;
Ptr<RrFfMacScheduler> rrsched;
if (m_schedulerType.compare ("ns3::RrFfMacScheduler") == 0)
{
rrsched = ptrval.Get<RrFfMacScheduler> ();
if (rrsched == 0)
{
NS_FATAL_ERROR ("No RR Scheduler available");
}
Simulator::Schedule (Seconds (0.2), &RrFfMacScheduler::TransmissionModeConfigurationUpdate, rrsched, rnti, 1);
Simulator::Schedule (Seconds (0.4), &RrFfMacScheduler::TransmissionModeConfigurationUpdate, rrsched, rnti, 2);
}
else if (m_schedulerType.compare ("ns3::PfFfMacScheduler") == 0)
{
pfsched = ptrval.Get<PfFfMacScheduler> ();
if (pfsched == 0)
{
NS_FATAL_ERROR ("No Pf Scheduler available");
}
Simulator::Schedule (Seconds (0.2), &PfFfMacScheduler::TransmissionModeConfigurationUpdate, pfsched, rnti, 1);
Simulator::Schedule (Seconds (0.4), &PfFfMacScheduler::TransmissionModeConfigurationUpdate, pfsched, rnti, 2);
}
else
{
NS_FATAL_ERROR ("Scheduler not supported by this test");
}
Ptr<RadioBearerStatsCalculator> rlcStats = lteHelper->GetRlcStats ();
rlcStats->SetAttribute ("EpochDuration", TimeValue (Seconds (0.1)));
NS_LOG_INFO (m_schedulerType << " MIMO test:");
double sampleTime = 0.199999; // at 0.2 RlcStats are reset
for (uint8_t j = 0; j < m_estThrDl.size (); j ++)
{
NS_LOG_INFO ("\t test with user at distance " << m_dist << " time " << sampleTime);
// get the imsi
uint64_t imsi = ueDevs.Get (0)->GetObject<LteUeNetDevice> ()->GetImsi ();
uint8_t lcId = 3;
Time t = Seconds (sampleTime);
Simulator::Schedule(t, &LenaMimoTestCase::GetRlcBufferSample, this, rlcStats, imsi, lcId);
sampleTime += 0.2;
}
Simulator::Stop (Seconds (simulationTime));
Simulator::Run ();
Simulator::Destroy ();
NS_LOG_INFO ("Check consistency");
for (uint8_t i = 0; i < m_estThrDl.size (); i++)
{
NS_LOG_INFO ("interval " << i + 1 << ": bytes rxed " << (double)m_dlDataRxed.at (i) << " ref " << m_estThrDl.at (i));
NS_TEST_ASSERT_MSG_EQ_TOL ((double)m_dlDataRxed.at (i) , m_estThrDl.at (i), m_estThrDl.at (i) * tolerance, " Unfair Throughput!");
}
}
