A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
wifi-error-rate-models-test.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2016 University of Washington
3 *
4 * SPDX-License-Identifier: GPL-2.0-only
5 *
6 * Authors: Tom Henderson (tomhend@u.washington.edu)
7 * Sébastien Deronne (sebastien.deronne@gmail.com)
8 */
9
10#ifdef HAVE_GSL
11#include <gsl/gsl_cdf.h>
12#include <gsl/gsl_integration.h>
13#include <gsl/gsl_math.h>
14#include <gsl/gsl_sf_bessel.h>
15#endif
16
17#include "ns3/dsss-error-rate-model.h"
18#include "ns3/he-phy.h" //includes HT and VHT
19#include "ns3/interference-helper.h"
20#include "ns3/log.h"
21#include "ns3/nist-error-rate-model.h"
22#include "ns3/table-based-error-rate-model.h"
23#include "ns3/test.h"
24#include "ns3/wifi-phy.h"
25#include "ns3/wifi-utils.h"
26#include "ns3/yans-error-rate-model.h"
27
28using namespace ns3;
29
30NS_LOG_COMPONENT_DEFINE("WifiErrorRateModelsTest");
31
32static double
33FromRss(dBW_u rss)
34{
35 // SINR is based on receiver noise figure of 7 dB and thermal noise
36 // of -100.5522786 dBm in this 22 MHz bandwidth at 290K
37 dBW_u noisePower = -100.5522786 + 7;
38
39 dB_u sinr = rss - noisePower;
40 // return SINR expressed as ratio
41 return pow(10.0, sinr / 10.0);
42}
43
44/**
45 * @ingroup wifi-test
46 * @ingroup tests
47 *
48 * @brief Wifi Error Rate Models Test Case Dsss
49 */
50class WifiErrorRateModelsTestCaseDsss : public TestCase
51{
52 public:
53 WifiErrorRateModelsTestCaseDsss();
54 ~WifiErrorRateModelsTestCaseDsss() override;
55
56 private:
57 void DoRun() override;
58};
59
60WifiErrorRateModelsTestCaseDsss::WifiErrorRateModelsTestCaseDsss()
61 : TestCase("WifiErrorRateModel test case DSSS")
62{
63}
64
68
69void
70WifiErrorRateModelsTestCaseDsss::DoRun()
71{
72 // 1024 bytes plus headers
73 uint64_t size = (1024 + 40 + 14) * 8;
74 // Spot test some values returned from DsssErrorRateModel
75 // Values taken from sample 80211b.c program used in validation paper
76 double value;
77 // DBPSK
78 value = DsssErrorRateModel::GetDsssDbpskSuccessRate(FromRss(-105.0), size);
79 NS_TEST_ASSERT_MSG_EQ_TOL(value, 0, 1e-13, "Not equal within tolerance");
80 value = DsssErrorRateModel::GetDsssDbpskSuccessRate(FromRss(-100.0), size);
81 NS_TEST_ASSERT_MSG_EQ_TOL(value, 1.5e-13, 1e-13, "Not equal within tolerance");
82 value = DsssErrorRateModel::GetDsssDbpskSuccessRate(FromRss(-99.0), size);
83 NS_TEST_ASSERT_MSG_EQ_TOL(value, 0.0003, 0.0001, "Not equal within tolerance");
84 value = DsssErrorRateModel::GetDsssDbpskSuccessRate(FromRss(-98.0), size);
85 NS_TEST_ASSERT_MSG_EQ_TOL(value, 0.202, 0.005, "Not equal within tolerance");
86 value = DsssErrorRateModel::GetDsssDbpskSuccessRate(FromRss(-97.0), size);
87 NS_TEST_ASSERT_MSG_EQ_TOL(value, 0.813, 0.005, "Not equal within tolerance");
88 value = DsssErrorRateModel::GetDsssDbpskSuccessRate(FromRss(-96.0), size);
89 NS_TEST_ASSERT_MSG_EQ_TOL(value, 0.984, 0.005, "Not equal within tolerance");
90 value = DsssErrorRateModel::GetDsssDbpskSuccessRate(FromRss(-95.0), size);
91 NS_TEST_ASSERT_MSG_EQ_TOL(value, 0.999, 0.001, "Not equal within tolerance");
92 value = DsssErrorRateModel::GetDsssDbpskSuccessRate(FromRss(-90.0), size);
93 NS_TEST_ASSERT_MSG_EQ_TOL(value, 1, 0.001, "Not equal within tolerance");
94
95 // DQPSK
96 //
97 value = DsssErrorRateModel::GetDsssDqpskSuccessRate(FromRss(-96.0), size);
98 NS_TEST_ASSERT_MSG_EQ_TOL(value, 0, 1e-13, "Not equal within tolerance");
99 value = DsssErrorRateModel::GetDsssDqpskSuccessRate(FromRss(-95.0), size);
100 NS_TEST_ASSERT_MSG_EQ_TOL(value, 4.5e-6, 1e-6, "Not equal within tolerance");
101 value = DsssErrorRateModel::GetDsssDqpskSuccessRate(FromRss(-94.0), size);
102 NS_TEST_ASSERT_MSG_EQ_TOL(value, 0.036, 0.005, "Not equal within tolerance");
103 value = DsssErrorRateModel::GetDsssDqpskSuccessRate(FromRss(-93.0), size);
104 NS_TEST_ASSERT_MSG_EQ_TOL(value, 0.519, 0.005, "Not equal within tolerance");
105 value = DsssErrorRateModel::GetDsssDqpskSuccessRate(FromRss(-92.0), size);
106 NS_TEST_ASSERT_MSG_EQ_TOL(value, 0.915, 0.005, "Not equal within tolerance");
107 value = DsssErrorRateModel::GetDsssDqpskSuccessRate(FromRss(-91.0), size);
108 NS_TEST_ASSERT_MSG_EQ_TOL(value, 0.993, 0.005, "Not equal within tolerance");
109 value = DsssErrorRateModel::GetDsssDqpskSuccessRate(FromRss(-90.0), size);
110 NS_TEST_ASSERT_MSG_EQ_TOL(value, 0.999, 0.001, "Not equal within tolerance");
111 value = DsssErrorRateModel::GetDsssDqpskSuccessRate(FromRss(-89.0), size);
112 NS_TEST_ASSERT_MSG_EQ_TOL(value, 1, 0.001, "Not equal within tolerance");
113
114#ifdef HAVE_GSL
115 // DQPSK_CCK5.5
116 value = DsssErrorRateModel::GetDsssDqpskCck5_5SuccessRate(FromRss(-94.0), size);
117 NS_TEST_ASSERT_MSG_EQ_TOL(value, 0, 1e-13, "Not equal within tolerance");
118 value = DsssErrorRateModel::GetDsssDqpskCck5_5SuccessRate(FromRss(-93.0), size);
119 NS_TEST_ASSERT_MSG_EQ_TOL(value, 6.6e-14, 5e-14, "Not equal within tolerance");
120 value = DsssErrorRateModel::GetDsssDqpskCck5_5SuccessRate(FromRss(-92.0), size);
121 NS_TEST_ASSERT_MSG_EQ_TOL(value, 0.0001, 0.00005, "Not equal within tolerance");
122 value = DsssErrorRateModel::GetDsssDqpskCck5_5SuccessRate(FromRss(-91.0), size);
123 NS_TEST_ASSERT_MSG_EQ_TOL(value, 0.132, 0.005, "Not equal within tolerance");
124 value = DsssErrorRateModel::GetDsssDqpskCck5_5SuccessRate(FromRss(-90.0), size);
125 NS_TEST_ASSERT_MSG_EQ_TOL(value, 0.744, 0.005, "Not equal within tolerance");
126 value = DsssErrorRateModel::GetDsssDqpskCck5_5SuccessRate(FromRss(-89.0), size);
127 NS_TEST_ASSERT_MSG_EQ_TOL(value, 0.974, 0.005, "Not equal within tolerance");
128 value = DsssErrorRateModel::GetDsssDqpskCck5_5SuccessRate(FromRss(-88.0), size);
129 NS_TEST_ASSERT_MSG_EQ_TOL(value, 0.999, 0.001, "Not equal within tolerance");
130 value = DsssErrorRateModel::GetDsssDqpskCck5_5SuccessRate(FromRss(-87.0), size);
131 NS_TEST_ASSERT_MSG_EQ_TOL(value, 1, 0.001, "Not equal within tolerance");
132
133 // DQPSK_CCK11
134 value = DsssErrorRateModel::GetDsssDqpskCck11SuccessRate(FromRss(-91.0), size);
135 NS_TEST_ASSERT_MSG_EQ_TOL(value, 0, 1e-14, "Not equal within tolerance");
136 value = DsssErrorRateModel::GetDsssDqpskCck11SuccessRate(FromRss(-90.0), size);
137 NS_TEST_ASSERT_MSG_EQ_TOL(value, 4.7e-14, 1e-14, "Not equal within tolerance");
138 value = DsssErrorRateModel::GetDsssDqpskCck11SuccessRate(FromRss(-89.0), size);
139 NS_TEST_ASSERT_MSG_EQ_TOL(value, 8.85e-5, 1e-5, "Not equal within tolerance");
140 value = DsssErrorRateModel::GetDsssDqpskCck11SuccessRate(FromRss(-88.0), size);
141 NS_TEST_ASSERT_MSG_EQ_TOL(value, 0.128, 0.005, "Not equal within tolerance");
142 value = DsssErrorRateModel::GetDsssDqpskCck11SuccessRate(FromRss(-87.0), size);
143 NS_TEST_ASSERT_MSG_EQ_TOL(value, 0.739, 0.005, "Not equal within tolerance");
144 value = DsssErrorRateModel::GetDsssDqpskCck11SuccessRate(FromRss(-86.0), size);
145 NS_TEST_ASSERT_MSG_EQ_TOL(value, 0.973, 0.005, "Not equal within tolerance");
146 value = DsssErrorRateModel::GetDsssDqpskCck11SuccessRate(FromRss(-85.0), size);
147 NS_TEST_ASSERT_MSG_EQ_TOL(value, 0.999, 0.001, "Not equal within tolerance");
148 value = DsssErrorRateModel::GetDsssDqpskCck11SuccessRate(FromRss(-84.0), size);
149 NS_TEST_ASSERT_MSG_EQ_TOL(value, 1, 0.001, "Not equal within tolerance");
150#endif
151}
152
153/**
154 * @ingroup wifi-test
155 * @ingroup tests
156 *
157 * @brief Wifi Error Rate Models Test Case Nist
158 */
159class WifiErrorRateModelsTestCaseNist : public TestCase
160{
161 public:
162 WifiErrorRateModelsTestCaseNist();
163 ~WifiErrorRateModelsTestCaseNist() override;
164
165 private:
166 void DoRun() override;
167};
168
169WifiErrorRateModelsTestCaseNist::WifiErrorRateModelsTestCaseNist()
170 : TestCase("WifiErrorRateModel test case NIST")
171{
172}
173
177
178void
179WifiErrorRateModelsTestCaseNist::DoRun()
180{
181 uint32_t frameSize = 2000;
182 WifiTxVector txVector;
183 Ptr<NistErrorRateModel> nist = CreateObject<NistErrorRateModel>();
184
185 // Spot test some values returned from NistErrorRateModel
186 // values can be generated by the example program ofdm-validation.cc
187 dB_u snr{2.5};
188 auto ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate6Mbps"),
189 txVector,
190 std::pow(10.0, snr / 10.0),
191 frameSize * 8);
192 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 2.04e-10, 1e-10, "Not equal within tolerance");
193 snr = dB_u{3.0};
194 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate6Mbps"),
195 txVector,
196 std::pow(10.0, snr / 10.0),
197 frameSize * 8);
198 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 0.020, 0.001, "Not equal within tolerance");
199 snr = dB_u{4.0};
200 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate6Mbps"),
201 txVector,
202 std::pow(10.0, snr / 10.0),
203 frameSize * 8);
204 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 0.885, 0.001, "Not equal within tolerance");
205 snr = dB_u{5.0};
206 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate6Mbps"),
207 txVector,
208 std::pow(10.0, snr / 10.0),
209 frameSize * 8);
210 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 0.997, 0.001, "Not equal within tolerance");
211
212 snr = dB_u{6.0};
213 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate9Mbps"),
214 txVector,
215 std::pow(10.0, snr / 10.0),
216 frameSize * 8);
217 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 0.097, 0.001, "Not equal within tolerance");
218 snr = dB_u{7.0};
219 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate9Mbps"),
220 txVector,
221 std::pow(10.0, snr / 10.0),
222 frameSize * 8);
223 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 0.918, 0.001, "Not equal within tolerance");
224 snr = dB_u{8.0};
225 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate9Mbps"),
226 txVector,
227 std::pow(10.0, snr / 10.0),
228 frameSize * 8);
229 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 0.998, 0.001, "Not equal within tolerance");
230 snr = dB_u{9.0};
231 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate9Mbps"),
232 txVector,
233 std::pow(10.0, snr / 10.0),
234 frameSize * 8);
235 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 0.999, 0.001, "Not equal within tolerance");
236
237 snr = dB_u{6.0};
238 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate12Mbps"),
239 txVector,
240 std::pow(10.0, snr / 10.0),
241 frameSize * 8);
242 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 0.0174, 0.001, "Not equal within tolerance");
243 snr = dB_u{7.0};
244 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate12Mbps"),
245 txVector,
246 std::pow(10.0, snr / 10.0),
247 frameSize * 8);
248 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 0.881, 0.001, "Not equal within tolerance");
249 snr = dB_u{8.0};
250 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate12Mbps"),
251 txVector,
252 std::pow(10.0, snr / 10.0),
253 frameSize * 8);
254 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 0.997, 0.001, "Not equal within tolerance");
255 snr = dB_u{9.0};
256 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate12Mbps"),
257 txVector,
258 std::pow(10.0, snr / 10.0),
259 frameSize * 8);
260 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 0.999, 0.001, "Not equal within tolerance");
261
262 snr = dB_u{8.5};
263 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate18Mbps"),
264 txVector,
265 std::pow(10.0, snr / 10.0),
266 frameSize * 8);
267 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 2.85e-6, 1e-6, "Not equal within tolerance");
268 snr = dB_u{9.5};
269 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate18Mbps"),
270 txVector,
271 std::pow(10.0, snr / 10.0),
272 frameSize * 8);
273 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 0.623, 0.001, "Not equal within tolerance");
274 snr = dB_u{10.5};
275 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate18Mbps"),
276 txVector,
277 std::pow(10.0, snr / 10.0),
278 frameSize * 8);
279 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 0.985, 0.001, "Not equal within tolerance");
280 snr = dB_u{11.5};
281 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate18Mbps"),
282 txVector,
283 std::pow(10.0, snr / 10.0),
284 frameSize * 8);
285 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 0.999, 0.001, "Not equal within tolerance");
286
287 snr = dB_u{12.0};
288 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate24Mbps"),
289 txVector,
290 std::pow(10.0, snr / 10.0),
291 frameSize * 8);
292 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 2.22e-7, 1e-7, "Not equal within tolerance");
293 snr = dB_u{13.0};
294 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate24Mbps"),
295 txVector,
296 std::pow(10.0, snr / 10.0),
297 frameSize * 8);
298 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 0.495, 0.001, "Not equal within tolerance");
299 snr = dB_u{14.0};
300 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate24Mbps"),
301 txVector,
302 std::pow(10.0, snr / 10.0),
303 frameSize * 8);
304 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 0.974, 0.001, "Not equal within tolerance");
305 snr = dB_u{15.0};
306 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate24Mbps"),
307 txVector,
308 std::pow(10.0, snr / 10.0),
309 frameSize * 8);
310 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 0.999, 0.001, "Not equal within tolerance");
311
312 snr = dB_u{15.5};
313 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate36Mbps"),
314 txVector,
315 std::pow(10.0, snr / 10.0),
316 frameSize * 8);
317 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 0.012, 0.001, "Not equal within tolerance");
318 snr = dB_u{16.5};
319 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate36Mbps"),
320 txVector,
321 std::pow(10.0, snr / 10.0),
322 frameSize * 8);
323 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 0.818, 0.001, "Not equal within tolerance");
324 snr = dB_u{17.5};
325 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate36Mbps"),
326 txVector,
327 std::pow(10.0, snr / 10.0),
328 frameSize * 8);
329 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 0.993, 0.001, "Not equal within tolerance");
330 snr = dB_u{18.5};
331 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate36Mbps"),
332 txVector,
333 std::pow(10.0, snr / 10.0),
334 frameSize * 8);
335 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 0.999, 0.001, "Not equal within tolerance");
336
337 snr = dB_u{20.0};
338 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate48Mbps"),
339 txVector,
340 std::pow(10.0, snr / 10.0),
341 frameSize * 8);
342 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 1.3e-4, 1e-4, "Not equal within tolerance");
343 snr = dB_u{21.0};
344 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate48Mbps"),
345 txVector,
346 std::pow(10.0, snr / 10.0),
347 frameSize * 8);
348 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 0.649, 0.001, "Not equal within tolerance");
349 snr = dB_u{22.0};
350 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate48Mbps"),
351 txVector,
352 std::pow(10.0, snr / 10.0),
353 frameSize * 8);
354 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 0.983, 0.001, "Not equal within tolerance");
355 snr = dB_u{23.0};
356 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate48Mbps"),
357 txVector,
358 std::pow(10.0, snr / 10.0),
359 frameSize * 8);
360 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 0.999, 0.001, "Not equal within tolerance");
361
362 snr = dB_u{21.0};
363 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate54Mbps"),
364 txVector,
365 std::pow(10.0, snr / 10.0),
366 frameSize * 8);
367 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 5.44e-8, 1e-8, "Not equal within tolerance");
368 snr = dB_u{22.0};
369 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate54Mbps"),
370 txVector,
371 std::pow(10.0, snr / 10.0),
372 frameSize * 8);
373 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 0.410, 0.001, "Not equal within tolerance");
374 snr = dB_u{23.0};
375 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate54Mbps"),
376 txVector,
377 std::pow(10.0, snr / 10.0),
378 frameSize * 8);
379 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 0.958, 0.001, "Not equal within tolerance");
380 snr = dB_u{24.0};
381 ps = nist->GetChunkSuccessRate(WifiMode("OfdmRate54Mbps"),
382 txVector,
383 std::pow(10.0, snr / 10.0),
384 frameSize * 8);
385 NS_TEST_ASSERT_MSG_EQ_TOL(ps, 0.999, 0.001, "Not equal within tolerance");
386}
387
394
395/**
396 * @ingroup wifi-test
397 * @ingroup tests
398 *
399 * @brief Wifi Error Rate Models Test Case MIMO
400 */
401class WifiErrorRateModelsTestCaseMimo : public TestCase
402{
403 public:
404 WifiErrorRateModelsTestCaseMimo();
405 ~WifiErrorRateModelsTestCaseMimo() override;
406
407 private:
408 void DoRun() override;
409};
410
411WifiErrorRateModelsTestCaseMimo::WifiErrorRateModelsTestCaseMimo()
412 : TestCase("WifiErrorRateModel test case MIMO")
413{
414}
415
419
420void
421WifiErrorRateModelsTestCaseMimo::DoRun()
422{
423 TestInterferenceHelper interference;
424 interference.SetNoiseFigure(0);
425 WifiMode mode = HtPhy::GetHtMcs0();
426 WifiTxVector txVector;
427
428 txVector.SetMode(mode);
429 txVector.SetTxPowerLevel(0);
430 txVector.SetChannelWidth(MHz_u{20});
431 txVector.SetNss(1);
432 txVector.SetNTx(1);
433
434 interference.SetNumberOfReceiveAntennas(1);
435 Ptr<NistErrorRateModel> nist = CreateObject<NistErrorRateModel>();
436 interference.SetErrorRateModel(nist);
437
438 // SISO: initial SNR set to 4dB
439 dB_u initialSnr{4.0};
440 dB_u tol{0.1};
441 auto snr = interference.CalculateSnr(Watt_u{0.001},
442 Watt_u{0.001} / DbToRatio(initialSnr),
443 txVector.GetChannelWidth(),
444 txVector.GetNss());
445 NS_TEST_ASSERT_MSG_EQ_TOL(RatioToDb(snr),
446 initialSnr,
447 tol,
448 "Attempt to set initial SNR to known value failed");
449 Time duration = MilliSeconds(2);
450 auto chunkSuccess = interference.CalculatePayloadChunkSuccessRate(snr, duration, txVector);
451 NS_TEST_ASSERT_MSG_EQ_TOL(chunkSuccess,
452 0.905685,
453 0.000001,
454 "CSR not within tolerance for SISO");
455 auto sisoChunkSuccess = chunkSuccess;
456
457 // MIMO 2x1:2: expect no SNR gain in AWGN channel
458 txVector.SetNss(2);
459 txVector.SetNTx(2);
460 snr = interference.CalculateSnr(Watt_u{0.001},
461 Watt_u{0.001} / DbToRatio(initialSnr),
462 txVector.GetChannelWidth(),
463 txVector.GetNss());
464 NS_TEST_ASSERT_MSG_EQ_TOL(RatioToDb(snr),
465 initialSnr,
466 tol,
467 "SNR not within tolerance for 2x1:2 MIMO");
468 chunkSuccess = interference.CalculatePayloadChunkSuccessRate(snr, duration, txVector);
469 NS_TEST_ASSERT_MSG_EQ_TOL(chunkSuccess,
470 0.905685,
471 0.000001,
472 "CSR not within tolerance for SISO");
473
474 // MIMO 1x2:1: expect that SNR is increased by a factor of 3 dB (10 log 2/1) compared to SISO
475 // thanks to RX diversity
476 txVector.SetNss(1);
477 txVector.SetNTx(1);
478 interference.SetNumberOfReceiveAntennas(2);
479 snr = interference.CalculateSnr(Watt_u{0.001},
480 Watt_u{0.001} / DbToRatio(initialSnr),
481 txVector.GetChannelWidth(),
482 txVector.GetNss());
483 NS_TEST_ASSERT_MSG_EQ_TOL(RatioToDb(snr),
484 initialSnr + dB_u{3.0},
485 tol,
486 "SNR not within tolerance for 1x2:1 MIMO");
487 chunkSuccess = interference.CalculatePayloadChunkSuccessRate(snr, duration, txVector);
488 NS_TEST_ASSERT_MSG_GT(chunkSuccess,
489 sisoChunkSuccess,
490 "CSR not within tolerance for 1x2:1 MIMO");
491
492 // MIMO 2x2:1: expect that SNR is increased by a factor of 3 dB (10 log 2/1) compared to SISO
493 // thanks to RX diversity
494 txVector.SetNss(1);
495 txVector.SetNTx(2);
496 interference.SetNumberOfReceiveAntennas(2);
497 snr = interference.CalculateSnr(Watt_u{0.001},
498 Watt_u{0.001} / DbToRatio(initialSnr),
499 txVector.GetChannelWidth(),
500 txVector.GetNss());
501 NS_TEST_ASSERT_MSG_EQ_TOL(RatioToDb(snr),
502 initialSnr + dB_u{3.0},
503 tol,
504 "SNR not equal within tolerance for 2x2:1 MIMO");
505 chunkSuccess = interference.CalculatePayloadChunkSuccessRate(snr, duration, txVector);
506 NS_TEST_ASSERT_MSG_GT(chunkSuccess,
507 sisoChunkSuccess,
508 "CSR not within tolerance for 2x2:1 MIMO");
509
510 // MIMO 2x2:2: expect no SNR gain in AWGN channel
511 txVector.SetNss(2);
512 txVector.SetNTx(2);
513 interference.SetNumberOfReceiveAntennas(2);
514 snr = interference.CalculateSnr(Watt_u{0.001},
515 Watt_u{0.001} / DbToRatio(initialSnr),
516 txVector.GetChannelWidth(),
517 txVector.GetNss());
518 NS_TEST_ASSERT_MSG_EQ_TOL(RatioToDb(snr),
519 initialSnr,
520 tol,
521 "SNR not equal within tolerance for 2x2:2 MIMO");
522 chunkSuccess = interference.CalculatePayloadChunkSuccessRate(snr, duration, txVector);
523 NS_TEST_ASSERT_MSG_EQ_TOL(chunkSuccess,
524 sisoChunkSuccess,
525 0.000001,
526 "CSR not within tolerance for 2x2:2 MIMO");
527
528 // MIMO 3x3:1: expect that SNR is increased by a factor of 4.8 dB (10 log 3/1) compared to SISO
529 // thanks to RX diversity
530 txVector.SetNss(1);
531 txVector.SetNTx(3);
532 interference.SetNumberOfReceiveAntennas(3);
533 snr = interference.CalculateSnr(Watt_u{0.001},
534 Watt_u{0.001} / DbToRatio(initialSnr),
535 txVector.GetChannelWidth(),
536 txVector.GetNss());
537 NS_TEST_ASSERT_MSG_EQ_TOL(RatioToDb(snr),
538 initialSnr + dB_u{4.8},
539 tol,
540 "SNR not within tolerance for 3x3:1 MIMO");
541 chunkSuccess = interference.CalculatePayloadChunkSuccessRate(snr, duration, txVector);
542 NS_TEST_ASSERT_MSG_GT(chunkSuccess,
543 sisoChunkSuccess,
544 "CSR not within tolerance for 3x3:1 MIMO");
545
546 // MIMO 3x3:2: expect that SNR is increased by a factor of 1.8 dB (10 log 3/2) compared to SISO
547 // thanks to RX diversity
548 txVector.SetNss(2);
549 txVector.SetNTx(3);
550 interference.SetNumberOfReceiveAntennas(3);
551 snr = interference.CalculateSnr(Watt_u{0.001},
552 Watt_u{0.001} / DbToRatio(initialSnr),
553 txVector.GetChannelWidth(),
554 txVector.GetNss());
555 NS_TEST_ASSERT_MSG_EQ_TOL(RatioToDb(snr),
556 initialSnr + dB_u{1.8},
557 tol,
558 "SNR not within tolerance for 3x3:2 MIMO");
559 chunkSuccess = interference.CalculatePayloadChunkSuccessRate(snr, duration, txVector);
560 NS_TEST_ASSERT_MSG_GT(chunkSuccess,
561 sisoChunkSuccess,
562 "CSR not within tolerance for 3x3:2 MIMO");
563
564 // MIMO 3x3:3: expect no SNR gain in AWGN channel
565 txVector.SetNss(3);
566 txVector.SetNTx(3);
567 interference.SetNumberOfReceiveAntennas(3);
568 snr = interference.CalculateSnr(Watt_u{0.001},
569 Watt_u{0.001} / DbToRatio(initialSnr),
570 txVector.GetChannelWidth(),
571 txVector.GetNss());
572 NS_TEST_ASSERT_MSG_EQ_TOL(RatioToDb(snr),
573 initialSnr,
574 tol,
575 "SNR not within tolerance for 3x3:3 MIMO");
576 chunkSuccess = interference.CalculatePayloadChunkSuccessRate(snr, duration, txVector);
577 NS_TEST_ASSERT_MSG_EQ_TOL(chunkSuccess,
578 sisoChunkSuccess,
579 0.000001,
580 "CSR not equal within tolerance for 3x3:3 MIMO");
581
582 // MIMO 4x4:1: expect that SNR is increased by a factor of 6 dB (10 log 4/1) compared to SISO
583 // thanks to RX diversity
584 txVector.SetNss(1);
585 txVector.SetNTx(4);
586 interference.SetNumberOfReceiveAntennas(4);
587 snr = interference.CalculateSnr(Watt_u{0.001},
588 Watt_u{0.001} / DbToRatio(initialSnr),
589 txVector.GetChannelWidth(),
590 txVector.GetNss());
591 NS_TEST_ASSERT_MSG_EQ_TOL(RatioToDb(snr),
592 initialSnr + dB_u{6.0},
593 tol,
594 "SNR not within tolerance for 4x4:1 MIMO");
595 chunkSuccess = interference.CalculatePayloadChunkSuccessRate(snr, duration, txVector);
596 NS_TEST_ASSERT_MSG_GT(chunkSuccess,
597 sisoChunkSuccess,
598 "CSR not within tolerance for 4x4:1 MIMO");
599
600 // MIMO 4x4:2: expect that SNR is increased by a factor of 3 dB (10 log 4/2) compared to SISO
601 // thanks to RX diversity
602 txVector.SetNss(2);
603 txVector.SetNTx(4);
604 interference.SetNumberOfReceiveAntennas(4);
605 snr = interference.CalculateSnr(Watt_u{0.001},
606 Watt_u{0.001} / DbToRatio(initialSnr),
607 txVector.GetChannelWidth(),
608 txVector.GetNss());
609 NS_TEST_ASSERT_MSG_EQ_TOL(RatioToDb(snr),
610 initialSnr + dB_u{3.0},
611 tol,
612 "SNR not within tolerance for 4x4:2 MIMO");
613 chunkSuccess = interference.CalculatePayloadChunkSuccessRate(snr, duration, txVector);
614 NS_TEST_ASSERT_MSG_GT(chunkSuccess,
615 sisoChunkSuccess,
616 "CSR not within tolerance for 4x4:2 MIMO");
617
618 // MIMO 4x4:3: expect that SNR is increased by a factor of 1.2 dB (10 log 4/3) compared to SISO
619 // thanks to RX diversity
620 txVector.SetNss(3);
621 txVector.SetNTx(4);
622 interference.SetNumberOfReceiveAntennas(4);
623 snr = interference.CalculateSnr(Watt_u{0.001},
624 Watt_u{0.001} / DbToRatio(initialSnr),
625 txVector.GetChannelWidth(),
626 txVector.GetNss());
627 NS_TEST_ASSERT_MSG_EQ_TOL(RatioToDb(snr),
628 initialSnr + dB_u{1.2},
629 tol,
630 "SNR not within tolerance for 4x4:3 MIMO");
631 chunkSuccess = interference.CalculatePayloadChunkSuccessRate(snr, duration, txVector);
632 NS_TEST_ASSERT_MSG_GT(chunkSuccess,
633 sisoChunkSuccess,
634 "CSR not within tolerance for 4x4:1 MIMO");
635
636 // MIMO 4x4:4: expect no SNR gain in AWGN channel
637 txVector.SetNss(4);
638 txVector.SetNTx(4);
639 interference.SetNumberOfReceiveAntennas(4);
640 snr = interference.CalculateSnr(Watt_u{0.001},
641 Watt_u{0.001} / DbToRatio(initialSnr),
642 txVector.GetChannelWidth(),
643 txVector.GetNss());
644 NS_TEST_ASSERT_MSG_EQ_TOL(RatioToDb(snr),
645 initialSnr,
646 tol,
647 "SNR not within tolerance for 4x4:4 MIMO");
648 chunkSuccess = interference.CalculatePayloadChunkSuccessRate(snr, duration, txVector);
649 NS_TEST_ASSERT_MSG_EQ_TOL(chunkSuccess,
650 sisoChunkSuccess,
651 0.000001,
652 "CSR not within tolerance for 4x4:4 MIMO");
653}
654
655/**
656 * map of PER values that have been manually computed for a given MCS, size (in bytes) and SNR (in
657 * dB) in order to verify against the PER calculated by the model
658 */
659std::map<std::pair<uint8_t /* mcs */, uint32_t /* size */>,
660 std::map<dB_u /* snr */, double /* per */>>
661 expectedTableValues = {
662 /* MCS 0 - 1458 bytes */
663 {std::make_pair(0, 1458),
664 {
665 {dB_u{-4.00}, 1.00000}, {dB_u{-3.75}, 1.00000}, {dB_u{-3.50}, 1.00000},
666 {dB_u{-3.25}, 1.00000}, {dB_u{-3.00}, 1.00000}, {dB_u{-2.75}, 1.00000},
667 {dB_u{-2.50}, 1.00000}, {dB_u{-2.25}, 1.00000}, {dB_u{-2.00}, 1.00000},
668 {dB_u{-1.75}, 1.00000}, {dB_u{-1.50}, 1.00000}, {dB_u{-1.25}, 1.00000},
669 {dB_u{-1.00}, 1.00000}, {dB_u{-0.75}, 0.99700}, {dB_u{-0.50}, 0.99400},
670 {dB_u{-0.25}, 0.90625}, {dB_u{0.00}, 0.81850}, {dB_u{0.25}, 0.55465},
671 {dB_u{0.50}, 0.29080}, {dB_u{0.75}, 0.17855}, {dB_u{1.00}, 0.06630},
672 {dB_u{1.25}, 0.03875}, {dB_u{1.50}, 0.01120}, {dB_u{1.75}, 0.00635},
673 {dB_u{2.00}, 0.00150}, {dB_u{2.25}, 0.00083}, {dB_u{2.50}, 0.00015},
674 {dB_u{2.75}, 0.00008}, {dB_u{3.00}, 0.00001}, {dB_u{3.25}, 0.00000},
675 {dB_u{3.50}, 0.00000}, {dB_u{3.75}, 0.00000}, {dB_u{4.00}, 0.00000},
676 {dB_u{4.25}, 0.00000}, {dB_u{4.50}, 0.00000}, {dB_u{4.75}, 0.00000},
677 {dB_u{5.00}, 0.00000}, {dB_u{5.25}, 0.00000}, {dB_u{5.50}, 0.00000},
678 {dB_u{5.75}, 0.00000}, {dB_u{6.00}, 0.00000}, {dB_u{6.25}, 0.00000},
679 {dB_u{6.50}, 0.00000}, {dB_u{6.75}, 0.00000}, {dB_u{7.00}, 0.00000},
680 {dB_u{7.25}, 0.00000}, {dB_u{7.50}, 0.00000}, {dB_u{7.75}, 0.00000},
681 {dB_u{8.00}, 0.00000}, {dB_u{8.25}, 0.00000}, {dB_u{8.50}, 0.00000},
682 {dB_u{8.75}, 0.00000}, {dB_u{9.00}, 0.00000}, {dB_u{9.25}, 0.00000},
683 {dB_u{9.50}, 0.00000}, {dB_u{9.75}, 0.00000}, {dB_u{10.00}, 0.00000},
684 {dB_u{10.25}, 0.00000}, {dB_u{10.50}, 0.00000}, {dB_u{10.75}, 0.00000},
685 {dB_u{11.00}, 0.00000}, {dB_u{11.25}, 0.00000}, {dB_u{11.50}, 0.00000},
686 {dB_u{11.75}, 0.00000}, {dB_u{12.00}, 0.00000}, {dB_u{12.25}, 0.00000},
687 {dB_u{12.50}, 0.00000}, {dB_u{12.75}, 0.00000}, {dB_u{13.00}, 0.00000},
688 {dB_u{13.25}, 0.00000}, {dB_u{13.50}, 0.00000}, {dB_u{13.75}, 0.00000},
689 {dB_u{14.00}, 0.00000}, {dB_u{14.25}, 0.00000}, {dB_u{14.50}, 0.00000},
690 {dB_u{14.75}, 0.00000}, {dB_u{15.00}, 0.00000}, {dB_u{15.25}, 0.00000},
691 {dB_u{15.50}, 0.00000}, {dB_u{15.75}, 0.00000}, {dB_u{16.00}, 0.00000},
692 {dB_u{16.25}, 0.00000}, {dB_u{16.50}, 0.00000}, {dB_u{16.75}, 0.00000},
693 {dB_u{17.00}, 0.00000}, {dB_u{17.25}, 0.00000}, {dB_u{17.50}, 0.00000},
694 {dB_u{17.75}, 0.00000}, {dB_u{18.00}, 0.00000}, {dB_u{18.25}, 0.00000},
695 {dB_u{18.50}, 0.00000}, {dB_u{18.75}, 0.00000}, {dB_u{19.00}, 0.00000},
696 {dB_u{19.25}, 0.00000}, {dB_u{19.50}, 0.00000}, {dB_u{19.75}, 0.00000},
697 {dB_u{20.00}, 0.00000}, {dB_u{20.25}, 0.00000}, {dB_u{20.50}, 0.00000},
698 {dB_u{20.75}, 0.00000}, {dB_u{21.00}, 0.00000}, {dB_u{21.25}, 0.00000},
699 {dB_u{21.50}, 0.00000}, {dB_u{21.75}, 0.00000}, {dB_u{22.00}, 0.00000},
700 {dB_u{22.25}, 0.00000}, {dB_u{22.50}, 0.00000}, {dB_u{22.75}, 0.00000},
701 {dB_u{23.00}, 0.00000}, {dB_u{23.25}, 0.00000}, {dB_u{23.50}, 0.00000},
702 {dB_u{23.75}, 0.00000}, {dB_u{24.00}, 0.00000}, {dB_u{24.25}, 0.00000},
703 {dB_u{24.50}, 0.00000}, {dB_u{24.75}, 0.00000}, {dB_u{25.00}, 0.00000},
704 {dB_u{25.25}, 0.00000}, {dB_u{25.50}, 0.00000}, {dB_u{25.75}, 0.00000},
705 {dB_u{26.00}, 0.00000}, {dB_u{26.25}, 0.00000}, {dB_u{26.50}, 0.00000},
706 {dB_u{26.75}, 0.00000}, {dB_u{27.00}, 0.00000}, {dB_u{27.25}, 0.00000},
707 {dB_u{27.50}, 0.00000}, {dB_u{27.75}, 0.00000}, {dB_u{28.00}, 0.00000},
708 {dB_u{28.25}, 0.00000}, {dB_u{28.50}, 0.00000}, {dB_u{28.75}, 0.00000},
709 {dB_u{29.00}, 0.00000}, {dB_u{29.25}, 0.00000}, {dB_u{29.50}, 0.00000},
710 {dB_u{29.75}, 0.00000}, {dB_u{30.00}, 0.00000},
711 }},
712 /* MCS 0 - 32 bytes */
713 {std::make_pair(0, 32),
714 {
715 {dB_u{-4.00}, 1.00000}, {dB_u{-3.75}, 1.00000}, {dB_u{-3.50}, 1.00000},
716 {dB_u{-3.25}, 0.99750}, {dB_u{-3.00}, 0.99500}, {dB_u{-2.75}, 0.96790},
717 {dB_u{-2.50}, 0.94080}, {dB_u{-2.25}, 0.88335}, {dB_u{-2.00}, 0.82590},
718 {dB_u{-1.75}, 0.70770}, {dB_u{-1.50}, 0.58950}, {dB_u{-1.25}, 0.44890},
719 {dB_u{-1.00}, 0.30830}, {dB_u{-0.75}, 0.21685}, {dB_u{-0.50}, 0.12540},
720 {dB_u{-0.25}, 0.07990}, {dB_u{0.00}, 0.03440}, {dB_u{0.25}, 0.02145},
721 {dB_u{0.50}, 0.00850}, {dB_u{0.75}, 0.00500}, {dB_u{1.00}, 0.00150},
722 {dB_u{1.25}, 0.00087}, {dB_u{1.50}, 0.00024}, {dB_u{1.75}, 0.00017},
723 {dB_u{2.00}, 0.00009}, {dB_u{2.25}, 0.00005}, {dB_u{2.50}, 0.00000},
724 {dB_u{2.75}, 0.00000}, {dB_u{3.00}, 0.00000}, {dB_u{3.25}, 0.00000},
725 {dB_u{3.50}, 0.00000}, {dB_u{3.75}, 0.00000}, {dB_u{4.00}, 0.00000},
726 {dB_u{4.25}, 0.00000}, {dB_u{4.50}, 0.00000}, {dB_u{4.75}, 0.00000},
727 {dB_u{5.00}, 0.00000}, {dB_u{5.25}, 0.00000}, {dB_u{5.50}, 0.00000},
728 {dB_u{5.75}, 0.00000}, {dB_u{6.00}, 0.00000}, {dB_u{6.25}, 0.00000},
729 {dB_u{6.50}, 0.00000}, {dB_u{6.75}, 0.00000}, {dB_u{7.00}, 0.00000},
730 {dB_u{7.25}, 0.00000}, {dB_u{7.50}, 0.00000}, {dB_u{7.75}, 0.00000},
731 {dB_u{8.00}, 0.00000}, {dB_u{8.25}, 0.00000}, {dB_u{8.50}, 0.00000},
732 {dB_u{8.75}, 0.00000}, {dB_u{9.00}, 0.00000}, {dB_u{9.25}, 0.00000},
733 {dB_u{9.50}, 0.00000}, {dB_u{9.75}, 0.00000}, {dB_u{10.00}, 0.00000},
734 {dB_u{10.25}, 0.00000}, {dB_u{10.50}, 0.00000}, {dB_u{10.75}, 0.00000},
735 {dB_u{11.00}, 0.00000}, {dB_u{11.25}, 0.00000}, {dB_u{11.50}, 0.00000},
736 {dB_u{11.75}, 0.00000}, {dB_u{12.00}, 0.00000}, {dB_u{12.25}, 0.00000},
737 {dB_u{12.50}, 0.00000}, {dB_u{12.75}, 0.00000}, {dB_u{13.00}, 0.00000},
738 {dB_u{13.25}, 0.00000}, {dB_u{13.50}, 0.00000}, {dB_u{13.75}, 0.00000},
739 {dB_u{14.00}, 0.00000}, {dB_u{14.25}, 0.00000}, {dB_u{14.50}, 0.00000},
740 {dB_u{14.75}, 0.00000}, {dB_u{15.00}, 0.00000}, {dB_u{15.25}, 0.00000},
741 {dB_u{15.50}, 0.00000}, {dB_u{15.75}, 0.00000}, {dB_u{16.00}, 0.00000},
742 {dB_u{16.25}, 0.00000}, {dB_u{16.50}, 0.00000}, {dB_u{16.75}, 0.00000},
743 {dB_u{17.00}, 0.00000}, {dB_u{17.25}, 0.00000}, {dB_u{17.50}, 0.00000},
744 {dB_u{17.75}, 0.00000}, {dB_u{18.00}, 0.00000}, {dB_u{18.25}, 0.00000},
745 {dB_u{18.50}, 0.00000}, {dB_u{18.75}, 0.00000}, {dB_u{19.00}, 0.00000},
746 {dB_u{19.25}, 0.00000}, {dB_u{19.50}, 0.00000}, {dB_u{19.75}, 0.00000},
747 {dB_u{20.00}, 0.00000}, {dB_u{20.25}, 0.00000}, {dB_u{20.50}, 0.00000},
748 {dB_u{20.75}, 0.00000}, {dB_u{21.00}, 0.00000}, {dB_u{21.25}, 0.00000},
749 {dB_u{21.50}, 0.00000}, {dB_u{21.75}, 0.00000}, {dB_u{22.00}, 0.00000},
750 {dB_u{22.25}, 0.00000}, {dB_u{22.50}, 0.00000}, {dB_u{22.75}, 0.00000},
751 {dB_u{23.00}, 0.00000}, {dB_u{23.25}, 0.00000}, {dB_u{23.50}, 0.00000},
752 {dB_u{23.75}, 0.00000}, {dB_u{24.00}, 0.00000}, {dB_u{24.25}, 0.00000},
753 {dB_u{24.50}, 0.00000}, {dB_u{24.75}, 0.00000}, {dB_u{25.00}, 0.00000},
754 {dB_u{25.25}, 0.00000}, {dB_u{25.50}, 0.00000}, {dB_u{25.75}, 0.00000},
755 {dB_u{26.00}, 0.00000}, {dB_u{26.25}, 0.00000}, {dB_u{26.50}, 0.00000},
756 {dB_u{26.75}, 0.00000}, {dB_u{27.00}, 0.00000}, {dB_u{27.25}, 0.00000},
757 {dB_u{27.50}, 0.00000}, {dB_u{27.75}, 0.00000}, {dB_u{28.00}, 0.00000},
758 {dB_u{28.25}, 0.00000}, {dB_u{28.50}, 0.00000}, {dB_u{28.75}, 0.00000},
759 {dB_u{29.00}, 0.00000}, {dB_u{29.25}, 0.00000}, {dB_u{29.50}, 0.00000},
760 {dB_u{29.75}, 0.00000}, {dB_u{30.00}, 0.00000},
761 }},
762 /* MCS 0 - 1000 bytes */
763 {std::make_pair(0, 1000),
764 {
765 {dB_u{-4.00}, 1.00000}, {dB_u{-3.75}, 1.00000}, {dB_u{-3.50}, 1.00000},
766 {dB_u{-3.25}, 1.00000}, {dB_u{-3.00}, 1.00000}, {dB_u{-2.75}, 1.00000},
767 {dB_u{-2.50}, 1.00000}, {dB_u{-2.25}, 1.00000}, {dB_u{-2.00}, 1.00000},
768 {dB_u{-1.75}, 1.00000}, {dB_u{-1.50}, 1.00000}, {dB_u{-1.25}, 1.00000},
769 {dB_u{-1.00}, 1.00000}, {dB_u{-0.75}, 0.98140}, {dB_u{-0.50}, 0.97007},
770 {dB_u{-0.25}, 0.80280}, {dB_u{0.00}, 0.68977}, {dB_u{0.25}, 0.42581},
771 {dB_u{0.50}, 0.20997}, {dB_u{0.75}, 0.12620}, {dB_u{1.00}, 0.04596},
772 {dB_u{1.25}, 0.02674}, {dB_u{1.50}, 0.00770}, {dB_u{1.75}, 0.00436},
773 {dB_u{2.00}, 0.00103}, {dB_u{2.25}, 0.00057}, {dB_u{2.50}, 0.00010},
774 {dB_u{2.75}, 0.00005}, {dB_u{3.00}, 0.00001}, {dB_u{3.25}, 0.00000},
775 {dB_u{3.50}, 0.00000}, {dB_u{3.75}, 0.00000}, {dB_u{4.00}, 0.00000},
776 {dB_u{4.25}, 0.00000}, {dB_u{4.50}, 0.00000}, {dB_u{4.75}, 0.00000},
777 {dB_u{5.00}, 0.00000}, {dB_u{5.25}, 0.00000}, {dB_u{5.50}, 0.00000},
778 {dB_u{5.75}, 0.00000}, {dB_u{6.00}, 0.00000}, {dB_u{6.25}, 0.00000},
779 {dB_u{6.50}, 0.00000}, {dB_u{6.75}, 0.00000}, {dB_u{7.00}, 0.00000},
780 {dB_u{7.25}, 0.00000}, {dB_u{7.50}, 0.00000}, {dB_u{7.75}, 0.00000},
781 {dB_u{8.00}, 0.00000}, {dB_u{8.25}, 0.00000}, {dB_u{8.50}, 0.00000},
782 {dB_u{8.75}, 0.00000}, {dB_u{9.00}, 0.00000}, {dB_u{9.25}, 0.00000},
783 {dB_u{9.50}, 0.00000}, {dB_u{9.75}, 0.00000}, {dB_u{10.00}, 0.00000},
784 {dB_u{10.25}, 0.00000}, {dB_u{10.50}, 0.00000}, {dB_u{10.75}, 0.00000},
785 {dB_u{11.00}, 0.00000}, {dB_u{11.25}, 0.00000}, {dB_u{11.50}, 0.00000},
786 {dB_u{11.75}, 0.00000}, {dB_u{12.00}, 0.00000}, {dB_u{12.25}, 0.00000},
787 {dB_u{12.50}, 0.00000}, {dB_u{12.75}, 0.00000}, {dB_u{13.00}, 0.00000},
788 {dB_u{13.25}, 0.00000}, {dB_u{13.50}, 0.00000}, {dB_u{13.75}, 0.00000},
789 {dB_u{14.00}, 0.00000}, {dB_u{14.25}, 0.00000}, {dB_u{14.50}, 0.00000},
790 {dB_u{14.75}, 0.00000}, {dB_u{15.00}, 0.00000}, {dB_u{15.25}, 0.00000},
791 {dB_u{15.50}, 0.00000}, {dB_u{15.75}, 0.00000}, {dB_u{16.00}, 0.00000},
792 {dB_u{16.25}, 0.00000}, {dB_u{16.50}, 0.00000}, {dB_u{16.75}, 0.00000},
793 {dB_u{17.00}, 0.00000}, {dB_u{17.25}, 0.00000}, {dB_u{17.50}, 0.00000},
794 {dB_u{17.75}, 0.00000}, {dB_u{18.00}, 0.00000}, {dB_u{18.25}, 0.00000},
795 {dB_u{18.50}, 0.00000}, {dB_u{18.75}, 0.00000}, {dB_u{19.00}, 0.00000},
796 {dB_u{19.25}, 0.00000}, {dB_u{19.50}, 0.00000}, {dB_u{19.75}, 0.00000},
797 {dB_u{20.00}, 0.00000}, {dB_u{20.25}, 0.00000}, {dB_u{20.50}, 0.00000},
798 {dB_u{20.75}, 0.00000}, {dB_u{21.00}, 0.00000}, {dB_u{21.25}, 0.00000},
799 {dB_u{21.50}, 0.00000}, {dB_u{21.75}, 0.00000}, {dB_u{22.00}, 0.00000},
800 {dB_u{22.25}, 0.00000}, {dB_u{22.50}, 0.00000}, {dB_u{22.75}, 0.00000},
801 {dB_u{23.00}, 0.00000}, {dB_u{23.25}, 0.00000}, {dB_u{23.50}, 0.00000},
802 {dB_u{23.75}, 0.00000}, {dB_u{24.00}, 0.00000}, {dB_u{24.25}, 0.00000},
803 {dB_u{24.50}, 0.00000}, {dB_u{24.75}, 0.00000}, {dB_u{25.00}, 0.00000},
804 {dB_u{25.25}, 0.00000}, {dB_u{25.50}, 0.00000}, {dB_u{25.75}, 0.00000},
805 {dB_u{26.00}, 0.00000}, {dB_u{26.25}, 0.00000}, {dB_u{26.50}, 0.00000},
806 {dB_u{26.75}, 0.00000}, {dB_u{27.00}, 0.00000}, {dB_u{27.25}, 0.00000},
807 {dB_u{27.50}, 0.00000}, {dB_u{27.75}, 0.00000}, {dB_u{28.00}, 0.00000},
808 {dB_u{28.25}, 0.00000}, {dB_u{28.50}, 0.00000}, {dB_u{28.75}, 0.00000},
809 {dB_u{29.00}, 0.00000}, {dB_u{29.25}, 0.00000}, {dB_u{29.50}, 0.00000},
810 {dB_u{29.75}, 0.00000}, {dB_u{30.00}, 0.00000},
811 }},
812 /* MCS 0 - 1 byte */
813 {std::make_pair(0, 1),
814 {
815 {dB_u{-4.00}, 1.00000}, {dB_u{-3.75}, 1.00000}, {dB_u{-3.50}, 1.00000},
816 {dB_u{-3.25}, 0.17075}, {dB_u{-3.00}, 0.15260}, {dB_u{-2.75}, 0.10190},
817 {dB_u{-2.50}, 0.08455}, {dB_u{-2.25}, 0.06494}, {dB_u{-2.00}, 0.05316},
818 {dB_u{-1.75}, 0.03771}, {dB_u{-1.50}, 0.02744}, {dB_u{-1.25}, 0.01845},
819 {dB_u{-1.00}, 0.01145}, {dB_u{-0.75}, 0.00761}, {dB_u{-0.50}, 0.00418},
820 {dB_u{-0.25}, 0.00260}, {dB_u{0.00}, 0.00110}, {dB_u{0.25}, 0.00068},
821 {dB_u{0.50}, 0.00027}, {dB_u{0.75}, 0.00016}, {dB_u{1.00}, 0.00005},
822 {dB_u{1.25}, 0.00003}, {dB_u{1.50}, 0.00000}, {dB_u{1.75}, 0.00000},
823 {dB_u{2.00}, 0.00000}, {dB_u{2.25}, 0.00000}, {dB_u{2.50}, 0.00000},
824 {dB_u{2.75}, 0.00000}, {dB_u{3.00}, 0.00000}, {dB_u{3.25}, 0.00000},
825 {dB_u{3.50}, 0.00000}, {dB_u{3.75}, 0.00000}, {dB_u{4.00}, 0.00000},
826 {dB_u{4.25}, 0.00000}, {dB_u{4.50}, 0.00000}, {dB_u{4.75}, 0.00000},
827 {dB_u{5.00}, 0.00000}, {dB_u{5.25}, 0.00000}, {dB_u{5.50}, 0.00000},
828 {dB_u{5.75}, 0.00000}, {dB_u{6.00}, 0.00000}, {dB_u{6.25}, 0.00000},
829 {dB_u{6.50}, 0.00000}, {dB_u{6.75}, 0.00000}, {dB_u{7.00}, 0.00000},
830 {dB_u{7.25}, 0.00000}, {dB_u{7.50}, 0.00000}, {dB_u{7.75}, 0.00000},
831 {dB_u{8.00}, 0.00000}, {dB_u{8.25}, 0.00000}, {dB_u{8.50}, 0.00000},
832 {dB_u{8.75}, 0.00000}, {dB_u{9.00}, 0.00000}, {dB_u{9.25}, 0.00000},
833 {dB_u{9.50}, 0.00000}, {dB_u{9.75}, 0.00000}, {dB_u{10.00}, 0.00000},
834 {dB_u{10.25}, 0.00000}, {dB_u{10.50}, 0.00000}, {dB_u{10.75}, 0.00000},
835 {dB_u{11.00}, 0.00000}, {dB_u{11.25}, 0.00000}, {dB_u{11.50}, 0.00000},
836 {dB_u{11.75}, 0.00000}, {dB_u{12.00}, 0.00000}, {dB_u{12.25}, 0.00000},
837 {dB_u{12.50}, 0.00000}, {dB_u{12.75}, 0.00000}, {dB_u{13.00}, 0.00000},
838 {dB_u{13.25}, 0.00000}, {dB_u{13.50}, 0.00000}, {dB_u{13.75}, 0.00000},
839 {dB_u{14.00}, 0.00000}, {dB_u{14.25}, 0.00000}, {dB_u{14.50}, 0.00000},
840 {dB_u{14.75}, 0.00000}, {dB_u{15.00}, 0.00000}, {dB_u{15.25}, 0.00000},
841 {dB_u{15.50}, 0.00000}, {dB_u{15.75}, 0.00000}, {dB_u{16.00}, 0.00000},
842 {dB_u{16.25}, 0.00000}, {dB_u{16.50}, 0.00000}, {dB_u{16.75}, 0.00000},
843 {dB_u{17.00}, 0.00000}, {dB_u{17.25}, 0.00000}, {dB_u{17.50}, 0.00000},
844 {dB_u{17.75}, 0.00000}, {dB_u{18.00}, 0.00000}, {dB_u{18.25}, 0.00000},
845 {dB_u{18.50}, 0.00000}, {dB_u{18.75}, 0.00000}, {dB_u{19.00}, 0.00000},
846 {dB_u{19.25}, 0.00000}, {dB_u{19.50}, 0.00000}, {dB_u{19.75}, 0.00000},
847 {dB_u{20.00}, 0.00000}, {dB_u{20.25}, 0.00000}, {dB_u{20.50}, 0.00000},
848 {dB_u{20.75}, 0.00000}, {dB_u{21.00}, 0.00000}, {dB_u{21.25}, 0.00000},
849 {dB_u{21.50}, 0.00000}, {dB_u{21.75}, 0.00000}, {dB_u{22.00}, 0.00000},
850 {dB_u{22.25}, 0.00000}, {dB_u{22.50}, 0.00000}, {dB_u{22.75}, 0.00000},
851 {dB_u{23.00}, 0.00000}, {dB_u{23.25}, 0.00000}, {dB_u{23.50}, 0.00000},
852 {dB_u{23.75}, 0.00000}, {dB_u{24.00}, 0.00000}, {dB_u{24.25}, 0.00000},
853 {dB_u{24.50}, 0.00000}, {dB_u{24.75}, 0.00000}, {dB_u{25.00}, 0.00000},
854 {dB_u{25.25}, 0.00000}, {dB_u{25.50}, 0.00000}, {dB_u{25.75}, 0.00000},
855 {dB_u{26.00}, 0.00000}, {dB_u{26.25}, 0.00000}, {dB_u{26.50}, 0.00000},
856 {dB_u{26.75}, 0.00000}, {dB_u{27.00}, 0.00000}, {dB_u{27.25}, 0.00000},
857 {dB_u{27.50}, 0.00000}, {dB_u{27.75}, 0.00000}, {dB_u{28.00}, 0.00000},
858 {dB_u{28.25}, 0.00000}, {dB_u{28.50}, 0.00000}, {dB_u{28.75}, 0.00000},
859 {dB_u{29.00}, 0.00000}, {dB_u{29.25}, 0.00000}, {dB_u{29.50}, 0.00000},
860 {dB_u{29.75}, 0.00000}, {dB_u{30.00}, 0.00000},
861 }},
862 /* MCS 0 - 2000 bytes */
863 {std::make_pair(0, 2000),
864 {
865 {dB_u{-4.00}, 1.00000}, {dB_u{-3.75}, 1.00000}, {dB_u{-3.50}, 1.00000},
866 {dB_u{-3.25}, 1.00000}, {dB_u{-3.00}, 1.00000}, {dB_u{-2.75}, 1.00000},
867 {dB_u{-2.50}, 1.00000}, {dB_u{-2.25}, 1.00000}, {dB_u{-2.00}, 1.00000},
868 {dB_u{-1.75}, 1.00000}, {dB_u{-1.50}, 1.00000}, {dB_u{-1.25}, 1.00000},
869 {dB_u{-1.00}, 1.00000}, {dB_u{-0.75}, 0.99965}, {dB_u{-0.50}, 0.99910},
870 {dB_u{-0.25}, 0.96111}, {dB_u{0.00}, 0.90376}, {dB_u{0.25}, 0.67031},
871 {dB_u{0.50}, 0.37584}, {dB_u{0.75}, 0.23647}, {dB_u{1.00}, 0.08981},
872 {dB_u{1.25}, 0.05277}, {dB_u{1.50}, 0.01533}, {dB_u{1.75}, 0.00870},
873 {dB_u{2.00}, 0.00206}, {dB_u{2.25}, 0.00113}, {dB_u{2.50}, 0.00021},
874 {dB_u{2.75}, 0.00011}, {dB_u{3.00}, 0.00001}, {dB_u{3.25}, 0.00000},
875 {dB_u{3.50}, 0.00000}, {dB_u{3.75}, 0.00000}, {dB_u{4.00}, 0.00000},
876 {dB_u{4.25}, 0.00000}, {dB_u{4.50}, 0.00000}, {dB_u{4.75}, 0.00000},
877 {dB_u{5.00}, 0.00000}, {dB_u{5.25}, 0.00000}, {dB_u{5.50}, 0.00000},
878 {dB_u{5.75}, 0.00000}, {dB_u{6.00}, 0.00000}, {dB_u{6.25}, 0.00000},
879 {dB_u{6.50}, 0.00000}, {dB_u{6.75}, 0.00000}, {dB_u{7.00}, 0.00000},
880 {dB_u{7.25}, 0.00000}, {dB_u{7.50}, 0.00000}, {dB_u{7.75}, 0.00000},
881 {dB_u{8.00}, 0.00000}, {dB_u{8.25}, 0.00000}, {dB_u{8.50}, 0.00000},
882 {dB_u{8.75}, 0.00000}, {dB_u{9.00}, 0.00000}, {dB_u{9.25}, 0.00000},
883 {dB_u{9.50}, 0.00000}, {dB_u{9.75}, 0.00000}, {dB_u{10.00}, 0.00000},
884 {dB_u{10.25}, 0.00000}, {dB_u{10.50}, 0.00000}, {dB_u{10.75}, 0.00000},
885 {dB_u{11.00}, 0.00000}, {dB_u{11.25}, 0.00000}, {dB_u{11.50}, 0.00000},
886 {dB_u{11.75}, 0.00000}, {dB_u{12.00}, 0.00000}, {dB_u{12.25}, 0.00000},
887 {dB_u{12.50}, 0.00000}, {dB_u{12.75}, 0.00000}, {dB_u{13.00}, 0.00000},
888 {dB_u{13.25}, 0.00000}, {dB_u{13.50}, 0.00000}, {dB_u{13.75}, 0.00000},
889 {dB_u{14.00}, 0.00000}, {dB_u{14.25}, 0.00000}, {dB_u{14.50}, 0.00000},
890 {dB_u{14.75}, 0.00000}, {dB_u{15.00}, 0.00000}, {dB_u{15.25}, 0.00000},
891 {dB_u{15.50}, 0.00000}, {dB_u{15.75}, 0.00000}, {dB_u{16.00}, 0.00000},
892 {dB_u{16.25}, 0.00000}, {dB_u{16.50}, 0.00000}, {dB_u{16.75}, 0.00000},
893 {dB_u{17.00}, 0.00000}, {dB_u{17.25}, 0.00000}, {dB_u{17.50}, 0.00000},
894 {dB_u{17.75}, 0.00000}, {dB_u{18.00}, 0.00000}, {dB_u{18.25}, 0.00000},
895 {dB_u{18.50}, 0.00000}, {dB_u{18.75}, 0.00000}, {dB_u{19.00}, 0.00000},
896 {dB_u{19.25}, 0.00000}, {dB_u{19.50}, 0.00000}, {dB_u{19.75}, 0.00000},
897 {dB_u{20.00}, 0.00000}, {dB_u{20.25}, 0.00000}, {dB_u{20.50}, 0.00000},
898 {dB_u{20.75}, 0.00000}, {dB_u{21.00}, 0.00000}, {dB_u{21.25}, 0.00000},
899 {dB_u{21.50}, 0.00000}, {dB_u{21.75}, 0.00000}, {dB_u{22.00}, 0.00000},
900 {dB_u{22.25}, 0.00000}, {dB_u{22.50}, 0.00000}, {dB_u{22.75}, 0.00000},
901 {dB_u{23.00}, 0.00000}, {dB_u{23.25}, 0.00000}, {dB_u{23.50}, 0.00000},
902 {dB_u{23.75}, 0.00000}, {dB_u{24.00}, 0.00000}, {dB_u{24.25}, 0.00000},
903 {dB_u{24.50}, 0.00000}, {dB_u{24.75}, 0.00000}, {dB_u{25.00}, 0.00000},
904 {dB_u{25.25}, 0.00000}, {dB_u{25.50}, 0.00000}, {dB_u{25.75}, 0.00000},
905 {dB_u{26.00}, 0.00000}, {dB_u{26.25}, 0.00000}, {dB_u{26.50}, 0.00000},
906 {dB_u{26.75}, 0.00000}, {dB_u{27.00}, 0.00000}, {dB_u{27.25}, 0.00000},
907 {dB_u{27.50}, 0.00000}, {dB_u{27.75}, 0.00000}, {dB_u{28.00}, 0.00000},
908 {dB_u{28.25}, 0.00000}, {dB_u{28.50}, 0.00000}, {dB_u{28.75}, 0.00000},
909 {dB_u{29.00}, 0.00000}, {dB_u{29.25}, 0.00000}, {dB_u{29.50}, 0.00000},
910 {dB_u{29.75}, 0.00000}, {dB_u{30.00}, 0.00000},
911 }},
912 /* MCS 7 - 1500 bytes */
913 {std::make_pair(7, 1500),
914 {
915 {dB_u{-4.00}, 1.00000}, {dB_u{-3.75}, 1.00000}, {dB_u{-3.50}, 1.00000},
916 {dB_u{-3.25}, 1.00000}, {dB_u{-3.00}, 1.00000}, {dB_u{-2.75}, 1.00000},
917 {dB_u{-2.50}, 1.00000}, {dB_u{-2.25}, 1.00000}, {dB_u{-2.00}, 1.00000},
918 {dB_u{-1.75}, 1.00000}, {dB_u{-1.50}, 1.00000}, {dB_u{-1.25}, 1.00000},
919 {dB_u{-1.00}, 1.00000}, {dB_u{-0.75}, 1.00000}, {dB_u{-0.50}, 1.00000},
920 {dB_u{-0.25}, 1.00000}, {dB_u{0.00}, 1.00000}, {dB_u{0.25}, 1.00000},
921 {dB_u{0.50}, 1.00000}, {dB_u{0.75}, 1.00000}, {dB_u{1.00}, 1.00000},
922 {dB_u{1.25}, 1.00000}, {dB_u{1.50}, 1.00000}, {dB_u{1.75}, 1.00000},
923 {dB_u{2.00}, 1.00000}, {dB_u{2.25}, 1.00000}, {dB_u{2.50}, 1.00000},
924 {dB_u{2.75}, 1.00000}, {dB_u{3.00}, 1.00000}, {dB_u{3.25}, 1.00000},
925 {dB_u{3.50}, 1.00000}, {dB_u{3.75}, 1.00000}, {dB_u{4.00}, 1.00000},
926 {dB_u{4.25}, 1.00000}, {dB_u{4.50}, 1.00000}, {dB_u{4.75}, 1.00000},
927 {dB_u{5.00}, 1.00000}, {dB_u{5.25}, 1.00000}, {dB_u{5.50}, 1.00000},
928 {dB_u{5.75}, 1.00000}, {dB_u{6.00}, 1.00000}, {dB_u{6.25}, 1.00000},
929 {dB_u{6.50}, 1.00000}, {dB_u{6.75}, 1.00000}, {dB_u{7.00}, 1.00000},
930 {dB_u{7.25}, 1.00000}, {dB_u{7.50}, 1.00000}, {dB_u{7.75}, 1.00000},
931 {dB_u{8.00}, 1.00000}, {dB_u{8.25}, 1.00000}, {dB_u{8.50}, 1.00000},
932 {dB_u{8.75}, 1.00000}, {dB_u{9.00}, 1.00000}, {dB_u{9.25}, 1.00000},
933 {dB_u{9.50}, 1.00000}, {dB_u{9.75}, 1.00000}, {dB_u{10.00}, 1.00000},
934 {dB_u{10.25}, 1.00000}, {dB_u{10.50}, 1.00000}, {dB_u{10.75}, 1.00000},
935 {dB_u{11.00}, 1.00000}, {dB_u{11.25}, 1.00000}, {dB_u{11.50}, 1.00000},
936 {dB_u{11.75}, 1.00000}, {dB_u{12.00}, 1.00000}, {dB_u{12.25}, 1.00000},
937 {dB_u{12.50}, 1.00000}, {dB_u{12.75}, 1.00000}, {dB_u{13.00}, 1.00000},
938 {dB_u{13.25}, 1.00000}, {dB_u{13.50}, 1.00000}, {dB_u{13.75}, 1.00000},
939 {dB_u{14.00}, 1.00000}, {dB_u{14.25}, 1.00000}, {dB_u{14.50}, 1.00000},
940 {dB_u{14.75}, 1.00000}, {dB_u{15.00}, 1.00000}, {dB_u{15.25}, 1.00000},
941 {dB_u{15.50}, 1.00000}, {dB_u{15.75}, 1.00000}, {dB_u{16.00}, 1.00000},
942 {dB_u{16.25}, 1.00000}, {dB_u{16.50}, 1.00000}, {dB_u{16.75}, 1.00000},
943 {dB_u{17.00}, 1.00000}, {dB_u{17.25}, 1.00000}, {dB_u{17.50}, 1.00000},
944 {dB_u{17.75}, 0.99057}, {dB_u{18.00}, 0.98075}, {dB_u{18.25}, 0.86664},
945 {dB_u{18.50}, 0.74920}, {dB_u{18.75}, 0.54857}, {dB_u{19.00}, 0.34531},
946 {dB_u{19.25}, 0.23624}, {dB_u{19.50}, 0.12672}, {dB_u{19.75}, 0.08164},
947 {dB_u{20.00}, 0.03650}, {dB_u{20.25}, 0.02340}, {dB_u{20.50}, 0.01029},
948 {dB_u{20.75}, 0.00653}, {dB_u{21.00}, 0.00278}, {dB_u{21.25}, 0.00165},
949 {dB_u{21.50}, 0.00051}, {dB_u{21.75}, 0.00030}, {dB_u{22.00}, 0.00009},
950 {dB_u{22.25}, 0.00005}, {dB_u{22.50}, 0.00001}, {dB_u{22.75}, 0.00000},
951 {dB_u{23.00}, 0.00000}, {dB_u{23.25}, 0.00000}, {dB_u{23.50}, 0.00000},
952 {dB_u{23.75}, 0.00000}, {dB_u{24.00}, 0.00000}, {dB_u{24.25}, 0.00000},
953 {dB_u{24.50}, 0.00000}, {dB_u{24.75}, 0.00000}, {dB_u{25.00}, 0.00000},
954 {dB_u{25.25}, 0.00000}, {dB_u{25.50}, 0.00000}, {dB_u{25.75}, 0.00000},
955 {dB_u{26.00}, 0.00000}, {dB_u{26.25}, 0.00000}, {dB_u{26.50}, 0.00000},
956 {dB_u{26.75}, 0.00000}, {dB_u{27.00}, 0.00000}, {dB_u{27.25}, 0.00000},
957 {dB_u{27.50}, 0.00000}, {dB_u{27.75}, 0.00000}, {dB_u{28.00}, 0.00000},
958 {dB_u{28.25}, 0.00000}, {dB_u{28.50}, 0.00000}, {dB_u{28.75}, 0.00000},
959 {dB_u{29.00}, 0.00000}, {dB_u{29.25}, 0.00000}, {dB_u{29.50}, 0.00000},
960 {dB_u{29.75}, 0.00000}, {dB_u{30.00}, 0.00000},
961 }},
962 /* MCS 8 - 1500 bytes */
963 {std::make_pair(8, 1500),
964 {
965 {dB_u{-4.00}, 1.00000}, {dB_u{-3.75}, 1.00000}, {dB_u{-3.50}, 1.00000},
966 {dB_u{-3.25}, 1.00000}, {dB_u{-3.00}, 1.00000}, {dB_u{-2.75}, 1.00000},
967 {dB_u{-2.50}, 1.00000}, {dB_u{-2.25}, 1.00000}, {dB_u{-2.00}, 1.00000},
968 {dB_u{-1.75}, 1.00000}, {dB_u{-1.50}, 1.00000}, {dB_u{-1.25}, 1.00000},
969 {dB_u{-1.00}, 1.00000}, {dB_u{-0.75}, 1.00000}, {dB_u{-0.50}, 1.00000},
970 {dB_u{-0.25}, 1.00000}, {dB_u{0.00}, 1.00000}, {dB_u{0.25}, 1.00000},
971 {dB_u{0.50}, 1.00000}, {dB_u{0.75}, 1.00000}, {dB_u{1.00}, 1.00000},
972 {dB_u{1.25}, 1.00000}, {dB_u{1.50}, 1.00000}, {dB_u{1.75}, 1.00000},
973 {dB_u{2.00}, 1.00000}, {dB_u{2.25}, 1.00000}, {dB_u{2.50}, 1.00000},
974 {dB_u{2.75}, 1.00000}, {dB_u{3.00}, 1.00000}, {dB_u{3.25}, 1.00000},
975 {dB_u{3.50}, 1.00000}, {dB_u{3.75}, 1.00000}, {dB_u{4.00}, 1.00000},
976 {dB_u{4.25}, 1.00000}, {dB_u{4.50}, 1.00000}, {dB_u{4.75}, 1.00000},
977 {dB_u{5.00}, 1.00000}, {dB_u{5.25}, 1.00000}, {dB_u{5.50}, 1.00000},
978 {dB_u{5.75}, 1.00000}, {dB_u{6.00}, 1.00000}, {dB_u{6.25}, 1.00000},
979 {dB_u{6.50}, 1.00000}, {dB_u{6.75}, 1.00000}, {dB_u{7.00}, 1.00000},
980 {dB_u{7.25}, 1.00000}, {dB_u{7.50}, 1.00000}, {dB_u{7.75}, 1.00000},
981 {dB_u{8.00}, 1.00000}, {dB_u{8.25}, 1.00000}, {dB_u{8.50}, 1.00000},
982 {dB_u{8.75}, 1.00000}, {dB_u{9.00}, 1.00000}, {dB_u{9.25}, 1.00000},
983 {dB_u{9.50}, 1.00000}, {dB_u{9.75}, 1.00000}, {dB_u{10.00}, 1.00000},
984 {dB_u{10.25}, 1.00000}, {dB_u{10.50}, 1.00000}, {dB_u{10.75}, 1.00000},
985 {dB_u{11.00}, 1.00000}, {dB_u{11.25}, 1.00000}, {dB_u{11.50}, 1.00000},
986 {dB_u{11.75}, 1.00000}, {dB_u{12.00}, 1.00000}, {dB_u{12.25}, 1.00000},
987 {dB_u{12.50}, 1.00000}, {dB_u{12.75}, 1.00000}, {dB_u{13.00}, 1.00000},
988 {dB_u{13.25}, 1.00000}, {dB_u{13.50}, 1.00000}, {dB_u{13.75}, 1.00000},
989 {dB_u{14.00}, 1.00000}, {dB_u{14.25}, 1.00000}, {dB_u{14.50}, 1.00000},
990 {dB_u{14.75}, 1.00000}, {dB_u{15.00}, 1.00000}, {dB_u{15.25}, 1.00000},
991 {dB_u{15.50}, 1.00000}, {dB_u{15.75}, 1.00000}, {dB_u{16.00}, 1.00000},
992 {dB_u{16.25}, 1.00000}, {dB_u{16.50}, 1.00000}, {dB_u{16.75}, 1.00000},
993 {dB_u{17.00}, 1.00000}, {dB_u{17.25}, 1.00000}, {dB_u{17.50}, 1.00000},
994 {dB_u{17.75}, 1.00000}, {dB_u{18.00}, 1.00000}, {dB_u{18.25}, 1.00000},
995 {dB_u{18.50}, 1.00000}, {dB_u{18.75}, 1.00000}, {dB_u{19.00}, 1.00000},
996 {dB_u{19.25}, 1.00000}, {dB_u{19.50}, 1.00000}, {dB_u{19.75}, 1.00000},
997 {dB_u{20.00}, 1.00000}, {dB_u{20.25}, 1.00000}, {dB_u{20.50}, 1.00000},
998 {dB_u{20.75}, 1.00000}, {dB_u{21.00}, 1.00000}, {dB_u{21.25}, 0.99918},
999 {dB_u{21.50}, 0.99833}, {dB_u{21.75}, 0.97191}, {dB_u{22.00}, 0.94458},
1000 {dB_u{22.25}, 0.81436}, {dB_u{22.50}, 0.68127}, {dB_u{22.75}, 0.52168},
1001 {dB_u{23.00}, 0.36056}, {dB_u{23.25}, 0.25114}, {dB_u{23.50}, 0.14127},
1002 {dB_u{23.75}, 0.09509}, {dB_u{24.00}, 0.04883}, {dB_u{24.25}, 0.03234},
1003 {dB_u{24.50}, 0.01584}, {dB_u{24.75}, 0.01060}, {dB_u{25.00}, 0.00535},
1004 {dB_u{25.25}, 0.00345}, {dB_u{25.50}, 0.00154}, {dB_u{25.75}, 0.00096},
1005 {dB_u{26.00}, 0.00037}, {dB_u{26.25}, 0.00022}, {dB_u{26.50}, 0.00007},
1006 {dB_u{26.75}, 0.00004}, {dB_u{27.00}, 0.00000}, {dB_u{27.25}, 0.00000},
1007 {dB_u{27.50}, 0.00000}, {dB_u{27.75}, 0.00000}, {dB_u{28.00}, 0.00000},
1008 {dB_u{28.25}, 0.00000}, {dB_u{28.50}, 0.00000}, {dB_u{28.75}, 0.00000},
1009 {dB_u{29.00}, 0.00000}, {dB_u{29.25}, 0.00000}, {dB_u{29.50}, 0.00000},
1010 {dB_u{29.75}, 0.00000}, {dB_u{30.00}, 0.00000},
1011 }},
1012};
1013
1014/**
1015 * @ingroup wifi-test
1016 * @ingroup tests
1017 *
1018 * @brief Wifi Table-based Error Rate Models Test Case
1019 */
1020class TableBasedErrorRateTestCase : public TestCase
1021{
1022 public:
1023 /**
1024 * Constructor
1025 *
1026 * @param testName the test name
1027 * @param mode the WifiMode to use for the test
1028 * @param size the number of bytes to use for the test
1029 */
1030 TableBasedErrorRateTestCase(const std::string& testName, WifiMode mode, uint32_t size);
1031 ~TableBasedErrorRateTestCase() override;
1032
1033 private:
1034 void DoRun() override;
1035
1036 std::string m_testName; ///< The name of the test to run
1037 WifiMode m_mode; ///< The WifiMode to test
1038 uint32_t m_size; ///< The size (in bytes) to test
1039};
1040
1041TableBasedErrorRateTestCase::TableBasedErrorRateTestCase(const std::string& testName,
1042 WifiMode mode,
1043 uint32_t size)
1044 : TestCase(testName),
1045 m_testName(testName),
1046 m_mode(mode),
1047 m_size(size)
1048{
1049}
1050
1054
1055void
1056TableBasedErrorRateTestCase::DoRun()
1057{
1058 // LogComponentEnable ("WifiErrorRateModelsTest", LOG_LEVEL_ALL);
1059 // LogComponentEnable ("TableBasedErrorRateModel", LOG_LEVEL_ALL);
1060 // LogComponentEnable ("YansErrorRateModel", LOG_LEVEL_ALL);
1061
1062 Ptr<TableBasedErrorRateModel> table = CreateObject<TableBasedErrorRateModel>();
1063 WifiTxVector txVector;
1064 txVector.SetMode(m_mode);
1065
1066 // Spot test some values returned from TableBasedErrorRateModel
1067 for (dB_u snr = -4; snr <= dB_u{30}; snr += dB_u{0.25})
1068 {
1069 double expectedValue = 0;
1070 if (m_mode.GetMcsValue() > ERROR_TABLE_BCC_MAX_NUM_MCS)
1071 {
1072 Ptr<YansErrorRateModel> yans = CreateObject<YansErrorRateModel>();
1073 expectedValue =
1074 1 - yans->GetChunkSuccessRate(m_mode, txVector, std::pow(10, snr / 10), m_size * 8);
1075 }
1076 else
1077 {
1078 auto it = expectedTableValues.find(std::make_pair(m_mode.GetMcsValue(), m_size));
1079 if (it != expectedTableValues.end())
1080 {
1081 auto itValue = it->second.find(snr);
1082 if (itValue != it->second.end())
1083 {
1084 expectedValue = itValue->second;
1085 }
1086 else
1087 {
1088 NS_FATAL_ERROR("SNR value " << snr << " dB not found!");
1089 }
1090 }
1091 else
1092 {
1093 NS_FATAL_ERROR("No expected value found for the combination MCS "
1094 << +m_mode.GetMcsValue() << " and size " << m_size << " bytes");
1095 }
1096 }
1097 const auto per =
1098 1 - table->GetChunkSuccessRate(m_mode, txVector, std::pow(10, snr / 10), m_size * 8);
1099 NS_LOG_INFO(m_testName << ": snr=" << snr << "dB per=" << per
1100 << " expectedPER=" << expectedValue);
1101 NS_TEST_ASSERT_MSG_EQ_TOL(per, expectedValue, 1e-5, "Not equal within tolerance");
1102 }
1103}
1104
1105/**
1106 * @ingroup wifi-test
1107 * @ingroup tests
1108 *
1109 * @brief Wifi Error Rate Models Test Suite
1110 */
1111class WifiErrorRateModelsTestSuite : public TestSuite
1112{
1113 public:
1114 WifiErrorRateModelsTestSuite();
1115};
1116
1117WifiErrorRateModelsTestSuite::WifiErrorRateModelsTestSuite()
1118 : TestSuite("wifi-error-rate-models", Type::UNIT)
1119{
1120 AddTestCase(new WifiErrorRateModelsTestCaseDsss, TestCase::Duration::QUICK);
1121 AddTestCase(new WifiErrorRateModelsTestCaseNist, TestCase::Duration::QUICK);
1122 AddTestCase(new WifiErrorRateModelsTestCaseMimo, TestCase::Duration::QUICK);
1123 AddTestCase(new TableBasedErrorRateTestCase("DefaultTableBasedHtMcs0-1458bytes",
1124 HtPhy::GetHtMcs0(),
1125 1458),
1126 TestCase::Duration::QUICK);
1127 AddTestCase(
1128 new TableBasedErrorRateTestCase("DefaultTableBasedHtMcs0-32bytes", HtPhy::GetHtMcs0(), 32),
1129 TestCase::Duration::QUICK);
1130 AddTestCase(new TableBasedErrorRateTestCase("DefaultTableBasedHtMcs0-1000bytes",
1131 HtPhy::GetHtMcs0(),
1132 1000),
1133 TestCase::Duration::QUICK);
1134 AddTestCase(
1135 new TableBasedErrorRateTestCase("DefaultTableBasedHtMcs0-1byte", HtPhy::GetHtMcs0(), 1),
1136 TestCase::Duration::QUICK);
1137 AddTestCase(new TableBasedErrorRateTestCase("DefaultTableBasedHtMcs0-2000bytes",
1138 HtPhy::GetHtMcs0(),
1139 2000),
1140 TestCase::Duration::QUICK);
1141 AddTestCase(new TableBasedErrorRateTestCase("DefaultTableBasedHtMcs7-1500bytes",
1142 HtPhy::GetHtMcs7(),
1143 1500),
1144 TestCase::Duration::QUICK);
1145 AddTestCase(new TableBasedErrorRateTestCase("DefaultTableBasedVhtMcs0-1458bytes",
1146 VhtPhy::GetVhtMcs0(),
1147 1458),
1148 TestCase::Duration::QUICK);
1149 AddTestCase(new TableBasedErrorRateTestCase("DefaultTableBasedVhtMcs0-32bytes",
1150 VhtPhy::GetVhtMcs0(),
1151 32),
1152 TestCase::Duration::QUICK);
1153 AddTestCase(new TableBasedErrorRateTestCase("DefaultTableBasedVhtMcs0-1000bytes",
1154 VhtPhy::GetVhtMcs0(),
1155 1000),
1156 TestCase::Duration::QUICK);
1157 AddTestCase(
1158 new TableBasedErrorRateTestCase("DefaultTableBasedVhtMcs0-1byte", VhtPhy::GetVhtMcs0(), 1),
1159 TestCase::Duration::QUICK);
1160 AddTestCase(new TableBasedErrorRateTestCase("DefaultTableBasedVhtMcs0-2000bytes",
1161 VhtPhy::GetVhtMcs0(),
1162 2000),
1163 TestCase::Duration::QUICK);
1164 AddTestCase(new TableBasedErrorRateTestCase("DefaultTableBasedVhtMcs8-1500bytes",
1165 VhtPhy::GetVhtMcs8(),
1166 1500),
1167 TestCase::Duration::QUICK);
1168 AddTestCase(new TableBasedErrorRateTestCase("FallbackTableBasedHeMcs11-1458bytes",
1169 HePhy::GetHeMcs11(),
1170 1458),
1171 TestCase::Duration::QUICK);
1172}
1173
1174static WifiErrorRateModelsTestSuite wifiErrorRateModelsTestSuite; ///< the test suite
TableBasedErrorRateTestCase
Wifi Table-based Error Rate Models Test Case.
Definition wifi-error-rate-models-test.cc:1021
TableBasedErrorRateTestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition wifi-error-rate-models-test.cc:1056
TableBasedErrorRateTestCase::m_mode
WifiMode m_mode
The WifiMode to test.
Definition wifi-error-rate-models-test.cc:1037
TableBasedErrorRateTestCase::m_size
uint32_t m_size
The size (in bytes) to test.
Definition wifi-error-rate-models-test.cc:1038
TableBasedErrorRateTestCase::TableBasedErrorRateTestCase
TableBasedErrorRateTestCase(const std::string &testName, WifiMode mode, uint32_t size)
Constructor.
Definition wifi-error-rate-models-test.cc:1041
TableBasedErrorRateTestCase::m_testName
std::string m_testName
The name of the test to run.
Definition wifi-error-rate-models-test.cc:1036
WifiErrorRateModelsTestCaseDsss
Wifi Error Rate Models Test Case Dsss.
Definition wifi-error-rate-models-test.cc:51
WifiErrorRateModelsTestCaseDsss::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition wifi-error-rate-models-test.cc:70
WifiErrorRateModelsTestCaseMimo
Wifi Error Rate Models Test Case MIMO.
Definition wifi-error-rate-models-test.cc:402
WifiErrorRateModelsTestCaseMimo::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition wifi-error-rate-models-test.cc:421
WifiErrorRateModelsTestCaseNist
Wifi Error Rate Models Test Case Nist.
Definition wifi-error-rate-models-test.cc:160
WifiErrorRateModelsTestCaseNist::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition wifi-error-rate-models-test.cc:179
WifiErrorRateModelsTestSuite
Wifi Error Rate Models Test Suite.
Definition wifi-error-rate-models-test.cc:1112
ns3::DsssErrorRateModel::GetDsssDqpskSuccessRate
static double GetDsssDqpskSuccessRate(double sinr, uint64_t nbits)
Return the chunk success rate of the differential encoded QPSK.
Definition dsss-error-rate-model.cc:50
ns3::DsssErrorRateModel::GetDsssDbpskSuccessRate
static double GetDsssDbpskSuccessRate(double sinr, uint64_t nbits)
Return the chunk success rate of the differential BPSK.
Definition dsss-error-rate-model.cc:41
ns3::DsssErrorRateModel::GetDsssDqpskCck5_5SuccessRate
static double GetDsssDqpskCck5_5SuccessRate(double sinr, uint64_t nbits)
Return the chunk success rate of the differential encoded QPSK for 5.5Mbps data rate.
Definition dsss-error-rate-model.cc:59
ns3::DsssErrorRateModel::GetDsssDqpskCck11SuccessRate
static double GetDsssDqpskCck11SuccessRate(double sinr, uint64_t nbits)
Return the chunk success rate of the differential encoded QPSK for 11Mbps data rate.
Definition dsss-error-rate-model.cc:93
ns3::HePhy::GetHeMcs11
static WifiMode GetHeMcs11()
Return MCS 11 from HE MCS values.
ns3::HtPhy::GetHtMcs0
static WifiMode GetHtMcs0()
Return MCS 0 from HT MCS values.
ns3::HtPhy::GetHtMcs7
static WifiMode GetHtMcs7()
Return MCS 7 from HT MCS values.
ns3::InterferenceHelper
handles interference calculations
Definition interference-helper.h:122
ns3::InterferenceHelper::SetNoiseFigure
void SetNoiseFigure(double value)
Set the noise figure.
Definition interference-helper.cc:303
ns3::InterferenceHelper::CalculatePayloadChunkSuccessRate
double CalculatePayloadChunkSuccessRate(double snir, Time duration, const WifiTxVector &txVector, uint16_t staId=SU_STA_ID) const
Calculate the success rate of the payload chunk given the SINR, duration, and TXVECTOR.
Definition interference-helper.cc:543
ns3::InterferenceHelper::CalculateSnr
double CalculateSnr(Ptr< Event > event, MHz_u channelWidth, uint8_t nss, const WifiSpectrumBandInfo &band) const
Calculate the SNIR for the event (starting from now until the event end).
Definition interference-helper.cc:768
ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition ptr.h:66
ns3::TestCase
encapsulates test code
Definition test.h:1050
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::TestSuite
A suite of tests to run.
Definition test.h:1267
ns3::TestSuite::Type
Type
Type of test.
Definition test.h:1274
ns3::Time
Simulation virtual time values and global simulation resolution.
Definition nstime.h:94
ns3::VhtPhy::GetVhtMcs0
static WifiMode GetVhtMcs0()
Return MCS 0 from VHT MCS values.
ns3::VhtPhy::GetVhtMcs8
static WifiMode GetVhtMcs8()
Return MCS 8 from VHT MCS values.
ns3::WifiMode
represent a single transmission mode
Definition wifi-mode.h:40
ns3::WifiMode::GetMcsValue
uint8_t GetMcsValue() const
Definition wifi-mode.cc:152
ns3::WifiTxVector
This class mimics the TXVECTOR which is to be passed to the PHY in order to define the parameters whi...
Definition wifi-tx-vector.h:101
ns3::WifiTxVector::SetTxPowerLevel
void SetTxPowerLevel(uint8_t powerlevel)
Sets the selected transmission power level.
Definition wifi-tx-vector.cc:290
ns3::WifiTxVector::SetChannelWidth
void SetChannelWidth(MHz_u channelWidth)
Sets the selected channelWidth.
Definition wifi-tx-vector.cc:302
ns3::WifiTxVector::GetNss
uint8_t GetNss(uint16_t staId=SU_STA_ID) const
If this TX vector is associated with an SU PPDU, return the number of spatial streams.
Definition wifi-tx-vector.cc:193
ns3::WifiTxVector::GetChannelWidth
MHz_u GetChannelWidth() const
Definition wifi-tx-vector.cc:175
ns3::WifiTxVector::SetNTx
void SetNTx(uint8_t nTx)
Sets the number of TX antennas.
Definition wifi-tx-vector.cc:314
ns3::WifiTxVector::SetMode
void SetMode(WifiMode mode)
Sets the selected payload transmission mode.
Definition wifi-tx-vector.cc:274
ns3::WifiTxVector::SetNss
void SetNss(uint8_t nss)
Sets the number of Nss.
Definition wifi-tx-vector.cc:320
uint32_t
NS_FATAL_ERROR
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition fatal-error.h:168
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition log.h:191
NS_LOG_INFO
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition log.h:264
ns3::Create
Ptr< T > Create(Ts &&... args)
Create class instances by constructors with varying numbers of arguments and return them by Ptr.
Definition ptr.h:436
NS_TEST_ASSERT_MSG_GT
#define NS_TEST_ASSERT_MSG_GT(actual, limit, msg)
Test that an actual value is greater than a limit and report and abort if not.
Definition test.h:864
NS_TEST_ASSERT_MSG_EQ_TOL
#define NS_TEST_ASSERT_MSG_EQ_TOL(actual, limit, tol, msg)
Test that actual and expected (limit) values are equal to plus or minus some tolerance and report and...
Definition test.h:327
ns3::MilliSeconds
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition nstime.h:1356
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::RatioToDb
dB_u RatioToDb(double ratio)
Convert from ratio to dB.
Definition wifi-utils.cc:46
ns3::ERROR_TABLE_BCC_MAX_NUM_MCS
const uint8_t ERROR_TABLE_BCC_MAX_NUM_MCS
maximum number of MCSs for BCC
Definition error-rate-tables.h:30
ns3::value
static unsigned int value(char c)
Definition qkd-encryptor.cc:267
ns3::DbToRatio
double DbToRatio(dB_u val)
Convert from dB to ratio.
Definition wifi-utils.cc:27
FromRss
static double FromRss(dBW_u rss)
Definition wifi-error-rate-models-test.cc:33
expectedTableValues
std::map< std::pair< uint8_t, uint32_t >, std::map< dB_u, double > > expectedTableValues
map of PER values that have been manually computed for a given MCS, size (in bytes) and SNR (in dB) i...
Definition wifi-error-rate-models-test.cc:661
wifiErrorRateModelsTestSuite
static WifiErrorRateModelsTestSuite wifiErrorRateModelsTestSuite
the test suite
Definition wifi-error-rate-models-test.cc:1174