27#include "ns3/buildings-module.h"
28#include "ns3/core-module.h"
29#include "ns3/mobility-module.h"
30#include "ns3/network-module.h"
31#include "ns3/spectrum-signal-parameters.h"
32#include "ns3/three-gpp-channel-model.h"
33#include "ns3/three-gpp-spectrum-propagation-loss-model.h"
34#include "ns3/three-gpp-v2v-propagation-loss-model.h"
35#include "ns3/uniform-planar-array.h"
78 Vector aPos = thisDevice->GetNode()->GetObject<
MobilityModel>()->GetPosition();
79 Vector bPos = otherDevice->GetNode()->GetObject<
MobilityModel>()->GetPosition();
82 Angles completeAngle(bPos, aPos);
85 thisAntenna->SetBeamformingVector(bf);
101 NS_LOG_DEBUG(
"Pathloss " << -propagationGainDb <<
" dB");
102 double propagationGainLinear = std::pow(10.0, (propagationGainDb) / 10.0);
103 *(params.txParams->psd) *= propagationGainLinear;
112 NS_LOG_DEBUG(
"Average rx power " << 10 * log10(
Sum(*rxPsd) * 180e3) <<
" dB");
116 const double kT_dBm_Hz = -174.0;
117 double kT_W_Hz = std::pow(10.0, (kT_dBm_Hz - 30) / 10.0);
118 double noiseFigureLinear = std::pow(10.0, params.noiseFigure / 10.0);
119 double noisePowerSpectralDensity = kT_W_Hz * noiseFigureLinear;
121 (*noisePsd) = noisePowerSpectralDensity;
128 f.open(
"example-output.txt", std::ios::out | std::ios::app);
130 << params.txMob->GetPosition().x <<
" " << params.txMob->GetPosition().y <<
" "
131 << params.rxMob->GetPosition().x <<
" " << params.rxMob->GetPosition().y <<
" "
132 << cond->GetLosCondition() <<
" "
133 << 10 * log10(
Sum(*rxPsd) /
Sum(*noisePsd)) <<
" "
134 << -propagationGainDb << std::endl;
146 std::ofstream outFile;
147 outFile.open(filename, std::ios_base::out | std::ios_base::trunc);
148 if (!outFile.is_open())
157 Box box = (*it)->GetBoundaries();
158 outFile <<
"set object " << index <<
" rect from " << box.
xMin <<
"," << box.
yMin <<
" to "
159 << box.
xMax <<
"," << box.
yMax << std::endl;
164main(
int argc,
char* argv[])
166 double frequency = 28.0e9;
167 double txPow_dbm = 30.0;
168 double noiseFigure = 9.0;
171 std::string scenario =
"V2V-Urban";
173 double subCarrierSpacing = 60e3;
177 cmd.AddValue(
"frequency",
"operating frequency in Hz", frequency);
178 cmd.AddValue(
"txPow",
"tx power in dBm", txPow_dbm);
179 cmd.AddValue(
"noiseFigure",
"noise figure in dB", noiseFigure);
180 cmd.AddValue(
"scenario",
"3GPP propagation scenario, V2V-Urban or V2V-Highway", scenario);
181 cmd.Parse(argc, argv);
215 if (scenario ==
"V2V-Urban")
221 double buildingSizeX = 250 - 3.5 * 2 - 3;
222 double buildingSizeY = 433 - 3.5 * 2 - 3;
223 double streetWidth = 20;
224 double buildingHeight = 10;
227 double maxAxisX = (buildingSizeX + streetWidth) * numBuildingsX;
228 double maxAxisY = (buildingSizeY + streetWidth) * numBuildingsY;
230 std::vector<Ptr<Building>> buildingVector;
231 for (
uint32_t buildingIdX = 0; buildingIdX < numBuildingsX; ++buildingIdX)
233 for (
uint32_t buildingIdY = 0; buildingIdY < numBuildingsY; ++buildingIdY)
238 building->SetBoundaries(
239 Box(buildingIdX * (buildingSizeX + streetWidth),
240 buildingIdX * (buildingSizeX + streetWidth) + buildingSizeX,
241 buildingIdY * (buildingSizeY + streetWidth),
242 buildingIdY * (buildingSizeY + streetWidth) + buildingSizeY,
245 building->SetNRoomsX(1);
246 building->SetNRoomsY(1);
247 building->SetNFloors(1);
248 buildingVector.push_back(building);
254 double vRx = vScatt / 2;
259 Waypoint(nextWaypoint, Vector(maxAxisX / 2 - streetWidth / 2, 1.0, 1.5)));
260 nextWaypoint +=
Seconds((maxAxisY - streetWidth) / 2 / vTx);
263 Vector(maxAxisX / 2 - streetWidth / 2, maxAxisY / 2 - streetWidth / 2, 1.5)));
264 nextWaypoint +=
Seconds((maxAxisX - streetWidth) / 2 / vTx);
266 Waypoint(nextWaypoint, Vector(0.0, maxAxisY / 2 - streetWidth / 2, 1.5)));
269 Waypoint(nextWaypoint, Vector(maxAxisX / 2 - streetWidth / 2, 0.0, 1.5)));
270 nextWaypoint +=
Seconds(maxAxisY / vRx);
272 Waypoint(nextWaypoint, Vector(maxAxisX / 2 - streetWidth / 2, maxAxisY, 1.5)));
283 else if (scenario ==
"V2V-Highway")
291 double vRx = vScatt / 2;
322 channelModel->SetAttribute(
"Scenario",
StringValue(scenario));
323 channelModel->SetAttribute(
"Frequency",
DoubleValue(frequency));
325 channelModel->SetAttribute(
"vScatt",
DoubleValue(vScatt));
340 double freqSubBand = frequency;
341 for (
uint32_t n = 0; n < numRb; ++n)
345 freqSubBand += subCarrierSpacing / 2;
347 freqSubBand += subCarrierSpacing / 2;
354 double txPow_w = std::pow(10., (txPow_dbm - 30) / 10);
355 double txPowDens = (txPow_w / (numRb * subCarrierSpacing));
356 (*txPsd) = txPowDens;
357 txParams->psd = txPsd->Copy();
359 for (
int i = 0; i < simTime / timeRes; i++)
367 f.open(
"example-output.txt", std::ios::out);
368 f <<
"Time[s] TxPosX[m] TxPosY[m] RxPosX[m] RxPosY[m] ChannelState SNR[dB] Pathloss[dB]"
Class holding the azimuth and inclination angles of spherical coordinates.
double yMax
The y coordinate of the top bound of the box.
double xMin
The x coordinate of the left bound of the box.
double yMin
The y coordinate of the bottom bound of the box.
double xMax
The x coordinate of the right bound of the box.
static void Install(Ptr< Node > node)
Install the MobilityBuildingInfo to a node.
Parse command-line arguments.
Mobility model for which the current speed does not change once it has been set and until it is set a...
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Keep track of the current position and velocity of an object.
keep track of a set of node pointers.
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
uint32_t AddDevice(Ptr< NetDevice > device)
Associate a NetDevice to this node.
void AggregateObject(Ptr< Object > other)
Aggregate two Objects together.
AttributeValue implementation for Pointer.
Smart pointer class similar to boost::intrusive_ptr.
static EventId Schedule(const Time &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
static void Destroy()
Execute the events scheduled with ScheduleDestroy().
static Time Now()
Return the current simulation virtual time.
static void Run()
Run the simulation.
Hold variables of type string.
Simulation virtual time values and global simulation resolution.
double GetSeconds() const
Get an approximation of the time stored in this instance in the indicated unit.
Hold an unsigned integer type.
Waypoint-based mobility model.
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
#define NS_LOG_ERROR(msg)
Use NS_LOG to output a message of level LOG_ERROR.
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Ptr< T > CreateObject(Args &&... args)
Create an object by type, with varying number of constructor parameters.
Ptr< T > CreateObjectWithAttributes(Args... args)
Allocate an Object on the heap and initialize with a set of attributes.
Ptr< T > Create(Ts &&... args)
Create class instances by constructors with varying numbers of arguments and return them by Ptr.
Time Seconds(double value)
Construct a Time in the indicated unit.
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Every class exported by the ns3 library is enclosed in the ns3 namespace.
std::vector< BandInfo > Bands
Container of BandInfo.
double Sum(const SpectrumValue &x)
params
Fit Fluctuating Two Ray model to the 3GPP TR 38.901 using the Anderson-Darling goodness-of-fit ##.
A structure that holds the parameters for the ComputeSnr function.
Ptr< PhasedArrayModel > txAntenna
the tx antenna array
Ptr< MobilityModel > rxMob
the rx mobility model
double noiseFigure
the noise figure in dB
Ptr< SpectrumSignalParameters > txParams
the params of the tx signal
Ptr< PhasedArrayModel > rxAntenna
the rx antenna array
Ptr< MobilityModel > txMob
the tx mobility model
The building block of a SpectrumModel.
double fc
center frequency
double fl
lower limit of subband
double fh
upper limit of subband
static Ptr< ChannelConditionModel > m_condModel
the ChannelConditionModel object
static Ptr< ThreeGppPropagationLossModel > m_propagationLossModel
the PropagationLossModel object
static void DoBeamforming(Ptr< NetDevice > thisDevice, Ptr< PhasedArrayModel > thisAntenna, Ptr< NetDevice > otherDevice)
Perform the beamforming using the DFT beamforming method.
static void ComputeSnr(const ComputeSnrParams ¶ms)
Compute the average SNR.
void PrintGnuplottableBuildingListToFile(std::string filename)
Generates a GNU-plottable file representing the buildings deployed in the scenario.
static Ptr< ThreeGppSpectrumPropagationLossModel > m_spectrumLossModel
the SpectrumPropagationLossModel object