A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
three-gpp-propagation-loss-model-test-suite.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2019 SIGNET Lab, Department of Information Engineering,
3 * University of Padova
4 *
5 * SPDX-License-Identifier: GPL-2.0-only
6 */
7
8#include "ns3/abort.h"
9#include "ns3/boolean.h"
10#include "ns3/channel-condition-model.h"
11#include "ns3/config.h"
12#include "ns3/constant-position-mobility-model.h"
13#include "ns3/constant-velocity-mobility-model.h"
14#include "ns3/double.h"
15#include "ns3/log.h"
16#include "ns3/mobility-helper.h"
17#include "ns3/simulator.h"
18#include "ns3/test.h"
19#include "ns3/three-gpp-propagation-loss-model.h"
20#include "ns3/three-gpp-v2v-propagation-loss-model.h"
21
22using namespace ns3;
23
24NS_LOG_COMPONENT_DEFINE("ThreeGppPropagationLossModelsTest");
25
26/**
27 * @ingroup propagation-tests
28 *
29 * Test case for the class ThreeGppRmaPropagationLossModel.
30 * It computes the pathloss between two nodes and compares it with the value
31 * obtained using the formula in 3GPP TR 38.901, Table 7.4.1-1.
32 */
33class ThreeGppRmaPropagationLossModelTestCase : public TestCase
34{
35 public:
36 /**
37 * Constructor
38 */
39 ThreeGppRmaPropagationLossModelTestCase();
40
41 /**
42 * Destructor
43 */
44 ~ThreeGppRmaPropagationLossModelTestCase() override;
45
46 private:
47 /**
48 * Build the simulation scenario and run the tests
49 */
50 void DoRun() override;
51
52 /**
53 * Struct containing the parameters for each test
54 */
55 struct TestVector
56 {
57 double m_distance; //!< 2D distance between UT and BS in meters
58 bool m_isLos; //!< if true LOS, if false NLOS
59 double m_frequency; //!< carrier frequency in Hz
60 double m_pt; //!< transmitted power in dBm
61 double m_pr; //!< received power in dBm
62 };
63
64 TestVectors<TestVector> m_testVectors; //!< array containing all the test vectors
65 double m_tolerance; //!< tolerance
66};
67
68ThreeGppRmaPropagationLossModelTestCase::ThreeGppRmaPropagationLossModelTestCase()
69 : TestCase("Test for the ThreeGppRmaPropagationLossModel class"),
70 m_testVectors(),
71 m_tolerance(5e-2)
72{
73}
74
78
79void
80ThreeGppRmaPropagationLossModelTestCase::DoRun()
81{
82 TestVector testVector;
83
84 testVector.m_distance = 10.0;
85 testVector.m_isLos = true;
86 testVector.m_frequency = 5.0e9;
87 testVector.m_pt = 0.0;
88 testVector.m_pr = -77.3784;
89 m_testVectors.Add(testVector);
90
91 testVector.m_distance = 100.0;
92 testVector.m_isLos = true;
93 testVector.m_frequency = 5.0e9;
94 testVector.m_pt = 0.0;
95 testVector.m_pr = -87.2965;
96 m_testVectors.Add(testVector);
97
98 testVector.m_distance = 1000.0;
99 testVector.m_isLos = true;
100 testVector.m_frequency = 5.0e9;
101 testVector.m_pt = 0.0;
102 testVector.m_pr = -108.5577;
103 m_testVectors.Add(testVector);
104
105 testVector.m_distance = 10000.0;
106 testVector.m_isLos = true;
107 testVector.m_frequency = 5.0e9;
108 testVector.m_pt = 0.0;
109 testVector.m_pr = -140.3896;
110 m_testVectors.Add(testVector);
111
112 testVector.m_distance = 10.0;
113 testVector.m_isLos = false;
114 testVector.m_frequency = 5.0e9;
115 testVector.m_pt = 0.0;
116 testVector.m_pr = -77.3784;
117 m_testVectors.Add(testVector);
118
119 testVector.m_distance = 100.0;
120 testVector.m_isLos = false;
121 testVector.m_frequency = 5.0e9;
122 testVector.m_pt = 0.0;
123 testVector.m_pr = -95.7718;
124 m_testVectors.Add(testVector);
125
126 testVector.m_distance = 1000.0;
127 testVector.m_isLos = false;
128 testVector.m_frequency = 5.0e9;
129 testVector.m_pt = 0.0;
130 testVector.m_pr = -133.5223;
131 m_testVectors.Add(testVector);
132
133 testVector.m_distance = 5000.0;
134 testVector.m_isLos = false;
135 testVector.m_frequency = 5.0e9;
136 testVector.m_pt = 0.0;
137 testVector.m_pr = -160.5169;
138 m_testVectors.Add(testVector);
139
140 // Create the nodes for BS and UT
141 NodeContainer nodes;
142 nodes.Create(2);
143
144 // Create the mobility models
145 Ptr<MobilityModel> a = CreateObject<ConstantPositionMobilityModel>();
146 nodes.Get(0)->AggregateObject(a);
147 Ptr<MobilityModel> b = CreateObject<ConstantPositionMobilityModel>();
148 nodes.Get(1)->AggregateObject(b);
149
150 // Use a deterministic channel condition model
151 Ptr<ChannelConditionModel> losCondModel = CreateObject<AlwaysLosChannelConditionModel>();
152 Ptr<ChannelConditionModel> nlosCondModel = CreateObject<NeverLosChannelConditionModel>();
153
154 // Create the propagation loss model
155 Ptr<ThreeGppRmaPropagationLossModel> lossModel =
156 CreateObject<ThreeGppRmaPropagationLossModel>();
157 lossModel->SetAttribute("ShadowingEnabled", BooleanValue(false)); // disable the shadow fading
158
159 for (const auto& testVector : m_testVectors)
160 {
161 Vector posBs = Vector(0.0, 0.0, 35.0);
162 Vector posUt = Vector(testVector.m_distance, 0.0, 1.5);
163
164 // set the LOS or NLOS condition
165 if (testVector.m_isLos)
166 {
167 lossModel->SetChannelConditionModel(losCondModel);
168 }
169 else
170 {
171 lossModel->SetChannelConditionModel(nlosCondModel);
172 }
173
174 a->SetPosition(posBs);
175 b->SetPosition(posUt);
176
177 lossModel->SetAttribute("Frequency", DoubleValue(testVector.m_frequency));
178 NS_TEST_EXPECT_MSG_EQ_TOL(lossModel->CalcRxPower(testVector.m_pt, a, b),
179 testVector.m_pr,
180 m_tolerance,
181 "Got unexpected rcv power");
182 }
183
184 Simulator::Destroy();
185}
186
187/**
188 * @ingroup propagation-tests
189 *
190 * Test case for the class ThreeGppUmaPropagationLossModel.
191 * It computes the pathloss between two nodes and compares it with the value
192 * obtained using the formula in 3GPP TR 38.901, Table 7.4.1-1.
193 */
194class ThreeGppUmaPropagationLossModelTestCase : public TestCase
195{
196 public:
197 /**
198 * Constructor
199 */
200 ThreeGppUmaPropagationLossModelTestCase();
201
202 /**
203 * Destructor
204 */
205 ~ThreeGppUmaPropagationLossModelTestCase() override;
206
207 private:
208 /**
209 * Build the simulation scenario and run the tests
210 */
211 void DoRun() override;
212
213 /**
214 * Struct containing the parameters for each test
215 */
216 struct TestVector
217 {
218 double m_distance; //!< 2D distance between UT and BS in meters
219 bool m_isLos; //!< if true LOS, if false NLOS
220 double m_frequency; //!< carrier frequency in Hz
221 double m_pt; //!< transmitted power in dBm
222 double m_pr; //!< received power in dBm
223 };
224
225 TestVectors<TestVector> m_testVectors; //!< array containing all the test vectors
226 double m_tolerance; //!< tolerance
227};
228
229ThreeGppUmaPropagationLossModelTestCase::ThreeGppUmaPropagationLossModelTestCase()
230 : TestCase("Test for the ThreeGppUmaPropagationLossModel class"),
231 m_testVectors(),
232 m_tolerance(5e-2)
233{
234}
235
239
240void
241ThreeGppUmaPropagationLossModelTestCase::DoRun()
242{
243 TestVector testVector;
244
245 testVector.m_distance = 10.0;
246 testVector.m_isLos = true;
247 testVector.m_frequency = 5.0e9;
248 testVector.m_pt = 0.0;
249 testVector.m_pr = -72.9380;
250 m_testVectors.Add(testVector);
251
252 testVector.m_distance = 100.0;
253 testVector.m_isLos = true;
254 testVector.m_frequency = 5.0e9;
255 testVector.m_pt = 0.0;
256 testVector.m_pr = -86.2362;
257 m_testVectors.Add(testVector);
258
259 testVector.m_distance = 1000.0;
260 testVector.m_isLos = true;
261 testVector.m_frequency = 5.0e9;
262 testVector.m_pt = 0.0;
263 testVector.m_pr = -109.7252;
264 m_testVectors.Add(testVector);
265
266 testVector.m_distance = 5000.0;
267 testVector.m_isLos = true;
268 testVector.m_frequency = 5.0e9;
269 testVector.m_pt = 0.0;
270 testVector.m_pr = -137.6794;
271 m_testVectors.Add(testVector);
272
273 testVector.m_distance = 10.0;
274 testVector.m_isLos = false;
275 testVector.m_frequency = 5.0e9;
276 testVector.m_pt = 0.0;
277 testVector.m_pr = -82.5131;
278 m_testVectors.Add(testVector);
279
280 testVector.m_distance = 100.0;
281 testVector.m_isLos = false;
282 testVector.m_frequency = 5.0e9;
283 testVector.m_pt = 0.0;
284 testVector.m_pr = -106.1356;
285 m_testVectors.Add(testVector);
286
287 testVector.m_distance = 1000.0;
288 testVector.m_isLos = false;
289 testVector.m_frequency = 5.0e9;
290 testVector.m_pt = 0.0;
291 testVector.m_pr = -144.7641;
292 m_testVectors.Add(testVector);
293
294 testVector.m_distance = 5000.0;
295 testVector.m_isLos = false;
296 testVector.m_frequency = 5.0e9;
297 testVector.m_pt = 0.0;
298 testVector.m_pr = -172.0753;
299 m_testVectors.Add(testVector);
300
301 // Create the nodes for BS and UT
302 NodeContainer nodes;
303 nodes.Create(2);
304
305 // Create the mobility models
306 Ptr<MobilityModel> a = CreateObject<ConstantPositionMobilityModel>();
307 nodes.Get(0)->AggregateObject(a);
308 Ptr<MobilityModel> b = CreateObject<ConstantPositionMobilityModel>();
309 nodes.Get(1)->AggregateObject(b);
310
311 // Use a deterministic channel condition model
312 Ptr<ChannelConditionModel> losCondModel = CreateObject<AlwaysLosChannelConditionModel>();
313 Ptr<ChannelConditionModel> nlosCondModel = CreateObject<NeverLosChannelConditionModel>();
314
315 // Create the propagation loss model
316 Ptr<ThreeGppUmaPropagationLossModel> lossModel =
317 CreateObject<ThreeGppUmaPropagationLossModel>();
318 lossModel->SetAttribute("ShadowingEnabled", BooleanValue(false)); // disable the shadow fading
319
320 for (std::size_t i = 0; i < m_testVectors.GetN(); i++)
321 {
322 TestVector testVector = m_testVectors.Get(i);
323
324 Vector posBs = Vector(0.0, 0.0, 25.0);
325 Vector posUt = Vector(testVector.m_distance, 0.0, 1.5);
326
327 // set the LOS or NLOS condition
328 if (testVector.m_isLos)
329 {
330 lossModel->SetChannelConditionModel(losCondModel);
331 }
332 else
333 {
334 lossModel->SetChannelConditionModel(nlosCondModel);
335 }
336
337 a->SetPosition(posBs);
338 b->SetPosition(posUt);
339
340 lossModel->SetAttribute("Frequency", DoubleValue(testVector.m_frequency));
341 NS_TEST_EXPECT_MSG_EQ_TOL(lossModel->CalcRxPower(testVector.m_pt, a, b),
342 testVector.m_pr,
343 m_tolerance,
344 "Got unexpected rcv power");
345 }
346
347 Simulator::Destroy();
348}
349
350/**
351 * @ingroup propagation-tests
352 *
353 * Test case for the class ThreeGppUmiStreetCanyonPropagationLossModel.
354 * It computes the pathloss between two nodes and compares it with the value
355 * obtained using the formula in 3GPP TR 38.901, Table 7.4.1-1.
356 */
357class ThreeGppUmiPropagationLossModelTestCase : public TestCase
358{
359 public:
360 /**
361 * Constructor
362 */
363 ThreeGppUmiPropagationLossModelTestCase();
364
365 /**
366 * Destructor
367 */
368 ~ThreeGppUmiPropagationLossModelTestCase() override;
369
370 private:
371 /**
372 * Build the simulation scenario and run the tests
373 */
374 void DoRun() override;
375
376 /**
377 * Struct containing the parameters for each test
378 */
379 struct TestVector
380 {
381 double m_distance; //!< 2D distance between UT and BS in meters
382 bool m_isLos; //!< if true LOS, if false NLOS
383 double m_frequency; //!< carrier frequency in Hz
384 double m_pt; //!< transmitted power in dBm
385 double m_pr; //!< received power in dBm
386 };
387
388 TestVectors<TestVector> m_testVectors; //!< array containing all the test vectors
389 double m_tolerance; //!< tolerance
390};
391
392ThreeGppUmiPropagationLossModelTestCase::ThreeGppUmiPropagationLossModelTestCase()
393 : TestCase("Test for the ThreeGppUmiPropagationLossModel class"),
394 m_testVectors(),
395 m_tolerance(5e-2)
396{
397}
398
402
403void
404ThreeGppUmiPropagationLossModelTestCase::DoRun()
405{
406 TestVector testVector;
407
408 testVector.m_distance = 10.0;
409 testVector.m_isLos = true;
410 testVector.m_frequency = 5.0e9;
411 testVector.m_pt = 0.0;
412 testVector.m_pr = -69.8591;
413 m_testVectors.Add(testVector);
414
415 testVector.m_distance = 100.0;
416 testVector.m_isLos = true;
417 testVector.m_frequency = 5.0e9;
418 testVector.m_pt = 0.0;
419 testVector.m_pr = -88.4122;
420 m_testVectors.Add(testVector);
421
422 testVector.m_distance = 1000.0;
423 testVector.m_isLos = true;
424 testVector.m_frequency = 5.0e9;
425 testVector.m_pt = 0.0;
426 testVector.m_pr = -119.3114;
427
428 testVector.m_distance = 5000.0;
429 testVector.m_isLos = true;
430 testVector.m_frequency = 5.0e9;
431 testVector.m_pt = 0.0;
432 testVector.m_pr = -147.2696;
433
434 testVector.m_distance = 10.0;
435 testVector.m_isLos = false;
436 testVector.m_frequency = 5.0e9;
437 testVector.m_pt = 0.0;
438 testVector.m_pr = -76.7563;
439
440 testVector.m_distance = 100.0;
441 testVector.m_isLos = false;
442 testVector.m_frequency = 5.0e9;
443 testVector.m_pt = 0.0;
444 testVector.m_pr = -107.9432;
445
446 testVector.m_distance = 1000.0;
447 testVector.m_isLos = false;
448 testVector.m_frequency = 5.0e9;
449 testVector.m_pt = 0.0;
450 testVector.m_pr = -143.1886;
451
452 testVector.m_distance = 5000.0;
453 testVector.m_isLos = false;
454 testVector.m_frequency = 5.0e9;
455 testVector.m_pt = 0.0;
456 testVector.m_pr = -167.8617;
457
458 // Create the nodes for BS and UT
459 NodeContainer nodes;
460 nodes.Create(2);
461
462 // Create the mobility models
463 Ptr<MobilityModel> a = CreateObject<ConstantPositionMobilityModel>();
464 nodes.Get(0)->AggregateObject(a);
465 Ptr<MobilityModel> b = CreateObject<ConstantPositionMobilityModel>();
466 nodes.Get(1)->AggregateObject(b);
467
468 // Use a deterministic channel condition model
469 Ptr<ChannelConditionModel> losCondModel = CreateObject<AlwaysLosChannelConditionModel>();
470 Ptr<ChannelConditionModel> nlosCondModel = CreateObject<NeverLosChannelConditionModel>();
471
472 // Create the propagation loss model
473 Ptr<ThreeGppUmiStreetCanyonPropagationLossModel> lossModel =
474 CreateObject<ThreeGppUmiStreetCanyonPropagationLossModel>();
475 lossModel->SetAttribute("ShadowingEnabled", BooleanValue(false)); // disable the shadow fading
476
477 for (std::size_t i = 0; i < m_testVectors.GetN(); i++)
478 {
479 TestVector testVector = m_testVectors.Get(i);
480
481 Vector posBs = Vector(0.0, 0.0, 10.0);
482 Vector posUt = Vector(testVector.m_distance, 0.0, 1.5);
483
484 // set the LOS or NLOS condition
485 if (testVector.m_isLos)
486 {
487 lossModel->SetChannelConditionModel(losCondModel);
488 }
489 else
490 {
491 lossModel->SetChannelConditionModel(nlosCondModel);
492 }
493
494 a->SetPosition(posBs);
495 b->SetPosition(posUt);
496
497 lossModel->SetAttribute("Frequency", DoubleValue(testVector.m_frequency));
498 NS_TEST_EXPECT_MSG_EQ_TOL(lossModel->CalcRxPower(testVector.m_pt, a, b),
499 testVector.m_pr,
500 m_tolerance,
501 "Got unexpected rcv power");
502 }
503
504 Simulator::Destroy();
505}
506
507/**
508 * @ingroup propagation-tests
509 *
510 * Test case for the class ThreeGppIndoorOfficePropagationLossModel.
511 * It computes the pathloss between two nodes and compares it with the value
512 * obtained using the formula in 3GPP TR 38.901, Table 7.4.1-1.
513 */
514class ThreeGppIndoorOfficePropagationLossModelTestCase : public TestCase
515{
516 public:
517 /**
518 * Constructor
519 */
520 ThreeGppIndoorOfficePropagationLossModelTestCase();
521
522 /**
523 * Destructor
524 */
525 ~ThreeGppIndoorOfficePropagationLossModelTestCase() override;
526
527 private:
528 /**
529 * Build the simulation scenario and run the tests
530 */
531 void DoRun() override;
532
533 /**
534 * Struct containing the parameters for each test
535 */
536 struct TestVector
537 {
538 double m_distance; //!< 2D distance between UT and BS in meters
539 bool m_isLos; //!< if true LOS, if false NLOS
540 double m_frequency; //!< carrier frequency in Hz
541 double m_pt; //!< transmitted power in dBm
542 double m_pr; //!< received power in dBm
543 };
544
545 TestVectors<TestVector> m_testVectors; //!< array containing all the test vectors
546 double m_tolerance; //!< tolerance
547};
548
549ThreeGppIndoorOfficePropagationLossModelTestCase::ThreeGppIndoorOfficePropagationLossModelTestCase()
550 : TestCase("Test for the ThreeGppIndoorOfficePropagationLossModel class"),
551 m_testVectors(),
552 m_tolerance(5e-2)
553{
554}
555
560
561void
562ThreeGppIndoorOfficePropagationLossModelTestCase::DoRun()
563{
564 TestVector testVector;
565
566 testVector.m_distance = 1.0;
567 testVector.m_isLos = true;
568 testVector.m_frequency = 5.0e9;
569 testVector.m_pt = 0.0;
570 testVector.m_pr = -50.8072;
571 m_testVectors.Add(testVector);
572
573 testVector.m_distance = 10.0;
574 testVector.m_isLos = true;
575 testVector.m_frequency = 5.0e9;
576 testVector.m_pt = 0.0;
577 testVector.m_pr = -63.7630;
578 m_testVectors.Add(testVector);
579
580 testVector.m_distance = 50.0;
581 testVector.m_isLos = true;
582 testVector.m_frequency = 5.0e9;
583 testVector.m_pt = 0.0;
584 testVector.m_pr = -75.7750;
585 m_testVectors.Add(testVector);
586
587 testVector.m_distance = 100.0;
588 testVector.m_isLos = true;
589 testVector.m_frequency = 5.0e9;
590 testVector.m_pt = 0.0;
591 testVector.m_pr = -80.9802;
592 m_testVectors.Add(testVector);
593
594 testVector.m_distance = 1.0;
595 testVector.m_isLos = false;
596 testVector.m_frequency = 5.0e9;
597 testVector.m_pt = 0.0;
598 testVector.m_pr = -50.8072;
599 m_testVectors.Add(testVector);
600
601 testVector.m_distance = 10.0;
602 testVector.m_isLos = false;
603 testVector.m_frequency = 5.0e9;
604 testVector.m_pt = 0.0;
605 testVector.m_pr = -73.1894;
606 m_testVectors.Add(testVector);
607
608 testVector.m_distance = 50.0;
609 testVector.m_isLos = false;
610 testVector.m_frequency = 5.0e9;
611 testVector.m_pt = 0.0;
612 testVector.m_pr = -99.7824;
613 m_testVectors.Add(testVector);
614
615 testVector.m_distance = 100.0;
616 testVector.m_isLos = false;
617 testVector.m_frequency = 5.0e9;
618 testVector.m_pt = 0.0;
619 testVector.m_pr = -111.3062;
620 m_testVectors.Add(testVector);
621
622 // Create the nodes for BS and UT
623 NodeContainer nodes;
624 nodes.Create(2);
625
626 // Create the mobility models
627 Ptr<MobilityModel> a = CreateObject<ConstantPositionMobilityModel>();
628 nodes.Get(0)->AggregateObject(a);
629 Ptr<MobilityModel> b = CreateObject<ConstantPositionMobilityModel>();
630 nodes.Get(1)->AggregateObject(b);
631
632 // Use a deterministic channel condition model
633 Ptr<ChannelConditionModel> losCondModel = CreateObject<AlwaysLosChannelConditionModel>();
634 Ptr<ChannelConditionModel> nlosCondModel = CreateObject<NeverLosChannelConditionModel>();
635
636 // Create the propagation loss model
637 Ptr<ThreeGppIndoorOfficePropagationLossModel> lossModel =
638 CreateObject<ThreeGppIndoorOfficePropagationLossModel>();
639 lossModel->SetAttribute("ShadowingEnabled", BooleanValue(false)); // disable the shadow fading
640
641 for (std::size_t i = 0; i < m_testVectors.GetN(); i++)
642 {
643 TestVector testVector = m_testVectors.Get(i);
644
645 Vector posBs = Vector(0.0, 0.0, 3.0);
646 Vector posUt = Vector(testVector.m_distance, 0.0, 1.5);
647
648 // set the LOS or NLOS condition
649 if (testVector.m_isLos)
650 {
651 lossModel->SetChannelConditionModel(losCondModel);
652 }
653 else
654 {
655 lossModel->SetChannelConditionModel(nlosCondModel);
656 }
657
658 a->SetPosition(posBs);
659 b->SetPosition(posUt);
660
661 lossModel->SetAttribute("Frequency", DoubleValue(testVector.m_frequency));
662 NS_TEST_EXPECT_MSG_EQ_TOL(lossModel->CalcRxPower(testVector.m_pt, a, b),
663 testVector.m_pr,
664 m_tolerance,
665 "Got unexpected rcv power");
666 }
667
668 Simulator::Destroy();
669}
670
671/**
672 * @ingroup propagation-tests
673 *
674 * Test case for the class ThreeGppV2vUrbanPropagationLossModel.
675 * It computes the pathloss between two nodes and compares it with the value
676 * obtained using the formula in 3GPP TR 37.885 Table 6.2.1-1 for v2v
677 * communications (sidelink).
678 *
679 * Note that 3GPP TR 37.885 defines 3 different channel states for vehicular
680 * environments: LOS, NLOS, and NLOSv, the latter representing the case in which
681 * the LOS path is blocked by other vehicles in the scenario. However, for
682 * computing the pathloss, only the two states are considered: LOS/NLOSv or NLOS
683 * (see TR 37.885 Section 6.2.1). In case of NLOSv, an additional vehicle
684 * blockage loss may be added, according to a log-normal random variable.
685 * Here, we test both conditions: LOS/NLOSv (without vehicle blockage
686 * loss) and NLOS.
687 */
688class ThreeGppV2vUrbanPropagationLossModelTestCase : public TestCase
689{
690 public:
691 /**
692 * Constructor
693 */
694 ThreeGppV2vUrbanPropagationLossModelTestCase();
695
696 /**
697 * Destructor
698 */
699 ~ThreeGppV2vUrbanPropagationLossModelTestCase() override;
700
701 private:
702 /**
703 * Build the simulation scenario and run the tests
704 */
705 void DoRun() override;
706
707 /**
708 * Struct containing the parameters for each test
709 */
710 struct TestVector
711 {
712 double m_distance; //!< 2D distance between UT and BS in meters
713 bool m_isLos; //!< if true LOS/NLOSv, if false NLOS
714 double m_frequency; //!< carrier frequency in Hz
715 double m_pt; //!< transmitted power in dBm
716 double m_pr; //!< received power in dBm
717 };
718
719 TestVectors<TestVector> m_testVectors; //!< array containing all the test vectors
720 double m_tolerance; //!< tolerance
721};
722
723ThreeGppV2vUrbanPropagationLossModelTestCase::ThreeGppV2vUrbanPropagationLossModelTestCase()
724 : TestCase("Test for the ThreeGppV2vUrbanPropagationLossModel class."),
725 m_testVectors(),
726 m_tolerance(5e-2)
727{
728}
729
733
734void
735ThreeGppV2vUrbanPropagationLossModelTestCase::DoRun()
736{
737 TestVector testVector;
738
739 testVector.m_distance = 10.0;
740 testVector.m_isLos = true;
741 testVector.m_frequency = 5.0e9;
742 testVector.m_pt = 0.0;
743 testVector.m_pr = -68.1913;
744 m_testVectors.Add(testVector);
745
746 testVector.m_distance = 100.0;
747 testVector.m_isLos = true;
748 testVector.m_frequency = 5.0e9;
749 testVector.m_pt = 0.0;
750 testVector.m_pr = -84.8913;
751 m_testVectors.Add(testVector);
752
753 testVector.m_distance = 1000.0;
754 testVector.m_isLos = true;
755 testVector.m_frequency = 5.0e9;
756 testVector.m_pt = 0.0;
757 testVector.m_pr = -101.5913;
758 m_testVectors.Add(testVector);
759
760 testVector.m_distance = 10.0;
761 testVector.m_isLos = false;
762 testVector.m_frequency = 5.0e9;
763 testVector.m_pt = 0.0;
764 testVector.m_pr = -80.0605;
765 m_testVectors.Add(testVector);
766
767 testVector.m_distance = 100.0;
768 testVector.m_isLos = false;
769 testVector.m_frequency = 5.0e9;
770 testVector.m_pt = 0.0;
771 testVector.m_pr = -110.0605;
772 m_testVectors.Add(testVector);
773
774 testVector.m_distance = 1000.0;
775 testVector.m_isLos = false;
776 testVector.m_frequency = 5.0e9;
777 testVector.m_pt = 0.0;
778 testVector.m_pr = -140.0605;
779 m_testVectors.Add(testVector);
780
781 // Create the nodes for BS and UT
782 NodeContainer nodes;
783 nodes.Create(2);
784
785 // Create the mobility models
786 Ptr<MobilityModel> a = CreateObject<ConstantPositionMobilityModel>();
787 nodes.Get(0)->AggregateObject(a);
788 Ptr<MobilityModel> b = CreateObject<ConstantPositionMobilityModel>();
789 nodes.Get(1)->AggregateObject(b);
790
791 // Use a deterministic channel condition model
792 Ptr<ChannelConditionModel> losCondModel = CreateObject<AlwaysLosChannelConditionModel>();
793 Ptr<ChannelConditionModel> nlosCondModel = CreateObject<NeverLosChannelConditionModel>();
794
795 // Create the propagation loss model
796 Ptr<ThreeGppPropagationLossModel> lossModel =
797 CreateObject<ThreeGppV2vUrbanPropagationLossModel>();
798 lossModel->SetAttribute("ShadowingEnabled", BooleanValue(false)); // disable the shadow fading
799
800 for (std::size_t i = 0; i < m_testVectors.GetN(); i++)
801 {
802 TestVector testVector = m_testVectors.Get(i);
803
804 Vector posUe1 = Vector(0.0, 0.0, 1.6);
805 Vector posUe2 = Vector(testVector.m_distance, 0.0, 1.6);
806
807 // set the LOS or NLOS condition
808 if (testVector.m_isLos)
809 {
810 lossModel->SetChannelConditionModel(losCondModel);
811 }
812 else
813 {
814 lossModel->SetChannelConditionModel(nlosCondModel);
815 }
816
817 a->SetPosition(posUe1);
818 b->SetPosition(posUe2);
819
820 lossModel->SetAttribute("Frequency", DoubleValue(testVector.m_frequency));
821 NS_TEST_EXPECT_MSG_EQ_TOL(lossModel->CalcRxPower(testVector.m_pt, a, b),
822 testVector.m_pr,
823 m_tolerance,
824 "Got unexpected rcv power");
825 }
826
827 Simulator::Destroy();
828}
829
830/**
831 * @ingroup propagation-tests
832 *
833 * Test case for the class ThreeGppV2vHighwayPropagationLossModel.
834 * It computes the pathloss between two nodes and compares it with the value
835 * obtained using the formula in 3GPP TR 37.885 Table 6.2.1-1 for v2v
836 * communications (sidelink).
837 *
838 * Note that 3GPP TR 37.885 defines 3 different channel states for vehicular
839 * environments: LOS, NLOS and NLOSv, the latter representing the case in which
840 * the LOS path is blocked by other vehicles in the scenario. However, for
841 * computing the pathloss, only two states are considered: LOS/NLOSv or NLOS
842 * (see TR 37.885 Section 6.2.1). In case of NLOSv, an additional vehicle
843 * blockage loss may be added, according to a log-normal random variable.
844 * Here, we test both conditions: LOS/NLOSv (without vehicle blockage
845 * loss) and NLOS.
846 */
847class ThreeGppV2vHighwayPropagationLossModelTestCase : public TestCase
848{
849 public:
850 /**
851 * Constructor
852 */
853 ThreeGppV2vHighwayPropagationLossModelTestCase();
854
855 /**
856 * Destructor
857 */
858 ~ThreeGppV2vHighwayPropagationLossModelTestCase() override;
859
860 private:
861 /**
862 * Build the simulation scenario and run the tests
863 */
864 void DoRun() override;
865
866 /**
867 * Struct containing the parameters for each test
868 */
869 struct TestVector
870 {
871 double m_distance; //!< 2D distance between UT and BS in meters
872 bool m_isLos; //!< if true LOS/NLOSv, if false NLOS
873 double m_frequency; //!< carrier frequency in Hz
874 double m_pt; //!< transmitted power in dBm
875 double m_pr; //!< received power in dBm
876 };
877
878 TestVectors<TestVector> m_testVectors; //!< array containing all the test vectors
879 double m_tolerance; //!< tolerance
880};
881
882ThreeGppV2vHighwayPropagationLossModelTestCase::ThreeGppV2vHighwayPropagationLossModelTestCase()
883 : TestCase("Test for the ThreeGppV2vHighwayPropagationLossModel"),
884 m_testVectors(),
885 m_tolerance(5e-2)
886{
887}
888
892
893void
894ThreeGppV2vHighwayPropagationLossModelTestCase::DoRun()
895{
896 TestVector testVector;
897
898 testVector.m_distance = 10.0;
899 testVector.m_isLos = true;
900 testVector.m_frequency = 5.0e9;
901 testVector.m_pt = 0.0;
902 testVector.m_pr = -66.3794;
903 m_testVectors.Add(testVector);
904
905 testVector.m_distance = 100.0;
906 testVector.m_isLos = true;
907 testVector.m_frequency = 5.0e9;
908 testVector.m_pt = 0.0;
909 testVector.m_pr = -86.3794;
910 m_testVectors.Add(testVector);
911
912 testVector.m_distance = 1000.0;
913 testVector.m_isLos = true;
914 testVector.m_frequency = 5.0e9;
915 testVector.m_pt = 0.0;
916 testVector.m_pr = -106.3794;
917 m_testVectors.Add(testVector);
918
919 testVector.m_distance = 10.0;
920 testVector.m_isLos = false;
921 testVector.m_frequency = 5.0e9;
922 testVector.m_pt = 0.0;
923 testVector.m_pr = -80.0605;
924 m_testVectors.Add(testVector);
925
926 testVector.m_distance = 100.0;
927 testVector.m_isLos = false;
928 testVector.m_frequency = 5.0e9;
929 testVector.m_pt = 0.0;
930 testVector.m_pr = -110.0605;
931 m_testVectors.Add(testVector);
932
933 testVector.m_distance = 1000.0;
934 testVector.m_isLos = false;
935 testVector.m_frequency = 5.0e9;
936 testVector.m_pt = 0.0;
937 testVector.m_pr = -140.0605;
938 m_testVectors.Add(testVector);
939
940 // Create the nodes for BS and UT
941 NodeContainer nodes;
942 nodes.Create(2);
943
944 // Create the mobility models
945 Ptr<MobilityModel> a = CreateObject<ConstantPositionMobilityModel>();
946 nodes.Get(0)->AggregateObject(a);
947 Ptr<MobilityModel> b = CreateObject<ConstantPositionMobilityModel>();
948 nodes.Get(1)->AggregateObject(b);
949
950 // Use a deterministic channel condition model
951 Ptr<ChannelConditionModel> losCondModel = CreateObject<AlwaysLosChannelConditionModel>();
952 Ptr<ChannelConditionModel> nlosCondModel = CreateObject<NeverLosChannelConditionModel>();
953
954 // Create the propagation loss model
955 Ptr<ThreeGppPropagationLossModel> lossModel =
956 CreateObject<ThreeGppV2vHighwayPropagationLossModel>();
957 lossModel->SetAttribute("ShadowingEnabled", BooleanValue(false)); // disable the shadow fading
958
959 for (std::size_t i = 0; i < m_testVectors.GetN(); i++)
960 {
961 TestVector testVector = m_testVectors.Get(i);
962
963 Vector posUe1 = Vector(0.0, 0.0, 1.6);
964 Vector posUe2 = Vector(testVector.m_distance, 0.0, 1.6);
965
966 // set the LOS or NLOS condition
967 if (testVector.m_isLos)
968 {
969 lossModel->SetChannelConditionModel(losCondModel);
970 }
971 else
972 {
973 lossModel->SetChannelConditionModel(nlosCondModel);
974 }
975
976 a->SetPosition(posUe1);
977 b->SetPosition(posUe2);
978
979 lossModel->SetAttribute("Frequency", DoubleValue(testVector.m_frequency));
980 NS_TEST_EXPECT_MSG_EQ_TOL(lossModel->CalcRxPower(testVector.m_pt, a, b),
981 testVector.m_pr,
982 m_tolerance,
983 "Got unexpected rcv power");
984 }
985
986 Simulator::Destroy();
987}
988
989/**
990 * @ingroup propagation-tests
991 *
992 * Test to check if the shadowing fading is correctly computed
993 */
994class ThreeGppShadowingTestCase : public TestCase
995{
996 public:
997 ThreeGppShadowingTestCase();
998 ~ThreeGppShadowingTestCase() override;
999
1000 private:
1001 void DoRun() override;
1002
1003 /**
1004 * Run the experiment
1005 * @param testNum the index of the experiment
1006 * @param propagationLossModelType the type id of the propagation loss model
1007 * to be used
1008 * @param hBs the BS height in meters
1009 * @param hUt the UT height in meters
1010 * @param distance the initial distance between the BS and the UT
1011 * @param shadowingEnabled true if shadowging must be enabled
1012 */
1013 void RunTest(uint16_t testNum,
1014 std::string propagationLossModelType,
1015 double hBs,
1016 double hUt,
1017 double distance,
1018 bool shadowingEnabled);
1019
1020 /**
1021 * Compute the propagation loss
1022 * @param a the first mobility model
1023 * @param b the second mobility model
1024 * @param testNum the index of the experiment
1025 */
1026 void EvaluateLoss(Ptr<MobilityModel> a, Ptr<MobilityModel> b, uint8_t testNum);
1027
1028 /**
1029 * Change the channel condition model
1030 * @param ccm the new ChannelConditionModel
1031 */
1032 void ChangeChannelCondition(Ptr<ChannelConditionModel> ccm);
1033
1034 /**
1035 * Struct containing the parameters for each test
1036 */
1037 struct TestVector
1038 {
1039 std::string m_propagationLossModelType; //!< the propagation loss model type id
1040 double m_hBs; //!< the BS height in meters
1041 double m_hUt; //!< the UT height in meters
1042 double m_distance; //!< the initial 2D distance in meters between BS and UT in meters
1043 double m_shadowingStdLos; //!< the standard deviation of the shadowing component in the LOS
1044 //!< case in dB
1045 double m_shadowingStdNlos; //!< the standard deviation of the shadowing component in the
1046 //!< NLOS case in dB
1047 };
1048
1049 TestVectors<TestVector> m_testVectors; //!< array containing all the test vectors
1050 Ptr<ThreeGppPropagationLossModel> m_lossModel; //!< the propagation loss model
1051 std::map<uint16_t /* index of experiment */, std::vector<double> /* loss in dB for each run */>
1052 m_results; //!< used to store the test results
1053};
1054
1055ThreeGppShadowingTestCase::ThreeGppShadowingTestCase()
1056 : TestCase("Test to check if the shadow fading is correctly computed")
1057{
1058}
1059
1063
1064void
1065ThreeGppShadowingTestCase::EvaluateLoss(Ptr<MobilityModel> a, Ptr<MobilityModel> b, uint8_t testNum)
1066{
1067 double loss = m_lossModel->CalcRxPower(0, a, b);
1068 m_results.at(testNum).push_back(loss);
1069}
1070
1071void
1076
1077void
1078ThreeGppShadowingTestCase::RunTest(uint16_t testNum,
1079 std::string propagationLossModelType,
1080 double hBs,
1081 double hUt,
1082 double distance,
1083 bool shadowingEnabled)
1084{
1085 // Add a new entry for this test in the results map
1086 m_results[testNum] = std::vector<double>();
1087
1088 // Create the nodes for BS and UT
1089 NodeContainer nodes;
1090 nodes.Create(2);
1091
1092 // Create the mobility models
1093 Ptr<MobilityModel> a = CreateObject<ConstantPositionMobilityModel>();
1094 a->SetPosition(Vector(0.0, 0.0, hBs));
1095 nodes.Get(0)->AggregateObject(a);
1096
1097 Ptr<ConstantVelocityMobilityModel> b = CreateObject<ConstantVelocityMobilityModel>();
1098 nodes.Get(1)->AggregateObject(b);
1099 b->SetPosition(Vector(0.0, distance, hUt));
1100 b->SetVelocity(Vector(1.0, 0.0, 0.0));
1101
1102 // Create the propagation loss model
1103 ObjectFactory propagationLossModelFactory = ObjectFactory(propagationLossModelType);
1104 m_lossModel = propagationLossModelFactory.Create<ThreeGppPropagationLossModel>();
1105 m_lossModel->SetAttribute("Frequency", DoubleValue(3.5e9));
1106 m_lossModel->SetAttribute("ShadowingEnabled",
1107 BooleanValue(shadowingEnabled)); // enable the shadow fading
1108
1109 // Set the channel condition to LOS
1110 Ptr<ChannelConditionModel> losCondModel = CreateObject<AlwaysLosChannelConditionModel>();
1111 m_lossModel->SetChannelConditionModel(losCondModel);
1112 // Schedule a transition to NLOS
1113 Ptr<ChannelConditionModel> nlosCondModel = CreateObject<NeverLosChannelConditionModel>();
1114 Simulator::Schedule(Seconds(99.5),
1115 &ThreeGppShadowingTestCase::ChangeChannelCondition,
1116 this,
1117 nlosCondModel);
1118
1119 // Schedule multiple calls to EvaluateLoss. Use both EvaluateLoss (a,b) and
1120 // EvaluateLoss (b,a) to check if the reciprocity holds.
1121 for (int i = 0; i < 200; i++)
1122 {
1123 if (i % 2 == 0)
1124 {
1125 Simulator::Schedule(MilliSeconds(1000 * i),
1126 &ThreeGppShadowingTestCase::EvaluateLoss,
1127 this,
1128 a,
1129 b,
1130 testNum);
1131 }
1132 else
1133 {
1134 Simulator::Schedule(MilliSeconds(1000 * i),
1135 &ThreeGppShadowingTestCase::EvaluateLoss,
1136 this,
1137 b,
1138 a,
1139 testNum);
1140 }
1141 }
1142
1143 Simulator::Run();
1144 Simulator::Destroy();
1145}
1146
1147void
1148ThreeGppShadowingTestCase::DoRun()
1149{
1150 // The test scenario is composed of two nodes, one fixed
1151 // at position (0,0) and the other moving with constant velocity from
1152 // position (0,50) to position (200,50).
1153 // The channel condition changes from LOS to NLOS when the second node
1154 // reaches position (100,50).
1155 // Each experiment computes the propagation loss between the two nodes
1156 // every second, until the final position is reached, and saves the
1157 // results in an entry of the map m_results.
1158 // We run numSamples experiments and estimate the mean propagation loss in
1159 // each position by averaging among the samples.
1160 // Then, we perform the null hypothesis test with a significance level of
1161 // 0.05.
1162 // This procedure is repeated for all the 3GPP propagation scenarios, i.e.,
1163 // RMa, UMa, UMi and Indoor-Office.
1164
1165 TestVector testVector;
1166 testVector.m_propagationLossModelType = "ns3::ThreeGppRmaPropagationLossModel";
1167 testVector.m_hBs = 25;
1168 testVector.m_hUt = 1.6;
1169 testVector.m_distance = 100;
1170 testVector.m_shadowingStdLos = 4;
1171 testVector.m_shadowingStdNlos = 8;
1172 m_testVectors.Add(testVector);
1173
1174 testVector.m_propagationLossModelType = "ns3::ThreeGppRmaPropagationLossModel";
1175 testVector.m_hBs = 25;
1176 testVector.m_hUt = 1.6;
1177 testVector.m_distance = 4000; // beyond the breakpoint distance
1178 testVector.m_shadowingStdLos = 6;
1179 testVector.m_shadowingStdNlos = 8;
1180 m_testVectors.Add(testVector);
1181
1182 testVector.m_propagationLossModelType = "ns3::ThreeGppUmaPropagationLossModel";
1183 testVector.m_hBs = 25;
1184 testVector.m_hUt = 1.6;
1185 testVector.m_distance = 100;
1186 testVector.m_shadowingStdLos = 4;
1187 testVector.m_shadowingStdNlos = 6;
1188 m_testVectors.Add(testVector);
1189
1190 testVector.m_propagationLossModelType = "ns3::ThreeGppUmiStreetCanyonPropagationLossModel";
1191 testVector.m_hBs = 10;
1192 testVector.m_hUt = 1.6;
1193 testVector.m_distance = 100;
1194 testVector.m_shadowingStdLos = 4;
1195 testVector.m_shadowingStdNlos = 7.82;
1196 m_testVectors.Add(testVector);
1197
1198 testVector.m_propagationLossModelType = "ns3::ThreeGppIndoorOfficePropagationLossModel";
1199 testVector.m_hBs = 3;
1200 testVector.m_hUt = 1;
1201 testVector.m_distance = 50;
1202 testVector.m_shadowingStdLos = 3;
1203 testVector.m_shadowingStdNlos = 8.03;
1204 m_testVectors.Add(testVector);
1205
1206 testVector.m_propagationLossModelType = "ns3::ThreeGppV2vUrbanPropagationLossModel";
1207 testVector.m_hBs = 1.6;
1208 testVector.m_hUt = 1.6;
1209 testVector.m_distance = 50;
1210 testVector.m_shadowingStdLos = 3;
1211 testVector.m_shadowingStdNlos = 4;
1212 m_testVectors.Add(testVector);
1213
1214 testVector.m_propagationLossModelType = "ns3::ThreeGppV2vHighwayPropagationLossModel";
1215 testVector.m_hBs = 1.6;
1216 testVector.m_hUt = 1.6;
1217 testVector.m_distance = 50;
1218 testVector.m_shadowingStdLos = 3;
1219 testVector.m_shadowingStdNlos = 4;
1220 m_testVectors.Add(testVector);
1221
1222 uint16_t numSamples = 250;
1223
1224 for (std::size_t tvIndex = 0; tvIndex < m_testVectors.GetN(); tvIndex++)
1225 {
1226 TestVector tv = m_testVectors.Get(tvIndex);
1227
1228 // run the experiments.
1229 for (uint16_t sampleIndex = 0; sampleIndex < numSamples; sampleIndex++)
1230 {
1231 RunTest(sampleIndex,
1232 tv.m_propagationLossModelType,
1233 tv.m_hBs,
1234 tv.m_hUt,
1235 tv.m_distance,
1236 true);
1237 }
1238
1239 // analyze the results
1240 std::vector<double> mean_vector; // the vector containing the mean propagation loss for each
1241 // position (sample mean)
1242
1243 uint16_t numPositions = m_results.at(0).size();
1244 for (uint16_t k = 0; k < numPositions; k++)
1245 {
1246 // compute the mean propagation loss in position k
1247 double mean = 0.0;
1248 for (auto resIt : m_results)
1249 {
1250 mean += resIt.second.at(k);
1251 }
1252 mean /= m_results.size();
1253 mean_vector.push_back(mean);
1254 }
1255
1256 // compute the true mean - just the pathloss, without the shadowing component
1257 RunTest(numSamples,
1258 tv.m_propagationLossModelType,
1259 tv.m_hBs,
1260 tv.m_hUt,
1261 tv.m_distance,
1262 false);
1263 std::vector<double> true_mean =
1264 m_results.at(numSamples); // the result of the last test is the true mean
1265
1266 // perform the null hypothesis test for the LOS case
1267 // positions from (0, 50) to (99, 50) are LOS
1268 for (std::size_t i = 0; i < mean_vector.size() / 2; i++)
1269 {
1270 double z = (mean_vector.at(i) - true_mean.at(i)) /
1271 (tv.m_shadowingStdLos / std::sqrt(mean_vector.size() / 2));
1272 NS_TEST_EXPECT_MSG_EQ_TOL(
1273 z,
1274 0.0,
1275 1.96,
1276 "Null hypothesis test (LOS case) for the shadowing component rejected");
1277 }
1278
1279 // perform the null hypothesis test for the NLOS case
1280 // positions from (100, 50) to (199, 50) are NLOS
1281 for (std::size_t i = mean_vector.size() / 2; i < mean_vector.size(); i++)
1282 {
1283 double z = (mean_vector.at(i) - true_mean.at(i)) /
1284 (tv.m_shadowingStdNlos / std::sqrt(mean_vector.size() / 2));
1285 NS_TEST_EXPECT_MSG_EQ_TOL(
1286 z,
1287 0.0,
1288 1.96,
1289 "Null hypothesis test (NLOS case) for the shadowing component rejected");
1290 }
1291 }
1292}
1293
1294/**
1295 * @ingroup propagation-tests
1296 *
1297 * @brief 3GPP Propagation models TestSuite
1298 *
1299 * This TestSuite tests the following models:
1300 * - ThreeGppRmaPropagationLossModel
1301 * - ThreeGppUmaPropagationLossModel
1302 * - ThreeGppUmiPropagationLossModel
1303 * - ThreeGppIndoorOfficePropagationLossModel
1304 * - ThreeGppV2vUrbanPropagationLossModel
1305 * - ThreeGppV2vHighwayPropagationLossModel
1306 * - ThreeGppShadowing
1307 */
1313
1325
1326/// Static variable for test initialization
1327static ThreeGppPropagationLossModelsTestSuite g_propagationLossModelsTestSuite;
ThreeGppIndoorOfficePropagationLossModelTestCase
Test case for the class ThreeGppIndoorOfficePropagationLossModel.
Definition three-gpp-propagation-loss-model-test-suite.cc:515
ThreeGppIndoorOfficePropagationLossModelTestCase::DoRun
void DoRun() override
Build the simulation scenario and run the tests.
Definition three-gpp-propagation-loss-model-test-suite.cc:562
ThreeGppIndoorOfficePropagationLossModelTestCase::m_testVectors
TestVectors< TestVector > m_testVectors
array containing all the test vectors
Definition three-gpp-propagation-loss-model-test-suite.cc:545
ThreeGppRmaPropagationLossModelTestCase
Test case for the class ThreeGppRmaPropagationLossModel.
Definition three-gpp-propagation-loss-model-test-suite.cc:34
ThreeGppRmaPropagationLossModelTestCase::DoRun
void DoRun() override
Build the simulation scenario and run the tests.
Definition three-gpp-propagation-loss-model-test-suite.cc:80
ThreeGppRmaPropagationLossModelTestCase::m_testVectors
TestVectors< TestVector > m_testVectors
array containing all the test vectors
Definition three-gpp-propagation-loss-model-test-suite.cc:64
ThreeGppShadowingTestCase
Test to check if the shadowing fading is correctly computed.
Definition three-gpp-propagation-loss-model-test-suite.cc:995
ThreeGppShadowingTestCase::EvaluateLoss
void EvaluateLoss(Ptr< MobilityModel > a, Ptr< MobilityModel > b, uint8_t testNum)
Compute the propagation loss.
Definition three-gpp-propagation-loss-model-test-suite.cc:1065
ThreeGppShadowingTestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition three-gpp-propagation-loss-model-test-suite.cc:1148
ThreeGppShadowingTestCase::m_results
std::map< uint16_t, std::vector< double > > m_results
used to store the test results
Definition three-gpp-propagation-loss-model-test-suite.cc:1052
ThreeGppShadowingTestCase::ChangeChannelCondition
void ChangeChannelCondition(Ptr< ChannelConditionModel > ccm)
Change the channel condition model.
Definition three-gpp-propagation-loss-model-test-suite.cc:1072
ThreeGppShadowingTestCase::m_lossModel
Ptr< ThreeGppPropagationLossModel > m_lossModel
the propagation loss model
Definition three-gpp-propagation-loss-model-test-suite.cc:1050
ThreeGppShadowingTestCase::m_testVectors
TestVectors< TestVector > m_testVectors
array containing all the test vectors
Definition three-gpp-propagation-loss-model-test-suite.cc:1049
ThreeGppShadowingTestCase::RunTest
void RunTest(uint16_t testNum, std::string propagationLossModelType, double hBs, double hUt, double distance, bool shadowingEnabled)
Run the experiment.
Definition three-gpp-propagation-loss-model-test-suite.cc:1078
ThreeGppUmaPropagationLossModelTestCase
Test case for the class ThreeGppUmaPropagationLossModel.
Definition three-gpp-propagation-loss-model-test-suite.cc:195
ThreeGppUmaPropagationLossModelTestCase::m_testVectors
TestVectors< TestVector > m_testVectors
array containing all the test vectors
Definition three-gpp-propagation-loss-model-test-suite.cc:225
ThreeGppUmaPropagationLossModelTestCase::DoRun
void DoRun() override
Build the simulation scenario and run the tests.
Definition three-gpp-propagation-loss-model-test-suite.cc:241
ThreeGppUmiPropagationLossModelTestCase
Test case for the class ThreeGppUmiStreetCanyonPropagationLossModel.
Definition three-gpp-propagation-loss-model-test-suite.cc:358
ThreeGppUmiPropagationLossModelTestCase::m_testVectors
TestVectors< TestVector > m_testVectors
array containing all the test vectors
Definition three-gpp-propagation-loss-model-test-suite.cc:388
ThreeGppUmiPropagationLossModelTestCase::DoRun
void DoRun() override
Build the simulation scenario and run the tests.
Definition three-gpp-propagation-loss-model-test-suite.cc:404
ThreeGppV2vHighwayPropagationLossModelTestCase
Test case for the class ThreeGppV2vHighwayPropagationLossModel.
Definition three-gpp-propagation-loss-model-test-suite.cc:848
ThreeGppV2vHighwayPropagationLossModelTestCase::m_testVectors
TestVectors< TestVector > m_testVectors
array containing all the test vectors
Definition three-gpp-propagation-loss-model-test-suite.cc:878
ThreeGppV2vHighwayPropagationLossModelTestCase::DoRun
void DoRun() override
Build the simulation scenario and run the tests.
Definition three-gpp-propagation-loss-model-test-suite.cc:894
ThreeGppV2vUrbanPropagationLossModelTestCase
Test case for the class ThreeGppV2vUrbanPropagationLossModel.
Definition three-gpp-propagation-loss-model-test-suite.cc:689
ThreeGppV2vUrbanPropagationLossModelTestCase::m_testVectors
TestVectors< TestVector > m_testVectors
array containing all the test vectors
Definition three-gpp-propagation-loss-model-test-suite.cc:719
ThreeGppV2vUrbanPropagationLossModelTestCase::DoRun
void DoRun() override
Build the simulation scenario and run the tests.
Definition three-gpp-propagation-loss-model-test-suite.cc:735
ns3::DoubleValue
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition double.h:31
ns3::NodeContainer
keep track of a set of node pointers.
Definition node-container.h:29
ns3::ObjectFactory
Instantiate subclasses of ns3::Object.
Definition object-factory.h:37
ns3::ObjectFactory::Create
Ptr< Object > Create() const
Create an Object instance of the configured TypeId.
Definition object-factory.cc:82
ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition ptr.h:66
ns3::Simulator::Schedule
static EventId Schedule(const Time &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
Definition simulator.h:561
ns3::Simulator::Destroy
static void Destroy()
Execute the events scheduled with ScheduleDestroy().
Definition simulator.cc:131
ns3::Simulator::Run
static void Run()
Run the simulation.
Definition simulator.cc:167
ns3::TestCase::AddTestCase
void AddTestCase(TestCase *testCase, Duration duration=Duration::QUICK)
Add an individual child TestCase to this test suite.
Definition test.cc:292
ns3::TestCase::Duration::QUICK
@ QUICK
Fast test.
Definition test.h:1055
ns3::TestCase::TestCase
TestCase(const TestCase &)=delete
ns3::TestSuite::Type
Type
Type of test.
Definition test.h:1274
ns3::TestSuite::TestSuite
TestSuite(std::string name, Type type=Type::UNIT)
Construct a new test suite.
Definition test.cc:490
ns3::TestSuite::UNIT
static constexpr auto UNIT
Definition test.h:1291
ns3::TestVectors
A simple way to store test vectors (for stimulus or from responses)
Definition test.h:1348
ns3::ThreeGppPropagationLossModel
Base class for the 3GPP propagation models.
Definition three-gpp-propagation-loss-model.h:23
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition log.h:191
ns3::CreateObject
Ptr< T > CreateObject(Args &&... args)
Create an object by type, with varying number of constructor parameters.
Definition object.h:619
NS_TEST_EXPECT_MSG_EQ_TOL
#define NS_TEST_EXPECT_MSG_EQ_TOL(actual, limit, tol, msg)
Test that actual and expected (limit) values are equal to plus or minus some tolerance and report if ...
Definition test.h:500
ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition nstime.h:1345
ns3::MilliSeconds
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition nstime.h:1357
nodes
NodeContainer nodes
Definition lr-wpan-bootstrap.cc:43
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
g_propagationLossModelsTestSuite
static PropagationLossModelsTestSuite g_propagationLossModelsTestSuite
Static variable for test initialization.
Definition propagation-loss-model-test-suite.cc:510
ThreeGppShadowingTestCase::TestVector::m_distance
double m_distance
the initial 2D distance in meters between BS and UT in meters
Definition three-gpp-propagation-loss-model-test-suite.cc:1042
ThreeGppShadowingTestCase::TestVector::m_propagationLossModelType
std::string m_propagationLossModelType
the propagation loss model type id
Definition three-gpp-propagation-loss-model-test-suite.cc:1039
ThreeGppShadowingTestCase::TestVector::m_shadowingStdLos
double m_shadowingStdLos
the standard deviation of the shadowing component in the LOS case in dB
Definition three-gpp-propagation-loss-model-test-suite.cc:1043
ThreeGppShadowingTestCase::TestVector::m_shadowingStdNlos
double m_shadowingStdNlos
the standard deviation of the shadowing component in the NLOS case in dB
Definition three-gpp-propagation-loss-model-test-suite.cc:1045