A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
three-gpp-channel-model.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2019 SIGNET Lab, Department of Information Engineering,
3 * University of Padova
4 * Copyright (c) 2015, NYU WIRELESS, Tandon School of Engineering,
5 * New York University
6 *
7 * SPDX-License-Identifier: GPL-2.0-only
8 *
9 */
10
11#include "three-gpp-channel-model.h"
12
13#include "ns3/double.h"
14#include "ns3/geocentric-constant-position-mobility-model.h"
15#include "ns3/integer.h"
16#include "ns3/log.h"
17#include "ns3/mobility-model.h"
18#include "ns3/node.h"
19#include "ns3/phased-array-model.h"
20#include "ns3/pointer.h"
21#include "ns3/shuffle.h"
22#include "ns3/simulator.h"
23#include "ns3/string.h"
24
25#include <algorithm>
26#include <array>
27#include <map>
28#include <random>
29
30namespace ns3
31{
32
33NS_LOG_COMPONENT_DEFINE("ThreeGppChannelModel");
34
35NS_OBJECT_ENSURE_REGISTERED(ThreeGppChannelModel);
36
37/// Conversion factor: degrees to radians
38static constexpr double DEG2RAD = M_PI / 180.0;
39
40/// The ray offset angles within a cluster, given for rms angle spread normalized to 1.
41/// (Table 7.5-3)
42static constexpr std::array<double, 20> offSetAlpha = {
43 0.0447, -0.0447, 0.1413, -0.1413, 0.2492, -0.2492, 0.3715, -0.3715, 0.5129, -0.5129,
44 0.6797, -0.6797, 0.8844, -0.8844, 1.1481, -1.1481, 1.5195, -1.5195, 2.1551, -2.1551,
45};
46
47/**
48 * The square root matrix for <em>RMa LOS</em>, which is generated using the
49 * Cholesky decomposition according to table 7.5-6 Part 2 and follows the order
50 * of [SF, K, DS, ASD, ASA, ZSD, ZSA].
51 *
52 * The Matlab file to generate the matrices can be found in
53 * https://github.com/nyuwireless-unipd/ns3-mmwave/blob/master/src/mmwave/model/BeamFormingMatrix/SqrtMatrix.m
54 */
55static constexpr std::array<std::array<double, 7>, 7> sqrtC_RMa_LOS = {{
56 {1, 0, 0, 0, 0, 0, 0},
57 {0, 1, 0, 0, 0, 0, 0},
58 {-0.5, 0, 0.866025, 0, 0, 0, 0},
59 {0, 0, 0, 1, 0, 0, 0},
60 {0, 0, 0, 0, 1, 0, 0},
61 {0.01, 0, -0.0519615, 0.73, -0.2, 0.651383, 0},
62 {-0.17, -0.02, 0.21362, -0.14, 0.24, 0.142773, 0.909661},
63}};
64
65/**
66 * The square root matrix for <em>RMa NLOS</em>, which is generated using the
67 * Cholesky decomposition according to table 7.5-6 Part 2 and follows the order
68 * of [SF, K, DS, ASD, ASA, ZSD, ZSA].
69 * The parameter K is ignored.
70 *
71 * The Matlab file to generate the matrices can be found in
72 * https://github.com/nyuwireless-unipd/ns3-mmwave/blob/master/src/mmwave/model/BeamFormingMatrix/SqrtMatrix.m
73 */
74static constexpr std::array<std::array<double, 6>, 6> sqrtC_RMa_NLOS = {{
75 {1, 0, 0, 0, 0, 0},
76 {-0.5, 0.866025, 0, 0, 0, 0},
77 {0.6, -0.11547, 0.791623, 0, 0, 0},
78 {0, 0, 0, 1, 0, 0},
79 {-0.04, -0.138564, 0.540662, -0.18, 0.809003, 0},
80 {-0.25, -0.606218, -0.240013, 0.26, -0.231685, 0.625392},
81}};
82
83/**
84 * The square root matrix for <em>RMa O2I</em>, which is generated using the
85 * Cholesky decomposition according to table 7.5-6 Part 2 and follows the order
86 * of [SF, K, DS, ASD, ASA, ZSD, ZSA].
87 *
88 * The Matlab file to generate the matrices can be found in
89 * https://github.com/nyuwireless-unipd/ns3-mmwave/blob/master/src/mmwave/model/BeamFormingMatrix/SqrtMatrix.m
90 */
91static constexpr std::array<std::array<double, 6>, 6> sqrtC_RMa_O2I = {{
92 {1, 0, 0, 0, 0, 0},
93 {0, 1, 0, 0, 0, 0},
94 {0, 0, 1, 0, 0, 0},
95 {0, 0, -0.7, 0.714143, 0, 0},
96 {0, 0, 0.66, -0.123225, 0.741091, 0},
97 {0, 0, 0.47, 0.152631, -0.393194, 0.775373},
98}};
99
100/**
101 * The square root matrix for <em>UMa LOS</em>, which is generated using the
102 * Cholesky decomposition according to table 7.5-6 Part 1 and follows the order
103 * of [SF, K, DS, ASD, ASA, ZSD, ZSA].
104 *
105 * The Matlab file to generate the matrices can be found in
106 * https://github.com/nyuwireless-unipd/ns3-mmwave/blob/master/src/mmwave/model/BeamFormingMatrix/SqrtMatrix.m
107 */
108static constexpr std::array<std::array<double, 7>, 7> sqrtC_UMa_LOS = {{
109 {1, 0, 0, 0, 0, 0, 0},
110 {0, 1, 0, 0, 0, 0, 0},
111 {-0.4, -0.4, 0.824621, 0, 0, 0, 0},
112 {-0.5, 0, 0.242536, 0.83137, 0, 0, 0},
113 {-0.5, -0.2, 0.630593, -0.484671, 0.278293, 0, 0},
114 {0, 0, -0.242536, 0.672172, 0.642214, 0.27735, 0},
115 {-0.8, 0, -0.388057, -0.367926, 0.238537, -3.58949e-15, 0.130931},
116}};
117
118/**
119 * The square root matrix for <em>UMa NLOS</em>, which is generated using the
120 * Cholesky decomposition according to table 7.5-6 Part 1 and follows the order
121 * of [SF, K, DS, ASD, ASA, ZSD, ZSA].
122 * The parameter K is ignored.
123 *
124 * The Matlab file to generate the matrices can be found in
125 * https://github.com/nyuwireless-unipd/ns3-mmwave/blob/master/src/mmwave/model/BeamFormingMatrix/SqrtMatrix.m
126 */
127static constexpr std::array<std::array<double, 6>, 6> sqrtC_UMa_NLOS = {{
128 {1, 0, 0, 0, 0, 0},
129 {-0.4, 0.916515, 0, 0, 0, 0},
130 {-0.6, 0.174574, 0.78072, 0, 0, 0},
131 {0, 0.654654, 0.365963, 0.661438, 0, 0},
132 {0, -0.545545, 0.762422, 0.118114, 0.327327, 0},
133 {-0.4, -0.174574, -0.396459, 0.392138, 0.49099, 0.507445},
134}};
135
136/**
137 * The square root matrix for <em>UMa O2I</em>, which is generated using the
138 * Cholesky decomposition according to table 7.5-6 Part 1 and follows the order
139 * of [SF, K, DS, ASD, ASA, ZSD, ZSA].
140 *
141 * The Matlab file to generate the matrices can be found in
142 * https://github.com/nyuwireless-unipd/ns3-mmwave/blob/master/src/mmwave/model/BeamFormingMatrix/SqrtMatrix.m
143 */
144static constexpr std::array<std::array<double, 6>, 6> sqrtC_UMa_O2I = {{
145 {1, 0, 0, 0, 0, 0},
146 {-0.5, 0.866025, 0, 0, 0, 0},
147 {0.2, 0.57735, 0.791623, 0, 0, 0},
148 {0, 0.46188, -0.336861, 0.820482, 0, 0},
149 {0, -0.69282, 0.252646, 0.493742, 0.460857, 0},
150 {0, -0.23094, 0.16843, 0.808554, -0.220827, 0.464515},
151}};
152
153/**
154 * The square root matrix for <em>UMi LOS</em>, which is generated using the
155 * Cholesky decomposition according to table 7.5-6 Part 1 and follows the order
156 * of [SF, K, DS, ASD, ASA, ZSD, ZSA].
157 *
158 * The Matlab file to generate the matrices can be found in
159 * https://github.com/nyuwireless-unipd/ns3-mmwave/blob/master/src/mmwave/model/BeamFormingMatrix/SqrtMatrix.m
160 */
161static constexpr std::array<std::array<double, 7>, 7> sqrtC_UMi_LOS = {{
162 {1, 0, 0, 0, 0, 0, 0},
163 {0.5, 0.866025, 0, 0, 0, 0, 0},
164 {-0.4, -0.57735, 0.711805, 0, 0, 0, 0},
165 {-0.5, 0.057735, 0.468293, 0.726201, 0, 0, 0},
166 {-0.4, -0.11547, 0.805464, -0.23482, 0.350363, 0, 0},
167 {0, 0, 0, 0.688514, 0.461454, 0.559471, 0},
168 {0, 0, 0.280976, 0.231921, -0.490509, 0.11916, 0.782603},
169}};
170
171/**
172 * The square root matrix for <em>UMi NLOS</em>, which is generated using the
173 * Cholesky decomposition according to table 7.5-6 Part 1 and follows the order
174 * of [SF, K, DS, ASD, ASA, ZSD, ZSA].
175 * The parameter K is ignored.
176 *
177 * The Matlab file to generate the matrices can be found in
178 * https://github.com/nyuwireless-unipd/ns3-mmwave/blob/master/src/mmwave/model/BeamFormingMatrix/SqrtMatrix.m
179 */
180static constexpr std::array<std::array<double, 6>, 6> sqrtC_UMi_NLOS = {{
181 {1, 0, 0, 0, 0, 0},
182 {-0.7, 0.714143, 0, 0, 0, 0},
183 {0, 0, 1, 0, 0, 0},
184 {-0.4, 0.168034, 0, 0.90098, 0, 0},
185 {0, -0.70014, 0.5, 0.130577, 0.4927, 0},
186 {0, 0, 0.5, 0.221981, -0.566238, 0.616522},
187}};
188
189/**
190 * The square root matrix for <em>UMi O2I</em>, which is generated using the
191 * Cholesky decomposition according to table 7.5-6 Part 1 and follows the order
192 * of [SF, K, DS, ASD, ASA, ZSD, ZSA].
193 *
194 * The Matlab file to generate the matrices can be found in
195 * https://github.com/nyuwireless-unipd/ns3-mmwave/blob/master/src/mmwave/model/BeamFormingMatrix/SqrtMatrix.m
196 */
197static constexpr std::array<std::array<double, 6>, 6> sqrtC_UMi_O2I = {{
198 {1, 0, 0, 0, 0, 0},
199 {-0.5, 0.866025, 0, 0, 0, 0},
200 {0.2, 0.57735, 0.791623, 0, 0, 0},
201 {0, 0.46188, -0.336861, 0.820482, 0, 0},
202 {0, -0.69282, 0.252646, 0.493742, 0.460857, 0},
203 {0, -0.23094, 0.16843, 0.808554, -0.220827, 0.464515},
204}};
205
206/**
207 * The square root matrix for <em>Indoor-Office LOS</em>, which is generated
208 * using the Cholesky decomposition according to table 7.5-6 Part 2 and follows
209 * the order of [SF, K, DS, ASD, ASA, ZSD, ZSA].
210 *
211 * The Matlab file to generate the matrices can be found in
212 * https://github.com/nyuwireless-unipd/ns3-mmwave/blob/master/src/mmwave/model/BeamFormingMatrix/SqrtMatrix.m
213 */
214static constexpr std::array<std::array<double, 7>, 7> sqrtC_office_LOS = {{
215 {1, 0, 0, 0, 0, 0, 0},
216 {0.5, 0.866025, 0, 0, 0, 0, 0},
217 {-0.8, -0.11547, 0.588784, 0, 0, 0, 0},
218 {-0.4, 0.23094, 0.520847, 0.717903, 0, 0, 0},
219 {-0.5, 0.288675, 0.73598, -0.348236, 0.0610847, 0, 0},
220 {0.2, -0.11547, 0.418943, 0.541106, 0.219905, 0.655744, 0},
221 {0.3, -0.057735, 0.73598, -0.348236, 0.0610847, -0.304997, 0.383375},
222}};
223
224/**
225 * The square root matrix for <em>Indoor-Office NLOS</em>, which is generated
226 * using the Cholesky decomposition according to table 7.5-6 Part 2 and follows
227 * the order of [SF, K, DS, ASD, ASA, ZSD, ZSA].
228 * The parameter K is ignored.
229 *
230 * The Matlab file to generate the matrices can be found in
231 * https://github.com/nyuwireless-unipd/ns3-mmwave/blob/master/src/mmwave/model/BeamFormingMatrix/SqrtMatrix.m
232 */
233static constexpr std::array<std::array<double, 6>, 6> sqrtC_office_NLOS = {{
234 {1, 0, 0, 0, 0, 0},
235 {-0.5, 0.866025, 0, 0, 0, 0},
236 {0, 0.46188, 0.886942, 0, 0, 0},
237 {-0.4, -0.23094, 0.120263, 0.878751, 0, 0},
238 {0, -0.311769, 0.55697, -0.249198, 0.728344, 0},
239 {0, -0.069282, 0.295397, 0.430696, 0.468462, 0.709214},
240}};
241
242/**
243 * The square root matrix for <em>NTN Dense Urban LOS</em>, which is generated
244 * using the Cholesky decomposition according to 3GPP TR 38.811 v15.4.0 table 6.7.2-1 and follows
245 * the order of [SF, K, DS, ASD, ASA, ZSD, ZSA].
246 *
247 * The Matlab file to generate the matrices can be found in
248 * https://github.com/nyuwireless-unipd/ns3-mmwave/blob/master/src/mmwave/model/BeamFormingMatrix/SqrtMatrix.m
249 */
250static constexpr std::array<std::array<double, 7>, 7> sqrtC_NTN_DenseUrban_LOS = {{
251 {1, 0, 0, 0, 0, 0, 0},
252 {0, 1, 0, 0, 0, 0, 0},
253 {-0.4, -0.4, 0.824621, 0, 0, 0, 0},
254 {-0.5, 0, 0.242536, 0.83137, 0, 0, 0},
255 {-0.5, -0.2, 0.630593, -0.484671, 0.278293, 0, 0},
256 {0, 0, -0.242536, 0.672172, 0.642214, 0.27735, 0},
257 {-0.8, 0, -0.388057, -0.367926, 0.238537, -4.09997e-15, 0.130931},
258}};
259
260/**
261 * The square root matrix for <em>NTN Dense Urban NLOS</em>, which is generated
262 * using the Cholesky decomposition according to 3GPP TR 38.811 v15.4.0 table 6.7.2-2 and follows
263 * the order of [SF, K, DS, ASD, ASA, ZSD, ZSA].
264 *
265 * The Matlab file to generate the matrices can be found in
266 * https://github.com/nyuwireless-unipd/ns3-mmwave/blob/master/src/mmwave/model/BeamFormingMatrix/SqrtMatrix.m
267 */
268static constexpr std::array<std::array<double, 6>, 6> sqrtC_NTN_DenseUrban_NLOS = {{
269 {1, 0, 0, 0, 0, 0},
270 {-0.4, 0.916515, 0, 0, 0, 0},
271 {-0.6, 0.174574, 0.78072, 0, 0, 0},
272 {0, 0.654654, 0.365963, 0.661438, 0, 0},
273 {0, -0.545545, 0.762422, 0.118114, 0.327327, 0},
274 {-0.4, -0.174574, -0.396459, 0.392138, 0.49099, 0.507445},
275}};
276
277/**
278 * The square root matrix for <em>NTN Urban LOS</em>, which is generated
279 * using the Cholesky decomposition according to 3GPP TR 38.811 v15.4.0 table 6.7.2-3 and follows
280 * the order of [SF, K, DS, ASD, ASA, ZSD, ZSA].
281 *
282 * The Matlab file to generate the matrices can be found in
283 * https://github.com/nyuwireless-unipd/ns3-mmwave/blob/master/src/mmwave/model/BeamFormingMatrix/SqrtMatrix.m
284 */
285static constexpr std::array<std::array<double, 7>, 7> sqrtC_NTN_Urban_LOS = {{
286 {1, 0, 0, 0, 0, 0, 0},
287 {0, 1, 0, 0, 0, 0, 0},
288 {-0.4, -0.4, 0.824621, 0, 0, 0, 0},
289 {-0.5, 0, 0.242536, 0.83137, 0, 0, 0},
290 {-0.5, -0.2, 0.630593, -0.484671, 0.278293, 0, 0},
291 {0, 0, -0.242536, 0.672172, 0.642214, 0.27735, 0},
292 {-0.8, 0, -0.388057, -0.367926, 0.238537, -4.09997e-15, 0.130931},
293}};
294
295/**
296 * The square root matrix for <em>NTN Urban NLOS</em>, which is generated
297 * using the Cholesky decomposition according to 3GPP TR 38.811 v15.4.0 table 6.7.2-4 and follows
298 * the order of [SF, K, DS, ASD, ASA, ZSD, ZSA].
299 *
300 * The square root matrix is dependent on the elevation angle, thus requiring a map.
301 *
302 * The Matlab file to generate the matrices can be found in
303 * https://github.com/nyuwireless-unipd/ns3-mmwave/blob/master/src/mmwave/model/BeamFormingMatrix/SqrtMatrix.m
304 */
305static const std::map<int, std::array<std::array<double, 6>, 6>> sqrtC_NTN_Urban_NLOS{
306 {10,
307 {{
308 {1, 0, 0, 0, 0, 0},
309 {-0.21, 0.977701, 0, 0, 0, 0},
310 {-0.48, 0.459445, 0.747335, 0, 0, 0},
311 {-0.05, 0.377927, 0.28416, 0.879729, 0, 0},
312 {-0.02, 0.691213, 0.258017, 0.073265, 0.670734, 0},
313 {-0.31, -0.00521632, -0.115615, 0.0788023, 0.00218104, 0.940368},
314 }}},
315 {20,
316 {{
317 {1, 0, 0, 0, 0, 0},
318 {-0.25, 0.968246, 0, 0, 0, 0},
319 {-0.52, 0.35115, 0.778648, 0, 0, 0},
320 {-0.04, 0.371806, 0.345008, 0.860889, 0, 0},
321 {0, 0.743613, 0.281102, 0.0424415, 0.605161, 0},
322 {-0.32, 0.0206559, -0.0689057, 0.154832, 0.061865, 0.929852},
323 }}},
324 {30,
325 {{
326 {1, 0, 0, 0, 0, 0},
327 {-0.21, 0.977701, 0, 0, 0, 0},
328 {-0.52, 0.450853, 0.725487, 0, 0, 0},
329 {-0.04, 0.288023, 0.260989, 0.920504, 0, 0},
330 {0.01, 0.697657, 0.386856, 0.0418183, 0.601472, 0},
331 {-0.33, 0.0416283, -0.0694268, 0.166137, 0.139937, 0.915075},
332 }}},
333 {40,
334 {{
335 {1, 0, 0, 0, 0, 0},
336 {-0.26, 0.965609, 0, 0, 0, 0},
337 {-0.53, 0.395813, 0.749955, 0, 0, 0},
338 {-0.04, 0.299914, 0.320139, 0.897754, 0, 0},
339 {0.01, 0.696556, 0.372815, 0.0580784, 0.610202, 0},
340 {-0.33, 0.0457742, -0.0173584, 0.154417, 0.129332, 0.920941},
341 }}},
342 {50,
343 {{
344 {1, 0, 0, 0, 0, 0},
345 {-0.25, 0.968246, 0, 0, 0, 0},
346 {-0.57, 0.420864, 0.705672, 0, 0, 0},
347 {-0.03, 0.229797, 0.235501, 0.943839, 0, 0},
348 {0.03, 0.679063, 0.384466, 0.0681379, 0.6209, 0},
349 {-0.41, -0.147173, -0.229228, 0.270707, 0.293002, 0.773668},
350 }}},
351 {60,
352 {{
353 {1, 0, 0, 0, 0, 0},
354 {-0.2, 0.979796, 0, 0, 0, 0},
355 {-0.53, 0.473568, 0.703444, 0, 0, 0},
356 {-0.05, 0.204124, 0.109225, 0.971547, 0, 0},
357 {0.03, 0.68994, 0.411073, 0.0676935, 0.591202, 0},
358 {-0.4, -0.224537, -0.292371, 0.275609, 0.301835, 0.732828},
359 }}},
360 {70,
361 {{
362 {1, 0, 0, 0, 0, 0},
363 {-0.19, 0.981784, 0, 0, 0, 0},
364 {-0.5, 0.524555, 0.689088, 0, 0, 0},
365 {-0.03, 0.228462, 0.18163, 0.955989, 0, 0},
366 {-0.02, 0.637818, 0.428725, 0.00608114, 0.639489, 0},
367 {-0.36, -0.18171, -0.282523, 0.106726, 0.123808, 0.854894},
368 }}},
369 {80,
370 {{
371 {1, 0, 0, 0, 0, 0},
372 {-0.2, 0.979796, 0, 0, 0, 0},
373 {-0.49, 0.502145, 0.712566, 0, 0, 0},
374 {-0.01, 0.232702, 0.151916, 0.960558, 0, 0},
375 {-0.05, 0.612372, 0.376106, 0.0206792, 0.693265, 0},
376 {-0.37, -0.320475, -0.365405, -0.00376264, 0.0364343, 0.790907},
377 }}},
378 {90,
379 {{
380 {1, 0, 0, 0, 0, 0},
381 {-0.19, 0.981784, 0, 0, 0, 0},
382 {-0.38, 0.58852, 0.713613, 0, 0, 0},
383 {-0.03, 0.360874, 0.12082, 0.924269, 0, 0},
384 {-0.12, 0.526796, 0.34244, 0.0594196, 0.766348, 0},
385 {-0.33, -0.257389, -0.24372, -0.257035, -0.176521, 0.817451},
386 }}},
387};
388
389/**
390 * The square root matrix for <em>NTN Suburban LOS</em>, which is generated
391 * using the Cholesky decomposition according to 3GPP TR 38.811 v15.4.0 table 6.7.2-5 and follows
392 * the order of [SF, K, DS, ASD, ASA, ZSD, ZSA].
393 *
394 * The Matlab file to generate the matrices can be found in
395 * https://github.com/nyuwireless-unipd/ns3-mmwave/blob/master/src/mmwave/model/BeamFormingMatrix/SqrtMatrix.m
396 */
397static constexpr std::array<std::array<double, 7>, 7> sqrtC_NTN_Suburban_LOS = {{
398 {1, 0, 0, 0, 0, 0, 0},
399 {0, 1, 0, 0, 0, 0, 0},
400 {-0.4, -0.4, 0.824621, 0, 0, 0, 0},
401 {-0.5, 0, 0.242536, 0.83137, 0, 0, 0},
402 {-0.5, -0.2, 0.630593, -0.484671, 0.278293, 0, 0},
403 {0, 0, -0.242536, 0.672172, 0.642214, 0.27735, 0},
404 {-0.8, 0, -0.388057, -0.367926, 0.238537, -4.09997e-15, 0.130931},
405}};
406
407/**
408 * The square root matrix for <em>NTN Suburban NLOS</em>, which is generated
409 * using the Cholesky decomposition according to 3GPP TR 38.811 v15.4.0 table 6.7.2-6 and follows
410 * the order of [SF, K, DS, ASD, ASA, ZSD, ZSA].
411 *
412 * The Matlab file to generate the matrices can be found in
413 * https://github.com/nyuwireless-unipd/ns3-mmwave/blob/master/src/mmwave/model/BeamFormingMatrix/SqrtMatrix.m
414 */
415static constexpr std::array<std::array<double, 6>, 6> sqrtC_NTN_Suburban_NLOS = {{
416 {1, 0, 0, 0, 0, 0},
417 {-0.4, 0.916515, 0, 0, 0, 0},
418 {-0.6, 0.174574, 0.78072, 0, 0, 0},
419 {0, 0.654654, 0.365963, 0.661438, 0, 0},
420 {0, -0.545545, 0.762422, 0.118114, 0.327327, 0},
421 {-0.4, -0.174574, -0.396459, 0.392138, 0.49099, 0.507445},
422}};
423
424/**
425 * The square root matrix for <em>NTN Rural LOS</em>, which is generated
426 * using the Cholesky decomposition according to 3GPP TR 38.811 v15.4.0 table 6.7.2-7 and follows
427 * the order of [SF, K, DS, ASD, ASA, ZSD, ZSA].
428 *
429 * The Matlab file to generate the matrices can be found in
430 * https://github.com/nyuwireless-unipd/ns3-mmwave/blob/master/src/mmwave/model/BeamFormingMatrix/SqrtMatrix.m
431 */
432static constexpr std::array<std::array<double, 7>, 7> sqrtC_NTN_Rural_LOS = {{
433 {1, 0, 0, 0, 0, 0, 0},
434 {0, 1, 0, 0, 0, 0, 0},
435 {-0.5, 0, 0.866025, 0, 0, 0, 0},
436 {0, 0, 0, 1, 0, 0, 0},
437 {0, 0, 0, 0, 1, 0, 0},
438 {0.01, 0, -0.0519615, 0.73, -0.2, 0.651383, 0},
439 {-0.17, -0.02, 0.21362, -0.14, 0.24, 0.142773, 0.909661},
440}};
441
442/**
443 * The square root matrix for <em>NTN Rural NLOS S Band</em>, which is generated
444 * using the Cholesky decomposition according to 3GPP TR 38.811 v15.4.0 table 6.7.2-8a and follows
445 * the order of [SF, K, DS, ASD, ASA, ZSD, ZSA].
446 *
447 * The square root matrix is dependent on the elevation angle, thus requiring a map.
448 *
449 * The Matlab file to generate the matrices can be found in
450 * https://github.com/nyuwireless-unipd/ns3-mmwave/blob/master/src/mmwave/model/BeamFormingMatrix/SqrtMatrix.m
451 */
452static const std::map<int, std::array<std::array<double, 6>, 6>> sqrtC_NTN_Rural_NLOS_S{
453 {10,
454 {{
455 {1, 0, 0, 0, 0, 0},
456 {-0.36, 0.932952, 0, 0, 0, 0},
457 {0.45, 0.516639, 0.728412, 0, 0, 0},
458 {0.02, 0.329277, 0.371881, 0.867687, 0, 0},
459 {-0.06, 0.59853, 0.436258, -0.0324062, 0.668424, 0},
460 {-0.07, 0.0373009, 0.305087, -0.0280496, -0.225204, 0.921481},
461 }}},
462 {20,
463 {{
464 {1, 0, 0, 0, 0, 0},
465 {-0.39, 0.920815, 0, 0, 0, 0},
466 {0.52, 0.426579, 0.740021, 0, 0, 0},
467 {0, 0.347518, -0.0381664, 0.936896, 0, 0},
468 {-0.04, 0.710675, 0.172483, 0.116993, 0.670748, 0},
469 {-0.17, -0.0394216, 0.115154, 0.243458, -0.0702635, 0.944498},
470 }}},
471 {30,
472 {{
473 {1, 0, 0, 0, 0, 0},
474 {-0.41, 0.912086, 0, 0, 0, 0},
475 {0.54, 0.49491, 0.680782, 0, 0, 0},
476 {0, 0.350844, -0.152231, 0.923977, 0, 0},
477 {-0.04, 0.694672, 0.0702137, 0.0832998, 0.709903, 0},
478 {-0.19, -0.0854087, 0.0805978, 0.283811, -0.137441, 0.922318},
479 }}},
480 {40,
481 {{
482 {1, 0, 0, 0, 0, 0},
483 {-0.37, 0.929032, 0, 0, 0, 0},
484 {0.53, 0.480177, 0.698949, 0, 0, 0},
485 {0.01, 0.434538, 0.00864797, 0.900556, 0, 0},
486 {-0.05, 0.765851, -0.0303947, 0.0421641, 0.63896, 0},
487 {-0.17, -0.16458, 0.0989022, 0.158081, -0.150425, 0.941602},
488 }}},
489 {50,
490 {{
491 {1, 0, 0, 0, 0, 0},
492 {-0.4, 0.916515, 0, 0, 0, 0},
493 {0.55, 0.403703, 0.731111, 0, 0, 0},
494 {0.02, 0.499719, -0.0721341, 0.862947, 0, 0},
495 {-0.06, 0.835775, -0.156481, 0.0373835, 0.521534, 0},
496 {-0.19, -0.301141, 0.145082, 0.144564, -0.0238067, 0.911427},
497 }}},
498 {60,
499 {{
500 {1, 0, 0, 0, 0, 0},
501 {-0.41, 0.912086, 0, 0, 0, 0},
502 {0.56, 0.339442, 0.755764, 0, 0, 0},
503 {0.02, 0.436582, -0.0256617, 0.899076, 0, 0},
504 {-0.07, 0.856608, -0.12116, 0.0715303, 0.491453, 0},
505 {-0.2, -0.331109, 0.15136, 0.036082, 0.031313, 0.908391},
506 }}},
507 {70,
508 {{
509 {1, 0, 0, 0, 0, 0},
510 {-0.4, 0.916515, 0, 0, 0, 0},
511 {0.56, 0.386246, 0.732949, 0, 0, 0},
512 {0.04, 0.573913, -0.0601289, 0.815726, 0, 0},
513 {-0.11, 0.813953, -0.0720183, 0.0281118, 0.565158, 0},
514 {-0.19, -0.432071, 0.236423, -0.0247788, -0.0557206, 0.847113},
515 }}},
516 {80,
517 {{
518 {1, 0, 0, 0, 0, 0},
519 {-0.46, 0.887919, 0, 0, 0, 0},
520 {0.58, 0.469412, 0.665772, 0, 0, 0},
521 {0.01, 0.309262, -0.286842, 0.90663, 0, 0},
522 {-0.05, 0.762457, -0.268721, -0.0467443, 0.584605, 0},
523 {-0.23, -0.580909, 0.399665, 0.0403629, 0.326208, 0.584698},
524 }}},
525 {90,
526 {{
527 {1, 0, 0, 0, 0, 0},
528 {-0.3, 0.953939, 0, 0, 0, 0},
529 {0.47, 0.81871, 0.329868, 0, 0, 0},
530 {0.06, 0.0712834, -0.595875, 0.797654, 0, 0},
531 {-0.1, 0.408831, -0.0233859, 0.0412736, 0.905873, 0},
532 {-0.13, -0.407783, 0.439436, -0.0768289, -0.212875, 0.756631},
533 }}},
534};
535
536/**
537 * The square root matrix for <em>NTN Rural NLOS Ka Band</em>, which is generated
538 * using the Cholesky decomposition according to 3GPP TR 38.811 v15.4.0 table 6.7.2-8b and follows
539 * the order of [SF, K, DS, ASD, ASA, ZSD, ZSA].
540 *
541 * The square root matrix is dependent on the elevation angle, which acts as the corresponding map's
542 * key..
543 *
544 * The Matlab file to generate the matrices can be found in
545 * https://github.com/nyuwireless-unipd/ns3-mmwave/blob/master/src/mmwave/model/BeamFormingMatrix/SqrtMatrix.m
546 */
547static const std::map<int, std::array<std::array<double, 6>, 6>> sqrtC_NTN_Rural_NLOS_Ka{
548 {10,
549 {{
550 {1, 0, 0, 0, 0, 0},
551 {-0.36, 0.932952, 0, 0, 0, 0},
552 {0.45, 0.527358, 0.72069, 0, 0, 0},
553 {0.02, 0.350715, 0.355282, 0.866241, 0, 0},
554 {-0.07, 0.562515, 0.478504, 0.0162932, 0.670406, 0},
555 {-0.06, 0.0411597, 0.270982, 0.0121094, -0.159927, 0.946336},
556 }}},
557 {20,
558 {{
559 {1, 0, 0, 0, 0, 0},
560 {-0.38, 0.924986, 0, 0, 0, 0},
561 {0.52, 0.473088, 0.711188, 0, 0, 0},
562 {0, 0.367573, -0.0617198, 0.927944, 0, 0},
563 {-0.04, 0.68628, 0.149228, 0.115257, 0.701332, 0},
564 {-0.16, -0.0441088, 0.118207, 0.251641, -0.0752458, 0.943131},
565 }}},
566 {30,
567 {{
568 {1, 0, 0, 0, 0, 0},
569 {-0.42, 0.907524, 0, 0, 0, 0},
570 {0.54, 0.48131, 0.690464, 0, 0, 0},
571 {0, 0.363627, -0.137613, 0.921324, 0, 0},
572 {-0.04, 0.686704, 0.117433, 0.104693, 0.708581, 0},
573 {-0.19, -0.0438556, 0.0922685, 0.269877, -0.136292, 0.928469},
574 }}},
575 {40,
576 {{
577 {1, 0, 0, 0, 0, 0},
578 {-0.36, 0.932952, 0, 0, 0, 0},
579 {0.53, 0.483197, 0.696865, 0, 0, 0},
580 {0.01, 0.464761, -0.0285153, 0.88492, 0, 0},
581 {-0.05, 0.763169, 0.140255, 0.0562856, 0.626286, 0},
582 {-0.16, -0.126051, 0.0942905, 0.195354, -0.217188, 0.92967},
583 }}},
584 {50,
585 {{
586 {1, 0, 0, 0, 0, 0},
587 {-0.39, 0.920815, 0, 0, 0, 0},
588 {0.55, 0.406705, 0.729446, 0, 0, 0},
589 {0.01, 0.503793, -0.123923, 0.854831, 0, 0},
590 {-0.06, 0.821664, -0.207246, 0.0245302, 0.526988, 0},
591 {-0.19, -0.254231, 0.10679, 0.190931, -0.0665276, 0.920316},
592 }}},
593 {60,
594 {{
595 {1, 0, 0, 0, 0, 0},
596 {-0.42, 0.907524, 0, 0, 0, 0},
597 {0.56, 0.391395, 0.730213, 0, 0, 0},
598 {0.02, 0.427978, -0.0393147, 0.902712, 0, 0},
599 {-0.06, 0.820694, -0.119986, 0.105509, 0.545281, 0},
600 {-0.2, -0.279882, 0.180145, 0.0563477, -0.0121631, 0.919723},
601 }}},
602 {70,
603 {{
604 {1, 0, 0, 0, 0, 0},
605 {-0.36, 0.932952, 0, 0, 0, 0},
606 {0.54, 0.519212, 0.662434, 0, 0, 0},
607 {0.04, 0.412025, -0.0234416, 0.909992, 0, 0},
608 {-0.09, 0.758452, -0.0682296, 0.0214276, 0.64151, 0},
609 {-0.17, -0.387158, 0.306169, -0.0291255, -0.109344, 0.845378},
610 }}},
611 {80,
612 {{
613 {1, 0, 0, 0, 0, 0},
614 {-0.44, 0.897998, 0, 0, 0, 0},
615 {0.57, 0.43519, 0.696928, 0, 0, 0},
616 {0.01, 0.316705, -0.248988, 0.915207, 0, 0},
617 {-0.06, 0.805793, -0.296262, -0.0419182, 0.507514, 0},
618 {-0.22, -0.497551, 0.289742, 0.0785823, 0.328773, 0.711214},
619 }}},
620 {90,
621 {{
622 {1, 0, 0, 0, 0, 0},
623 {-0.27, 0.96286, 0, 0, 0, 0},
624 {0.46, 0.741748, 0.488067, 0, 0, 0},
625 {0.04, 0.0735309, -0.374828, 0.923308, 0, 0},
626 {-0.08, 0.517624, 0.128779, 0.0795063, 0.838308, 0},
627 {-0.11, -0.321646, 0.0802763, -0.131981, -0.193429, 0.907285},
628 }}},
629};
630
631/**
632 * The enumerator used for code clarity when performing parameter assignment in GetThreeGppTable
633 */
659
660/**
661 * The nested map containing the 3GPP value tables for the NTN Dense Urban LOS scenario.
662 * The outer key specifies the band (either "S" or "Ka"), while the inner key represents
663 * the quantized elevation angle.
664 * The inner vector collects the table3gpp values.
665 */
666static const std::map<std::string, std::map<int, std::array<float, 22>>> NTNDenseUrbanLOS{
667 {"S",
668 {
669 {10, {-7.12, 0.8, -3.06, 0.48, 0.94, 0.7, 0.82, 0.03, -2.52, 0.5, 4.4,
670 3.3, 2.5, 24.4, 3.8, 3.0, 20.0, 3.9, 0.0, 11.0, 7.0, 3.0}},
671 {20, {-7.28, 0.67, -2.68, 0.36, 0.87, 0.66, 0.5, 0.09, -2.29, 0.53, 9.0,
672 6.6, 2.5, 23.6, 4.7, 3.0, 20.0, 3.9, 0.0, 11.0, 7.0, 3.0}},
673 {30, {-7.45, 0.68, -2.51, 0.38, 0.92, 0.68, 0.82, 0.05, -2.19, 0.58, 9.3,
674 6.1, 2.5, 23.2, 4.6, 3.0, 20.0, 3.9, 0.0, 11.0, 7.0, 3.0}},
675 {40, {-7.73, 0.66, -2.4, 0.32, 0.79, 0.64, 1.23, 0.03, -2.24, 0.51, 7.9,
676 4.0, 2.5, 22.6, 4.9, 3.0, 20.0, 3.9, 0.0, 11.0, 7.0, 3.0}},
677 {50, {-7.91, 0.62, -2.31, 0.33, 0.72, 0.63, 1.43, 0.06, -2.3, 0.46, 7.4,
678 3.0, 2.5, 21.8, 5.7, 3.0, 20.0, 3.9, 0.0, 11.0, 7.0, 3.0}},
679 {60, {-8.14, 0.51, -2.2, 0.39, 0.6, 0.54, 1.56, 0.05, -2.48, 0.35, 7.0,
680 2.6, 2.5, 20.5, 6.9, 3.0, 20.0, 3.9, 0.0, 11.0, 7.0, 3.0}},
681 {70, {-8.23, 0.45, -2.0, 0.4, 0.55, 0.52, 1.66, 0.05, -2.64, 0.31, 6.9,
682 2.2, 2.5, 19.3, 8.1, 3.0, 20.0, 3.9, 0.0, 11.0, 7.0, 3.0}},
683 {80, {-8.28, 0.31, -1.64, 0.32, 0.71, 0.53, 1.73, 0.02, -2.68, 0.39, 6.5,
684 2.1, 2.5, 17.4, 10.3, 3.0, 20.0, 3.9, 0.0, 11.0, 7.0, 3.0}},
685 {90, {-8.36, 0.08, -0.63, 0.53, 0.81, 0.62, 1.79, 0.01, -2.61, 0.28, 6.8,
686 1.9, 2.5, 12.3, 15.2, 3.0, 20.0, 3.9, 0.0, 11.0, 7.0, 3.0}},
687 }},
688 {"Ka",
689 {
690 {10, {-7.43, 0.9, -3.43, 0.54, 0.65, 0.82, 0.82, 0.05, -2.75, 0.55, 6.1,
691 2.6, 2.5, 24.7, 2.1, 3.0, 20.0, 1.6, 0.0, 11.0, 7.0, 3.0}},
692 {20, {-7.62, 0.78, -3.06, 0.41, 0.53, 0.78, 0.47, 0.11, -2.64, 0.64, 13.7,
693 6.8, 2.5, 24.4, 2.8, 3.0, 20.0, 1.6, 0.0, 11.0, 7.0, 3.0}},
694 {30, {-7.76, 0.8, -2.91, 0.42, 0.6, 0.83, 0.8, 0.05, -2.49, 0.69, 12.9,
695 6.0, 2.5, 24.4, 2.7, 3.0, 20.0, 1.6, 0.0, 11.0, 7.0, 3.0}},
696 {40, {-8.02, 0.72, -2.81, 0.34, 0.43, 0.78, 1.23, 0.04, -2.51, 0.57, 10.3,
697 3.3, 2.5, 24.2, 2.7, 3.0, 20.0, 1.6, 0.0, 11.0, 7.0, 3.0}},
698 {50, {-8.13, 0.61, -2.74, 0.34, 0.36, 0.77, 1.42, 0.1, -2.54, 0.5, 9.2,
699 2.2, 2.5, 23.9, 3.1, 3.0, 20.0, 1.6, 0.0, 11.0, 7.0, 3.0}},
700 {60, {-8.3, 0.47, -2.72, 0.7, 0.16, 0.84, 1.56, 0.06, -2.71, 0.37, 8.4,
701 1.9, 2.5, 23.3, 3.9, 3.0, 20.0, 1.6, 0.0, 11.0, 7.0, 3.0}},
702 {70, {-8.34, 0.39, -2.46, 0.4, 0.18, 0.64, 1.65, 0.07, -2.85, 0.31, 8.0,
703 1.5, 2.5, 22.6, 4.8, 3.0, 20.0, 1.6, 0.0, 11.0, 7.0, 3.0}},
704 {80, {-8.39, 0.26, -2.3, 0.78, 0.24, 0.81, 1.73, 0.02, -3.01, 0.45, 7.4,
705 1.6, 2.5, 21.2, 6.8, 3.0, 20.0, 1.6, 0.0, 11.0, 7.0, 3.0}},
706 {90, {-8.45, 0.01, -1.11, 0.51, 0.36, 0.65, 1.79, 0.01, -3.08, 0.27, 7.6,
707 1.3, 2.5, 17.6, 12.7, 3.0, 20.0, 1.6, 0.0, 11.0, 7.0, 3.0}},
708 }},
709};
710
711/**
712 * The nested map containing the 3GPP value tables for the NTN Dense Urban NLOS scenario.
713 * The outer key specifies the band (either "S" or "Ka"), while the inner key represents
714 * the quantized elevation angle.
715 * The inner vector collects the table3gpp values.
716 */
717static const std::map<std::string, std::map<int, std::array<float, 22>>> NTNDenseUrbanNLOS{
718 {"S",
719 {
720 {10, {-6.84, 0.82, -2.08, 0.87, 1.0, 1.6, 1.0, 0.63, -2.08, 0.58, 0.0,
721 0.0, 2.3, 23.8, 4.4, 4.0, 20.0, 3.9, 0.0, 15.0, 7.0, 3.0}},
722 {20, {-6.81, 0.61, -1.68, 0.73, 1.44, 0.87, 0.94, 0.65, -1.66, 0.5, 0.0,
723 0.0, 2.3, 21.9, 6.3, 4.0, 20.0, 3.9, 0.0, 15.0, 7.0, 3.0}},
724 {30, {-6.94, 0.49, -1.46, 0.53, 1.54, 0.64, 1.15, 0.42, -1.48, 0.4, 0.0,
725 0.0, 2.3, 19.7, 8.1, 4.0, 20.0, 3.9, 0.0, 15.0, 7.0, 3.0}},
726 {40, {-7.14, 0.49, -1.43, 0.5, 1.53, 0.56, 1.35, 0.28, -1.46, 0.37, 0.0,
727 0.0, 2.3, 18.1, 9.3, 4.0, 20.0, 3.9, 0.0, 15.0, 7.0, 3.0}},
728 {50, {-7.34, 0.51, -1.44, 0.58, 1.48, 0.54, 1.44, 0.25, -1.53, 0.47, 0.0,
729 0.0, 2.3, 16.3, 11.5, 4.0, 20.0, 3.9, 0.0, 15.0, 7.0, 3.0}},
730 {60, {-7.53, 0.47, -1.33, 0.49, 1.39, 0.68, 1.56, 0.16, -1.61, 0.43, 0.0,
731 0.0, 2.3, 14.0, 13.3, 4.0, 20.0, 3.9, 0.0, 15.0, 7.0, 3.0}},
732 {70, {-7.67, 0.44, -1.31, 0.65, 1.42, 0.55, 1.64, 0.18, -1.77, 0.5, 0.0,
733 0.0, 2.3, 12.1, 14.9, 4.0, 20.0, 3.9, 0.0, 15.0, 7.0, 3.0}},
734 {80, {-7.82, 0.42, -1.11, 0.69, 1.38, 0.6, 1.7, 0.09, -1.9, 0.42, 0.0,
735 0.0, 2.3, 8.7, 17.0, 4.0, 20.0, 3.9, 0.0, 15.0, 7.0, 3.0}},
736 {90, {-7.84, 0.55, -0.11, 0.53, 1.23, 0.6, 1.7, 0.17, -1.99, 0.5, 0.0,
737 0.0, 2.3, 6.4, 12.3, 4.0, 20.0, 3.9, 0.0, 15.0, 7.0, 3.0}},
738 }},
739 {"Ka",
740 {
741 {10, {-6.86, 0.81, -2.12, 0.94, 1.02, 1.44, 1.01, 0.56, -2.11, 0.59, 0.0,
742 0.0, 2.3, 23.7, 4.5, 4.0, 20.0, 3.9, 0.0, 15.0, 7.0, 3.0}},
743 {20, {-6.84, 0.61, -1.74, 0.79, 1.44, 0.77, 0.96, 0.55, -1.69, 0.51, 0.0,
744 0.0, 2.3, 21.8, 6.3, 4.0, 20.0, 3.9, 0.0, 15.0, 7.0, 3.0}},
745 {30, {-7.0, 0.56, -1.56, 0.66, 1.48, 0.7, 1.13, 0.43, -1.52, 0.46, 0.0,
746 0.0, 2.3, 19.6, 8.2, 4.0, 20.0, 3.9, 0.0, 15.0, 7.0, 3.0}},
747 {40, {-7.21, 0.56, -1.54, 0.63, 1.46, 0.6, 1.3, 0.37, -1.51, 0.43, 0.0,
748 0.0, 2.3, 18.0, 9.4, 4.0, 20.0, 3.9, 0.0, 15.0, 7.0, 3.0}},
749 {50, {-7.42, 0.57, -1.45, 0.56, 1.4, 0.59, 1.4, 0.32, -1.54, 0.45, 0.0,
750 0.0, 2.3, 16.3, 11.5, 4.0, 20.0, 3.9, 0.0, 15.0, 7.0, 3.0}},
751 {60, {-7.86, 0.55, -1.64, 0.78, 0.97, 1.27, 1.41, 0.45, -1.84, 0.63, 0.0,
752 0.0, 2.3, 15.9, 12.4, 4.0, 20.0, 3.9, 0.0, 15.0, 7.0, 3.0}},
753 {70, {-7.76, 0.47, -1.37, 0.56, 1.33, 0.56, 1.63, 0.17, -1.86, 0.51, 0.0,
754 0.0, 2.3, 12.3, 15.0, 4.0, 20.0, 3.9, 0.0, 15.0, 7.0, 3.0}},
755 {80, {-8.07, 0.42, -1.29, 0.76, 1.12, 1.04, 1.68, 0.14, -2.16, 0.74, 0.0,
756 0.0, 2.3, 10.5, 15.7, 4.0, 20.0, 3.9, 0.0, 15.0, 7.0, 3.0}},
757 {90, {-7.95, 0.59, -0.41, 0.59, 1.04, 0.63, 1.7, 0.17, -2.21, 0.61, 0.0,
758 0.0, 2.3, 10.5, 15.7, 4.0, 20.0, 3.9, 0.0, 15.0, 7.0, 3.0}},
759 }},
760};
761
762/**
763 * The nested map containing the 3GPP value tables for the NTN Urban LOS scenario.
764 * The outer key specifies the band (either "S" or "Ka"), while the inner key represents
765 * the quantized elevation angle.
766 * The inner vector collects the table3gpp values.
767 */
768static const std::map<std::string, std::map<int, std::array<float, 22>>> NTNUrbanLOS{
769 {"S",
770 {
771 {10, {-7.97, 1.0, -2.6, 0.79, 0.18, 0.74, -0.63, 2.6, -2.54, 2.62, 31.83,
772 13.84, 2.5, 8.0, 4.0, 4.0, 20.0, 3.9, 0.09, 12.55, 1.25, 3.0}},
773 {20, {-8.12, 0.83, -2.48, 0.8, 0.42, 0.9, -0.15, 3.31, -2.67, 2.96, 18.78,
774 13.78, 2.5, 8.0, 4.0, 3.0, 20.0, 3.9, 0.09, 12.76, 3.23, 3.0}},
775 {30, {-8.21, 0.68, -2.44, 0.91, 0.41, 1.3, 0.54, 1.1, -2.03, 0.86, 10.49,
776 10.42, 2.5, 8.0, 4.0, 3.0, 20.0, 3.9, 0.12, 14.36, 4.39, 3.0}},
777 {40, {-8.31, 0.48, -2.6, 1.02, 0.18, 1.69, 0.35, 1.59, -2.28, 1.19, 7.46,
778 8.01, 2.5, 8.0, 4.0, 3.0, 20.0, 3.9, 0.16, 16.42, 5.72, 3.0}},
779 {50, {-8.37, 0.38, -2.71, 1.17, -0.07, 2.04, 0.27, 1.62, -2.48, 1.4, 6.52,
780 8.27, 2.5, 8.0, 4.0, 3.0, 20.0, 3.9, 0.2, 17.13, 6.17, 3.0}},
781 {60, {-8.39, 0.24, -2.76, 1.17, -0.43, 2.54, 0.26, 0.97, -2.56, 0.85, 5.47,
782 7.26, 2.5, 8.0, 4.0, 3.0, 20.0, 3.9, 0.28, 19.01, 7.36, 3.0}},
783 {70, {-8.38, 0.18, -2.78, 1.2, -0.64, 2.47, -0.12, 1.99, -2.96, 1.61, 4.54,
784 5.53, 2.5, 8.0, 4.0, 3.0, 20.0, 3.9, 0.44, 19.31, 7.3, 3.0}},
785 {80, {-8.35, 0.13, -2.65, 1.45, -0.91, 2.69, -0.21, 1.82, -3.08, 1.49, 4.03,
786 4.49, 2.5, 8.0, 4.0, 3.0, 20.0, 3.9, 0.9, 22.39, 7.7, 3.0}},
787 {90, {-8.34, 0.09, -2.27, 1.85, -0.54, 1.66, -0.07, 1.43, -3.0, 1.09, 3.68,
788 3.14, 2.5, 8.0, 4.0, 3.0, 20.0, 3.9, 2.87, 27.8, 9.25, 3.0}},
789 }},
790 {"Ka",
791 {
792 {10, {-8.52, 0.92, -3.18, 0.79, -0.4, 0.77, -0.67, 2.22, -2.61, 2.41, 40.18,
793 16.99, 2.5, 8.0, 4.0, 4.0, 20.0, 1.6, 0.09, 11.8, 1.14, 3.0}},
794 {20, {-8.59, 0.79, -3.05, 0.87, -0.15, 0.97, -0.34, 3.04, -2.82, 2.59, 23.62,
795 18.96, 2.5, 8.0, 4.0, 3.0, 20.0, 1.6, 0.09, 11.6, 2.78, 3.0}},
796 {30, {-8.51, 0.65, -2.98, 1.04, -0.18, 1.58, 0.07, 1.33, -2.48, 1.02, 12.48,
797 14.23, 2.5, 8.0, 4.0, 3.0, 20.0, 1.6, 0.11, 13.05, 3.87, 3.0}},
798 {40, {-8.49, 0.48, -3.11, 1.06, -0.31, 1.69, -0.08, 1.45, -2.76, 1.27, 8.56,
799 11.06, 2.5, 8.0, 4.0, 3.0, 20.0, 1.6, 0.15, 14.56, 4.94, 3.0}},
800 {50, {-8.48, 0.46, -3.19, 1.12, -0.58, 2.13, -0.21, 1.62, -2.93, 1.38, 7.42,
801 11.21, 2.5, 8.0, 4.0, 3.0, 20.0, 1.6, 0.18, 15.35, 5.41, 3.0}},
802 {60, {-8.44, 0.34, -3.25, 1.14, -0.9, 2.51, -0.25, 1.06, -3.05, 0.96, 5.97,
803 9.47, 2.5, 8.0, 4.0, 3.0, 20.0, 1.6, 0.27, 16.97, 6.31, 3.0}},
804 {70, {-8.4, 0.27, -3.33, 1.25, -1.16, 2.47, -0.61, 1.88, -3.45, 1.51, 4.88,
805 7.24, 2.5, 8.0, 4.0, 3.0, 20.0, 1.6, 0.42, 17.96, 6.66, 3.0}},
806 {80, {-8.37, 0.19, -3.22, 1.35, -1.48, 2.61, -0.79, 1.87, -3.66, 1.49, 4.22,
807 5.79, 2.5, 8.0, 4.0, 3.0, 20.0, 1.6, 0.86, 20.68, 7.31, 3.0}},
808 {90, {-8.35, 0.14, -2.83, 1.62, -1.14, 1.7, -0.58, 1.19, -3.56, 0.89, 3.81,
809 4.25, 2.5, 8.0, 4.0, 3.0, 20.0, 1.6, 2.55, 25.08, 9.23, 3.0}},
810 }},
811};
812
813/**
814 * The nested map containing the 3GPP value tables for the NTN Urban NLOS scenario.
815 * The outer key specifies the band (either "S" or "Ka"), while the inner key represents
816 * the quantized elevation angle.
817 * The inner vector collects the table3gpp values.
818 */
819static const std::map<std::string, std::map<int, std::array<float, 22>>> NTNUrbanNLOS{
820 {"S",
821 {
822 {10, {-7.24, 1.26, -1.58, 0.89, 0.13, 2.99, -1.13, 2.66, -2.87, 2.76, 0.0,
823 0.0, 2.3, 7.0, 3.0, 3.0, 20.0, 1.6, 0.08, 14.72, 1.57, 3.0}},
824 {20, {-7.7, 0.99, -1.67, 0.89, 0.19, 3.12, 0.49, 2.03, -2.68, 2.76, 0.0,
825 0.0, 2.3, 7.0, 3.0, 3.0, 20.0, 1.6, 0.1, 14.62, 4.3, 3.0}},
826 {30, {-7.82, 0.86, -1.84, 1.3, 0.44, 2.69, 0.95, 1.54, -2.12, 1.54, 0.0,
827 0.0, 2.3, 7.0, 3.0, 3.0, 20.0, 1.6, 0.14, 16.4, 6.64, 3.0}},
828 {40, {-8.04, 0.75, -2.02, 1.15, 0.48, 2.45, 1.15, 1.02, -2.27, 1.77, 0.0,
829 0.0, 2.3, 7.0, 3.0, 3.0, 20.0, 1.6, 0.22, 17.86, 9.21, 3.0}},
830 {50, {-8.08, 0.77, -2.06, 1.23, 0.56, 2.17, 1.14, 1.61, -2.5, 2.36, 0.0,
831 0.0, 2.3, 7.0, 3.0, 3.0, 20.0, 1.6, 0.31, 19.74, 10.32, 3.0}},
832 {60, {-8.1, 0.76, -1.99, 1.02, 0.55, 1.93, 1.13, 1.84, -2.47, 2.33, 0.0,
833 0.0, 2.3, 7.0, 3.0, 3.0, 20.0, 1.6, 0.49, 19.73, 10.3, 3.0}},
834 {70, {-8.16, 0.73, -2.19, 1.78, 0.48, 1.72, 1.16, 1.81, -2.83, 2.84, 0.0,
835 0.0, 2.3, 7.0, 3.0, 2.0, 20.0, 1.6, 0.97, 20.5, 10.2, 3.0}},
836 {80, {-8.03, 0.79, -1.88, 1.55, 0.53, 1.51, 1.28, 1.35, -2.82, 2.87, 0.0,
837 0.0, 2.3, 7.0, 3.0, 2.0, 20.0, 1.6, 1.52, 26.16, 12.27, 3.0}},
838 {90, {-8.33, 0.7, -2.0, 1.4, 0.32, 1.2, 1.42, 0.6, -4.55, 4.27, 0.0,
839 0.0, 2.3, 7.0, 3.0, 2.0, 20.0, 1.6, 5.36, 25.83, 12.75, 3.0}},
840 }},
841 {"Ka",
842 {
843 {10, {-7.24, 1.26, -1.58, 0.89, 0.13, 2.99, -1.13, 2.66, -2.87, 2.76, 0.0,
844 0.0, 2.3, 7.0, 3.0, 3.0, 20.0, 1.6, 0.08, 14.72, 1.57, 3.0}},
845 {20, {-7.7, 0.99, -1.67, 0.89, 0.19, 3.12, 0.49, 2.03, -2.68, 2.76, 0.0,
846 0.0, 2.3, 7.0, 3.0, 3.0, 20.0, 1.6, 0.1, 14.62, 4.3, 3.0}},
847 {30, {-7.82, 0.86, -1.84, 1.3, 0.44, 2.69, 0.95, 1.54, -2.12, 1.54, 0.0,
848 0.0, 2.3, 7.0, 3.0, 3.0, 20.0, 1.6, 0.14, 16.4, 6.64, 3.0}},
849 {40, {-8.04, 0.75, -2.02, 1.15, 0.48, 2.45, 1.15, 1.02, -2.27, 1.77, 0.0,
850 0.0, 2.3, 7.0, 3.0, 3.0, 20.0, 1.6, 0.22, 17.86, 9.21, 3.0}},
851 {50, {-8.08, 0.77, -2.06, 1.23, 0.56, 2.17, 1.14, 1.61, -2.5, 2.36, 0.0,
852 0.0, 2.3, 7.0, 3.0, 3.0, 20.0, 1.6, 0.31, 19.74, 10.32, 3.0}},
853 {60, {-8.1, 0.76, -1.99, 1.02, 0.55, 1.93, 1.13, 1.84, -2.47, 2.33, 0.0,
854 0.0, 2.3, 7.0, 3.0, 3.0, 20.0, 1.6, 0.49, 19.73, 10.3, 3.0}},
855 {70, {-8.16, 0.73, -2.19, 1.78, 0.48, 1.72, 1.16, 1.81, -2.83, 2.84, 0.0,
856 0.0, 2.3, 7.0, 3.0, 2.0, 20.0, 1.6, 0.97, 20.5, 10.2, 3.0}},
857 {80, {-8.03, 0.79, -1.88, 1.55, 0.53, 1.51, 1.28, 1.35, -2.82, 2.87, 0.0,
858 0.0, 2.3, 7.0, 3.0, 2.0, 20.0, 1.6, 1.52, 26.16, 12.27, 3.0}},
859 {90, {-8.33, 0.7, -2.0, 1.4, 0.32, 1.2, 1.42, 0.6, -4.55, 4.27, 0.0,
860 0.0, 2.3, 7.0, 3.0, 2.0, 20.0, 1.6, 5.36, 25.83, 12.75, 3.0}},
861 }},
862};
863
864/**
865 * The nested map containing the 3GPP value tables for the NTN Suburban LOS scenario.
866 * The outer key specifies the band (either "S" or "Ka"), while the inner key represents
867 * the quantized elevation angle.
868 * The inner vector collects the table3gpp values.
869 */
870static const std::map<std::string, std::map<int, std::array<float, 22>>> NTNSuburbanLOS{
871 {"S",
872 {
873 {10, {-8.16, 0.99, -3.57, 1.62, 0.05, 1.84, -1.78, 0.62, -1.06, 0.96, 11.4,
874 6.26, 2.2, 21.3, 7.6, 3.0, 20.0, 1.6, 0.0, 11.0, 7.0, 3.0}},
875 {20, {-8.56, 0.96, -3.8, 1.74, -0.38, 1.94, -1.84, 0.81, -1.21, 0.95, 19.45,
876 10.32, 3.36, 21.0, 8.9, 3.0, 20.0, 1.6, 0.0, 11.0, 7.0, 3.0}},
877 {30, {-8.72, 0.79, -3.77, 1.72, -0.56, 1.75, -1.67, 0.57, -1.28, 0.49, 20.8,
878 16.34, 3.5, 21.2, 8.5, 3.0, 20.0, 1.6, 0.0, 11.0, 7.0, 3.0}},
879 {40, {-8.71, 0.81, -3.57, 1.6, -0.59, 1.82, -1.59, 0.86, -1.32, 0.79, 21.2,
880 15.63, 2.81, 21.1, 8.4, 3.0, 20.0, 1.6, 0.0, 11.0, 7.0, 3.0}},
881 {50, {-8.72, 1.12, -3.42, 1.49, -0.58, 1.87, -1.55, 1.05, -1.39, 0.97, 21.6,
882 14.22, 2.39, 20.7, 9.2, 3.0, 20.0, 1.6, 0.0, 11.0, 7.0, 3.0}},
883 {60, {-8.66, 1.23, -3.27, 1.43, -0.55, 1.92, -1.51, 1.23, -1.36, 1.17, 19.75,
884 14.19, 2.73, 20.6, 9.8, 3.0, 20.0, 1.6, 0.0, 11.0, 7.0, 3.0}},
885 {70, {-8.38, 0.55, -3.08, 1.36, -0.28, 1.16, -1.27, 0.54, -1.08, 0.62, 12.0,
886 5.7, 2.07, 20.3, 10.8, 2.0, 20.0, 1.6, 0.0, 11.0, 7.0, 3.0}},
887 {80, {-8.34, 0.63, -2.75, 1.26, -0.17, 1.09, -1.28, 0.67, -1.31, 0.76, 12.85,
888 9.91, 2.04, 19.8, 12.2, 2.0, 20.0, 1.6, 0.0, 11.0, 7.0, 3.0}},
889 {90, {-8.34, 0.63, -2.75, 1.26, -0.17, 1.09, -1.28, 0.67, -1.31, 0.76, 12.85,
890 9.91, 2.04, 19.1, 13.0, 2.0, 20.0, 1.6, 0.0, 11.0, 7.0, 3.0}},
891 }},
892 {"Ka",
893 {
894 {10, {-8.07, 0.46, -3.55, 0.48, 0.89, 0.67, 0.63, 0.35, -3.37, 0.28, 8.9,
895 4.4, 2.5, 23.2, 5.0, 3.0, 20.0, 1.6, 0.0, 11.0, 7.0, 3.0}},
896 {20, {-8.61, 0.45, -3.69, 0.41, 0.31, 0.78, 0.76, 0.3, -3.28, 0.27, 14.0,
897 4.6, 2.5, 23.6, 4.5, 3.0, 20.0, 1.6, 0.0, 11.0, 7.0, 3.0}},
898 {30, {-8.72, 0.28, -3.59, 0.41, 0.02, 0.75, 1.11, 0.28, -3.04, 0.26, 11.3,
899 3.7, 2.5, 23.5, 4.7, 3.0, 20.0, 1.6, 0.0, 11.0, 7.0, 3.0}},
900 {40, {-8.63, 0.17, -3.38, 0.35, -0.1, 0.65, 1.37, 0.23, -2.88, 0.21, 9.0,
901 3.5, 2.5, 23.4, 5.2, 3.0, 20.0, 1.6, 0.0, 11.0, 7.0, 3.0}},
902 {50, {-8.54, 0.14, -3.23, 0.35, -0.19, 0.55, 1.53, 0.23, -2.83, 0.18, 7.5,
903 3.0, 2.5, 23.2, 5.7, 3.0, 20.0, 1.6, 0.0, 11.0, 7.0, 3.0}},
904 {60, {-8.48, 0.15, -3.19, 0.43, -0.54, 0.96, 1.65, 0.17, -2.86, 0.17, 6.6,
905 2.6, 2.5, 23.3, 5.9, 3.0, 20.0, 1.6, 0.0, 11.0, 7.0, 3.0}},
906 {70, {-8.42, 0.09, -2.83, 0.33, -0.24, 0.43, 1.74, 0.11, -2.95, 0.1, 5.9,
907 1.7, 2.5, 23.4, 6.2, 2.0, 20.0, 1.6, 0.0, 11.0, 7.0, 3.0}},
908 {80, {-8.39, 0.05, -2.66, 0.44, -0.52, 0.93, 1.82, 0.05, -3.21, 0.07, 5.5,
909 0.7, 2.5, 23.2, 7.0, 2.0, 20.0, 1.6, 0.0, 11.0, 7.0, 3.0}},
910 {90, {-8.37, 0.02, -1.22, 0.31, -0.15, 0.44, 1.87, 0.02, -3.49, 0.24, 5.4,
911 0.3, 2.5, 23.1, 7.6, 2.0, 20.0, 1.6, 0.0, 11.0, 7.0, 3.0}},
912 }},
913};
914
915/**
916 * The nested map containing the 3GPP value tables for the NTN Suburban NLOS scenario.
917 * The outer key specifies the band (either "S" or "Ka"), while the inner key represents
918 * the quantized elevation angle.
919 * The inner vector collects the table3gpp values.
920 */
921static const std::map<std::string, std::map<int, std::array<float, 22>>> NTNSuburbanNLOS{
922 {"S",
923 {
924 {10, {-7.43, 0.5, -2.89, 0.41, 1.49, 0.4, 0.81, 0.36, -3.09, 0.32, 0.0,
925 0.0, 2.3, 22.5, 5.0, 4.0, 20.0, 1.6, 0.0, 15.0, 7.0, 3.0}},
926 {20, {-7.63, 0.61, -2.76, 0.41, 1.24, 0.82, 1.06, 0.41, -2.93, 0.47, 0.0,
927 0.0, 2.3, 19.4, 8.5, 4.0, 20.0, 1.6, 0.0, 15.0, 7.0, 3.0}},
928 {30, {-7.86, 0.56, -2.64, 0.41, 1.06, 0.71, 1.12, 0.4, -2.91, 0.46, 0.0,
929 0.0, 2.3, 15.5, 10.0, 4.0, 20.0, 1.6, 0.0, 15.0, 7.0, 3.0}},
930 {40, {-7.96, 0.58, -2.41, 0.52, 0.91, 0.55, 1.14, 0.39, -2.78, 0.54, 0.0,
931 0.0, 2.3, 13.9, 10.6, 4.0, 20.0, 1.6, 0.0, 15.0, 7.0, 3.0}},
932 {50, {-7.98, 0.59, -2.42, 0.7, 0.98, 0.58, 1.29, 0.35, -2.7, 0.45, 0.0,
933 0.0, 2.3, 11.7, 10.0, 4.0, 20.0, 1.6, 0.0, 15.0, 7.0, 3.0}},
934 {60, {-8.45, 0.47, -2.53, 0.5, 0.49, 1.37, 1.38, 0.36, -3.03, 0.36, 0.0,
935 0.0, 2.3, 9.8, 9.1, 3.0, 20.0, 1.6, 0.0, 15.0, 7.0, 3.0}},
936 {70, {-8.21, 0.36, -2.35, 0.58, 0.73, 0.49, 1.36, 0.29, -2.9, 0.42, 0.0,
937 0.0, 2.3, 10.3, 9.1, 3.0, 20.0, 1.6, 0.0, 15.0, 7.0, 3.0}},
938 {80, {-8.69, 0.29, -2.31, 0.73, -0.04, 1.48, 1.38, 0.2, -3.2, 0.3, 0.0,
939 0.0, 2.3, 15.6, 9.1, 3.0, 20.0, 1.6, 0.0, 15.0, 7.0, 3.0}},
940 {90, {-8.69, 0.29, -2.31, 0.73, -0.04, 1.48, 1.38, 0.2, -3.2, 0.3, 0.0,
941 0.0, 2.3, 15.6, 9.1, 3.0, 20.0, 1.6, 0.0, 15.0, 7.0, 3.0}},
942 }},
943 {"Ka",
944 {
945 {10, {-7.43, 0.5, -2.89, 0.41, 1.49, 0.4, 0.81, 0.36, -3.09, 0.32, 0.0,
946 0.0, 2.3, 22.5, 5.0, 4.0, 20.0, 1.6, 0.0, 15.0, 7.0, 3.0}},
947 {20, {-7.63, 0.61, -2.76, 0.41, 1.24, 0.82, 1.06, 0.41, -2.93, 0.47, 0.0,
948 0.0, 2.3, 19.4, 8.5, 4.0, 20.0, 1.6, 0.0, 15.0, 7.0, 3.0}},
949 {30, {-7.86, 0.56, -2.64, 0.41, 1.06, 0.71, 1.12, 0.4, -2.91, 0.46, 0.0,
950 0.0, 2.3, 15.5, 10.0, 4.0, 20.0, 1.6, 0.0, 15.0, 7.0, 3.0}},
951 {40, {-7.96, 0.58, -2.41, 0.52, 0.91, 0.55, 1.14, 0.39, -2.78, 0.54, 0.0,
952 0.0, 2.3, 13.9, 10.6, 4.0, 20.0, 1.6, 0.0, 15.0, 7.0, 3.0}},
953 {50, {-7.98, 0.59, -2.42, 0.7, 0.98, 0.58, 1.29, 0.35, -2.7, 0.45, 0.0,
954 0.0, 2.3, 11.7, 10.0, 4.0, 20.0, 1.6, 0.0, 15.0, 7.0, 3.0}},
955 {60, {-8.45, 0.47, -2.53, 0.5, 0.49, 1.37, 1.38, 0.36, -3.03, 0.36, 0.0,
956 0.0, 2.3, 9.8, 9.1, 3.0, 20.0, 1.6, 0.0, 15.0, 7.0, 3.0}},
957 {70, {-8.21, 0.36, -2.35, 0.58, 0.73, 0.49, 1.36, 0.29, -2.9, 0.42, 0.0,
958 0.0, 2.3, 10.3, 9.1, 3.0, 20.0, 1.6, 0.0, 15.0, 7.0, 3.0}},
959 {80, {-8.69, 0.29, -2.31, 0.73, -0.04, 1.48, 1.38, 0.2, -3.2, 0.3, 0.0,
960 0.0, 2.3, 15.6, 9.1, 3.0, 20.0, 1.6, 0.0, 15.0, 7.0, 3.0}},
961 {90, {-8.69, 0.29, -2.31, 0.73, -0.04, 1.48, 1.38, 0.2, -3.2, 0.3, 0.0,
962 0.0, 2.3, 15.6, 9.1, 3.0, 20.0, 1.6, 0.0, 15.0, 7.0, 3.0}},
963 }},
964};
965
966/**
967 * The nested map containing the 3GPP value tables for the NTN Rural LOS scenario.
968 * The outer key specifies the band (either "S" or "Ka"), while the inner key represents
969 * the quantized elevation angle.
970 * The inner vector collects the table3gpp values.
971 */
972static const std::map<std::string, std::map<int, std::array<float, 22>>> NTNRuralLOS{
973 {"S",
974 {
975 {10, {-9.55, 0.66, -3.42, 0.89, -9.45, 7.83, -4.2, 6.3, -6.03, 5.19, 24.72,
976 5.07, 3.8, 12.0, 4.0, 2.0, 20.0, 0.0, 0.39, 10.81, 1.94, 3.0}},
977 {20, {-8.68, 0.44, -3.0, 0.63, -4.45, 6.86, -2.31, 5.04, -4.31, 4.18, 12.31,
978 5.75, 3.8, 12.0, 4.0, 2.0, 20.0, 0.0, 0.31, 8.09, 1.83, 3.0}},
979 {30, {-8.46, 0.28, -2.86, 0.52, -2.39, 5.14, -0.28, 0.81, -2.57, 0.61, 8.05,
980 5.46, 3.8, 12.0, 4.0, 2.0, 20.0, 0.0, 0.29, 13.7, 2.28, 3.0}},
981 {40, {-8.36, 0.19, -2.78, 0.45, -1.28, 3.44, -0.38, 1.16, -2.59, 0.79, 6.21,
982 5.23, 3.8, 12.0, 4.0, 2.0, 20.0, 0.0, 0.37, 20.05, 2.93, 3.0}},
983 {50, {-8.29, 0.14, -2.7, 0.42, -0.99, 2.59, -0.38, 0.82, -2.59, 0.65, 5.04,
984 3.95, 3.8, 12.0, 4.0, 2.0, 20.0, 0.0, 0.61, 24.51, 2.84, 3.0}},
985 {60, {-8.26, 0.1, -2.66, 0.41, -1.05, 2.42, -0.46, 0.67, -2.65, 0.52, 4.42,
986 3.75, 3.8, 12.0, 4.0, 2.0, 20.0, 0.0, 0.9, 26.35, 3.17, 3.0}},
987 {70, {-8.22, 0.1, -2.53, 0.42, -0.9, 1.78, -0.49, 1.0, -2.69, 0.78, 3.92,
988 2.56, 3.8, 12.0, 4.0, 2.0, 20.0, 0.0, 1.43, 31.84, 3.88, 3.0}},
989 {80, {-8.2, 0.05, -2.21, 0.5, -0.89, 1.65, -0.53, 1.18, -2.65, 1.01, 3.65,
990 1.77, 3.8, 12.0, 4.0, 2.0, 20.0, 0.0, 2.87, 36.62, 4.17, 3.0}},
991 {90, {-8.19, 0.06, -1.78, 0.91, -0.81, 1.26, -0.46, 0.91, -2.65, 0.71, 3.59,
992 1.77, 3.8, 12.0, 4.0, 2.0, 20.0, 0.0, 5.48, 36.77, 4.29, 3.0}},
993 }},
994 {"Ka",
995 {
996 {10, {-9.68, 0.46, -4.03, 0.91, -9.74, 7.52, -5.85, 6.51, -7.45, 5.3, 25.43,
997 7.04, 3.8, 12.0, 4.0, 2.0, 20.0, 0.0, 0.36, 4.63, 0.75, 3.0}},
998 {20, {-8.86, 0.29, -3.55, 0.7, -4.88, 6.67, -3.27, 5.36, -5.25, 4.42, 12.72,
999 7.47, 3.8, 12.0, 4.0, 2.0, 20.0, 0.0, 0.3, 6.83, 1.25, 3.0}},
1000 {30, {-8.59, 0.18, -3.45, 0.55, -2.6, 4.63, -0.88, 0.93, -3.16, 0.68, 8.4,
1001 7.18, 3.8, 12.0, 4.0, 2.0, 20.0, 0.0, 0.25, 12.91, 1.93, 3.0}},
1002 {40, {-8.46, 0.19, -3.38, 0.52, -1.92, 3.45, -0.93, 0.96, -3.15, 0.73, 6.52,
1003 6.88, 3.8, 12.0, 4.0, 2.0, 20.0, 0.0, 0.35, 18.9, 2.37, 3.0}},
1004 {50, {-8.36, 0.14, -3.33, 0.46, -1.56, 2.44, -0.99, 0.97, -3.2, 0.77, 5.24,
1005 5.28, 3.8, 12.0, 4.0, 2.0, 20.0, 0.0, 0.53, 22.44, 2.66, 3.0}},
1006 {60, {-8.3, 0.15, -3.29, 0.43, -1.66, 2.38, -1.04, 0.83, -3.27, 0.61, 4.57,
1007 4.92, 3.8, 12.0, 4.0, 2.0, 20.0, 0.0, 0.88, 25.69, 3.23, 3.0}},
1008 {70, {-8.26, 0.13, -3.24, 0.46, -1.59, 1.67, -1.17, 1.01, -3.42, 0.74, 4.02,
1009 3.4, 3.8, 12.0, 4.0, 2.0, 20.0, 0.0, 1.39, 27.95, 3.71, 3.0}},
1010 {80, {-8.22, 0.03, -2.9, 0.44, -1.58, 1.44, -1.19, 1.01, -3.36, 0.79, 3.7,
1011 2.22, 3.8, 12.0, 4.0, 2.0, 20.0, 0.0, 2.7, 31.45, 4.17, 3.0}},
1012 {90, {-8.21, 0.07, -2.5, 0.82, -1.51, 1.13, -1.13, 0.85, -3.35, 0.65, 3.62,
1013 2.28, 3.8, 12.0, 4.0, 2.0, 20.0, 0.0, 4.97, 28.01, 4.14, 3.0}},
1014 }},
1015};
1016
1017/**
1018 * The nested map containing the 3GPP value tables for the NTN Rural NLOS scenario
1019 * The outer key specifies the band (either "S" or "Ka"), while the inner key represents
1020 * the quantized elevation angle.
1021 * The inner vector collects the table3gpp values.
1022 */
1023static const std::map<std::string, std::map<int, std::array<float, 22>>> NTNRuralNLOS{
1024 {"S",
1025 {
1026 {10, {-9.01, 1.59, -2.9, 1.34, -3.33, 6.22, -0.88, 3.26, -4.92, 3.96, 0.0,
1027 0.0, 1.7, 7.0, 3.0, 3.0, 20.0, 0.0, 0.03, 18.16, 2.32, 3.0}},
1028 {20, {-8.37, 0.95, -2.5, 1.18, -0.74, 4.22, -0.07, 3.29, -4.06, 4.07, 0.0,
1029 0.0, 1.7, 7.0, 3.0, 3.0, 20.0, 0.0, 0.05, 26.82, 7.34, 3.0}},
1030 {30, {-8.05, 0.92, -2.12, 1.08, 0.08, 3.02, 0.75, 1.92, -2.33, 1.7, 0.0,
1031 0.0, 1.7, 7.0, 3.0, 2.0, 20.0, 0.0, 0.07, 21.99, 8.28, 3.0}},
1032 {40, {-7.92, 0.92, -1.99, 1.06, 0.32, 2.45, 0.72, 1.92, -2.24, 2.01, 0.0,
1033 0.0, 1.7, 7.0, 3.0, 2.0, 20.0, 0.0, 0.1, 22.86, 8.76, 3.0}},
1034 {50, {-7.92, 0.87, -1.9, 1.05, 0.53, 1.63, 0.95, 1.45, -2.24, 2.0, 0.0,
1035 0.0, 1.7, 7.0, 3.0, 2.0, 20.0, 0.0, 0.15, 25.93, 9.68, 3.0}},
1036 {60, {-7.96, 0.87, -1.85, 1.06, 0.33, 2.08, 0.97, 1.62, -2.22, 1.82, 0.0,
1037 0.0, 1.7, 7.0, 3.0, 2.0, 20.0, 0.0, 0.22, 27.79, 9.94, 3.0}},
1038 {70, {-7.91, 0.82, -1.69, 1.14, 0.55, 1.58, 1.1, 1.43, -2.19, 1.66, 0.0,
1039 0.0, 1.7, 7.0, 3.0, 2.0, 20.0, 0.0, 0.5, 28.5, 8.9, 3.0}},
1040 {80, {-7.79, 0.86, -1.46, 1.16, 0.45, 2.01, 0.97, 1.88, -2.41, 2.58, 0.0,
1041 0.0, 1.7, 7.0, 3.0, 2.0, 20.0, 0.0, 1.04, 37.53, 13.74, 3.0}},
1042 {90, {-7.74, 0.81, -1.32, 1.3, 0.4, 2.19, 1.35, 0.62, -2.45, 2.52, 0.0,
1043 0.0, 1.7, 7.0, 3.0, 2.0, 20.0, 0.0, 2.11, 29.23, 12.16, 3.0}},
1044 }},
1045 {"Ka",
1046 {
1047 {10, {-9.13, 1.91, -2.9, 1.32, -3.4, 6.28, -1.19, 3.81, -5.47, 4.39, 0.0,
1048 0.0, 1.7, 7.0, 3.0, 3.0, 20.0, 0.0, 0.03, 18.21, 2.13, 3.0}},
1049 {20, {-8.39, 0.94, -2.53, 1.18, -0.51, 3.75, -0.11, 3.33, -4.06, 4.04, 0.0,
1050 0.0, 1.7, 7.0, 3.0, 3.0, 20.0, 0.0, 0.05, 24.08, 6.52, 3.0}},
1051 {30, {-8.1, 0.92, -2.16, 1.08, 0.06, 2.95, 0.72, 1.93, -2.32, 1.54, 0.0,
1052 0.0, 1.7, 7.0, 3.0, 2.0, 20.0, 0.0, 0.07, 22.06, 7.72, 3.0}},
1053 {40, {-7.96, 0.94, -2.04, 1.09, 0.2, 2.65, 0.69, 1.91, -2.19, 1.73, 0.0,
1054 0.0, 1.7, 7.0, 3.0, 2.0, 20.0, 0.0, 0.09, 21.4, 8.45, 3.0}},
1055 {50, {-7.99, 0.89, -1.99, 1.08, 0.4, 1.85, 0.84, 1.7, -2.16, 1.5, 0.0,
1056 0.0, 1.7, 7.0, 3.0, 2.0, 20.0, 0.0, 0.16, 24.26, 8.92, 3.0}},
1057 {60, {-8.05, 0.87, -1.95, 1.06, 0.32, 1.83, 0.99, 1.27, -2.24, 1.64, 0.0,
1058 0.0, 1.7, 7.0, 3.0, 2.0, 20.0, 0.0, 0.22, 24.15, 8.76, 3.0}},
1059 {70, {-8.01, 0.82, -1.81, 1.17, 0.46, 1.57, 0.95, 1.86, -2.29, 1.66, 0.0,
1060 0.0, 1.7, 7.0, 3.0, 2.0, 20.0, 0.0, 0.51, 25.99, 9.0, 3.0}},
1061 {80, {-8.05, 1.65, -1.56, 1.2, 0.33, 1.99, 0.92, 1.84, -2.65, 2.86, 0.0,
1062 0.0, 1.7, 7.0, 3.0, 2.0, 20.0, 0.0, 0.89, 36.07, 13.6, 3.0}},
1063 {90, {-7.91, 0.76, -1.53, 1.27, 0.24, 2.18, 1.29, 0.59, -2.23, 1.12, 0.0,
1064 0.0, 1.7, 7.0, 3.0, 2.0, 20.0, 0.0, 1.68, 24.51, 10.56, 3.0}},
1065 }},
1066};
1067
1079
1084
1085void
1086ThreeGppChannelModel::DoDispose()
1087{
1088 NS_LOG_FUNCTION(this);
1089 if (m_channelConditionModel)
1090 {
1091 m_channelConditionModel->Dispose();
1092 }
1093 m_channelMatrixMap.clear();
1094 m_channelParamsMap.clear();
1095 m_channelConditionModel = nullptr;
1096}
1097
1098TypeId
1099ThreeGppChannelModel::GetTypeId()
1100{
1101 static TypeId tid =
1102 TypeId("ns3::ThreeGppChannelModel")
1103 .SetGroupName("Spectrum")
1104 .SetParent<MatrixBasedChannelModel>()
1105 .AddConstructor<ThreeGppChannelModel>()
1106 .AddAttribute("Frequency",
1107 "The operating Frequency in Hz",
1108 DoubleValue(500.0e6),
1109 MakeDoubleAccessor(&ThreeGppChannelModel::SetFrequency,
1110 &ThreeGppChannelModel::GetFrequency),
1111 MakeDoubleChecker<double>())
1112 .AddAttribute(
1113 "Scenario",
1114 "The 3GPP scenario (RMa, UMa, UMi-StreetCanyon, InH-OfficeOpen, InH-OfficeMixed, "
1115 "NTN-DenseUrban, NTN-Urban, NTN-Suburban, NTN-Rural)",
1116 StringValue("UMa"),
1117 MakeStringAccessor(&ThreeGppChannelModel::SetScenario,
1118 &ThreeGppChannelModel::GetScenario),
1119 MakeStringChecker())
1120 .AddAttribute("ChannelConditionModel",
1121 "Pointer to the channel condition model",
1122 PointerValue(),
1123 MakePointerAccessor(&ThreeGppChannelModel::SetChannelConditionModel,
1124 &ThreeGppChannelModel::GetChannelConditionModel),
1125 MakePointerChecker<ChannelConditionModel>())
1126 .AddAttribute("UpdatePeriod",
1127 "Specify the channel coherence time",
1128 TimeValue(MilliSeconds(0)),
1129 MakeTimeAccessor(&ThreeGppChannelModel::m_updatePeriod),
1130 MakeTimeChecker())
1131 // attributes for the blockage model
1132 .AddAttribute("Blockage",
1133 "Enable blockage model A (sec 7.6.4.1)",
1134 BooleanValue(false),
1135 MakeBooleanAccessor(&ThreeGppChannelModel::m_blockage),
1136 MakeBooleanChecker())
1137 .AddAttribute("NumNonselfBlocking",
1138 "number of non-self-blocking regions",
1139 IntegerValue(4),
1140 MakeIntegerAccessor(&ThreeGppChannelModel::m_numNonSelfBlocking),
1141 MakeIntegerChecker<uint16_t>())
1142 .AddAttribute("PortraitMode",
1143 "true for portrait mode, false for landscape mode",
1144 BooleanValue(true),
1145 MakeBooleanAccessor(&ThreeGppChannelModel::m_portraitMode),
1146 MakeBooleanChecker())
1147 .AddAttribute("BlockerSpeed",
1148 "The speed of moving blockers, the unit is m/s",
1149 DoubleValue(1),
1150 MakeDoubleAccessor(&ThreeGppChannelModel::m_blockerSpeed),
1151 MakeDoubleChecker<double>())
1152 .AddAttribute("vScatt",
1153 "Maximum speed of the vehicle in the layout (see 3GPP TR 37.885 v15.3.0, "
1154 "Sec. 6.2.3)."
1155 "Used to compute the additional contribution for the Doppler of"
1156 "delayed (reflected) paths",
1157 DoubleValue(0.0),
1158 MakeDoubleAccessor(&ThreeGppChannelModel::m_vScatt),
1159 MakeDoubleChecker<double>(0.0))
1160
1161 ;
1162 return tid;
1163}
1164
1165void
1171
1172Ptr<ChannelConditionModel>
1178
1179void
1180ThreeGppChannelModel::SetFrequency(double f)
1181{
1182 NS_LOG_FUNCTION(this);
1183 NS_ASSERT_MSG(f >= 500.0e6 && f <= 100.0e9,
1184 "Frequency should be between 0.5 and 100 GHz but is " << f);
1185 m_frequency = f;
1186}
1187
1188double
1189ThreeGppChannelModel::GetFrequency() const
1190{
1191 NS_LOG_FUNCTION(this);
1192 return m_frequency;
1193}
1194
1195void
1196ThreeGppChannelModel::SetScenario(const std::string& scenario)
1197{
1198 NS_LOG_FUNCTION(this);
1199 NS_ASSERT_MSG(scenario == "RMa" || scenario == "UMa" || scenario == "UMi-StreetCanyon" ||
1200 scenario == "InH-OfficeOpen" || scenario == "InH-OfficeMixed" ||
1201 scenario == "V2V-Urban" || scenario == "V2V-Highway" ||
1202 scenario == "NTN-DenseUrban" || scenario == "NTN-Urban" ||
1203 scenario == "NTN-Suburban" || scenario == "NTN-Rural",
1204 "Unknown scenario, choose between: RMa, UMa, UMi-StreetCanyon, "
1205 "InH-OfficeOpen, InH-OfficeMixed, V2V-Urban, V2V-Highway, "
1206 "NTN-DenseUrban, NTN-Urban, NTN-Suburban or NTN-Rural");
1207 m_scenario = scenario;
1208}
1209
1210std::string
1211ThreeGppChannelModel::GetScenario() const
1212{
1213 NS_LOG_FUNCTION(this);
1214 return m_scenario;
1215}
1216
1217Ptr<const ThreeGppChannelModel::ParamsTable>
1218ThreeGppChannelModel::GetThreeGppTable(const Ptr<const MobilityModel> aMob,
1219 const Ptr<const MobilityModel> bMob,
1220 Ptr<const ChannelCondition> channelCondition) const
1221{
1222 NS_LOG_FUNCTION(this);
1223
1224 // NOTE we assume hUT = min (height(a), height(b)) and
1225 // hBS = max (height (a), height (b))
1226 double hUT = std::min(aMob->GetPosition().z, bMob->GetPosition().z);
1227 double hBS = std::max(aMob->GetPosition().z, bMob->GetPosition().z);
1228
1229 double distance2D = sqrt(pow(aMob->GetPosition().x - bMob->GetPosition().x, 2) +
1230 pow(aMob->GetPosition().y - bMob->GetPosition().y, 2));
1231
1232 double fcGHz = m_frequency / 1.0e9;
1233 Ptr<ParamsTable> table3gpp = Create<ParamsTable>();
1234 // table3gpp includes the following parameters:
1235 // numOfCluster, raysPerCluster, uLgDS, sigLgDS, uLgASD, sigLgASD,
1236 // uLgASA, sigLgASA, uLgZSA, sigLgZSA, uLgZSD, sigLgZSD, offsetZOD,
1237 // cDS, cASD, cASA, cZSA, uK, sigK, rTau, uXpr, sigXpr, shadowingStd
1238
1239 bool los = channelCondition->IsLos();
1240 bool o2i = channelCondition->IsO2i();
1241
1242 // In NLOS case, parameter uK and sigK are not used and they are set to 0
1243 if (m_scenario == "RMa")
1244 {
1245 if (los && !o2i)
1246 {
1247 // 3GPP mentioned that 3.91 ns should be used when the Cluster DS (cDS)
1248 // entry is N/A.
1249 table3gpp->m_numOfCluster = 11;
1250 table3gpp->m_raysPerCluster = 20;
1251 table3gpp->m_uLgDS = -7.49;
1252 table3gpp->m_sigLgDS = 0.55;
1253 table3gpp->m_uLgASD = 0.90;
1254 table3gpp->m_sigLgASD = 0.38;
1255 table3gpp->m_uLgASA = 1.52;
1256 table3gpp->m_sigLgASA = 0.24;
1257 table3gpp->m_uLgZSA = 0.47;
1258 table3gpp->m_sigLgZSA = 0.40;
1259 table3gpp->m_uLgZSD = 0.34;
1260 table3gpp->m_sigLgZSD =
1261 std::max(-1.0, -0.17 * (distance2D / 1000.0) - 0.01 * (hUT - 1.5) + 0.22);
1262 table3gpp->m_offsetZOD = 0;
1263 table3gpp->m_cDS = 3.91e-9;
1264 table3gpp->m_cASD = 2;
1265 table3gpp->m_cASA = 3;
1266 table3gpp->m_cZSA = 3;
1267 table3gpp->m_uK = 7;
1268 table3gpp->m_sigK = 4;
1269 table3gpp->m_rTau = 3.8;
1270 table3gpp->m_uXpr = 12;
1271 table3gpp->m_sigXpr = 4;
1272 table3gpp->m_perClusterShadowingStd = 3;
1273
1274 for (uint8_t row = 0; row < 7; row++)
1275 {
1276 for (uint8_t column = 0; column < 7; column++)
1277 {
1278 table3gpp->m_sqrtC[row][column] = sqrtC_RMa_LOS[row][column];
1279 }
1280 }
1281 }
1282 else if (!los && !o2i)
1283 {
1284 table3gpp->m_numOfCluster = 10;
1285 table3gpp->m_raysPerCluster = 20;
1286 table3gpp->m_uLgDS = -7.43;
1287 table3gpp->m_sigLgDS = 0.48;
1288 table3gpp->m_uLgASD = 0.95;
1289 table3gpp->m_sigLgASD = 0.45;
1290 table3gpp->m_uLgASA = 1.52;
1291 table3gpp->m_sigLgASA = 0.13;
1292 table3gpp->m_uLgZSA = 0.58;
1293 table3gpp->m_sigLgZSA = 0.37;
1294 table3gpp->m_uLgZSD =
1295 std::max(-1.0, -0.19 * (distance2D / 1000.0) - 0.01 * (hUT - 1.5) + 0.28);
1296 table3gpp->m_sigLgZSD = 0.30;
1297 table3gpp->m_offsetZOD = atan((35 - 3.5) / distance2D) - atan((35 - 1.5) / distance2D);
1298 table3gpp->m_cDS = 3.91e-9;
1299 table3gpp->m_cASD = 2;
1300 table3gpp->m_cASA = 3;
1301 table3gpp->m_cZSA = 3;
1302 table3gpp->m_uK = 0;
1303 table3gpp->m_sigK = 0;
1304 table3gpp->m_rTau = 1.7;
1305 table3gpp->m_uXpr = 7;
1306 table3gpp->m_sigXpr = 3;
1307 table3gpp->m_perClusterShadowingStd = 3;
1308
1309 for (uint8_t row = 0; row < 6; row++)
1310 {
1311 for (uint8_t column = 0; column < 6; column++)
1312 {
1313 table3gpp->m_sqrtC[row][column] = sqrtC_RMa_NLOS[row][column];
1314 }
1315 }
1316 }
1317 else // o2i
1318 {
1319 table3gpp->m_numOfCluster = 10;
1320 table3gpp->m_raysPerCluster = 20;
1321 table3gpp->m_uLgDS = -7.47;
1322 table3gpp->m_sigLgDS = 0.24;
1323 table3gpp->m_uLgASD = 0.67;
1324 table3gpp->m_sigLgASD = 0.18;
1325 table3gpp->m_uLgASA = 1.66;
1326 table3gpp->m_sigLgASA = 0.21;
1327 table3gpp->m_uLgZSA = 0.93;
1328 table3gpp->m_sigLgZSA = 0.22;
1329 table3gpp->m_uLgZSD =
1330 std::max(-1.0, -0.19 * (distance2D / 1000.0) - 0.01 * (hUT - 1.5) + 0.28);
1331 table3gpp->m_sigLgZSD = 0.30;
1332 table3gpp->m_offsetZOD = atan((35 - 3.5) / distance2D) - atan((35 - 1.5) / distance2D);
1333 table3gpp->m_cDS = 3.91e-9;
1334 table3gpp->m_cASD = 2;
1335 table3gpp->m_cASA = 3;
1336 table3gpp->m_cZSA = 3;
1337 table3gpp->m_uK = 0;
1338 table3gpp->m_sigK = 0;
1339 table3gpp->m_rTau = 1.7;
1340 table3gpp->m_uXpr = 7;
1341 table3gpp->m_sigXpr = 3;
1342 table3gpp->m_perClusterShadowingStd = 3;
1343
1344 for (uint8_t row = 0; row < 6; row++)
1345 {
1346 for (uint8_t column = 0; column < 6; column++)
1347 {
1348 table3gpp->m_sqrtC[row][column] = sqrtC_RMa_O2I[row][column];
1349 }
1350 }
1351 }
1352 }
1353 else if (m_scenario == "UMa")
1354 {
1355 if (los && !o2i)
1356 {
1357 table3gpp->m_numOfCluster = 12;
1358 table3gpp->m_raysPerCluster = 20;
1359 table3gpp->m_uLgDS = -6.955 - 0.0963 * log10(fcGHz);
1360 table3gpp->m_sigLgDS = 0.66;
1361 table3gpp->m_uLgASD = 1.06 + 0.1114 * log10(fcGHz);
1362 table3gpp->m_sigLgASD = 0.28;
1363 table3gpp->m_uLgASA = 1.81;
1364 table3gpp->m_sigLgASA = 0.20;
1365 table3gpp->m_uLgZSA = 0.95;
1366 table3gpp->m_sigLgZSA = 0.16;
1367 table3gpp->m_uLgZSD =
1368 std::max(-0.5, -2.1 * distance2D / 1000.0 - 0.01 * (hUT - 1.5) + 0.75);
1369 table3gpp->m_sigLgZSD = 0.40;
1370 table3gpp->m_offsetZOD = 0;
1371 table3gpp->m_cDS = std::max(0.25, -3.4084 * log10(fcGHz) + 6.5622) * 1e-9;
1372 table3gpp->m_cASD = 5;
1373 table3gpp->m_cASA = 11;
1374 table3gpp->m_cZSA = 7;
1375 table3gpp->m_uK = 9;
1376 table3gpp->m_sigK = 3.5;
1377 table3gpp->m_rTau = 2.5;
1378 table3gpp->m_uXpr = 8;
1379 table3gpp->m_sigXpr = 4;
1380 table3gpp->m_perClusterShadowingStd = 3;
1381
1382 for (uint8_t row = 0; row < 7; row++)
1383 {
1384 for (uint8_t column = 0; column < 7; column++)
1385 {
1386 table3gpp->m_sqrtC[row][column] = sqrtC_UMa_LOS[row][column];
1387 }
1388 }
1389 }
1390 else
1391 {
1392 double uLgZSD = std::max(-0.5, -2.1 * distance2D / 1000.0 - 0.01 * (hUT - 1.5) + 0.9);
1393
1394 double afc = 0.208 * log10(fcGHz) - 0.782;
1395 double bfc = 25;
1396 double cfc = -0.13 * log10(fcGHz) + 2.03;
1397 double efc = 7.66 * log10(fcGHz) - 5.96;
1398
1399 double offsetZOD = efc - std::pow(10, afc * log10(std::max(bfc, distance2D)) + cfc);
1400
1401 if (!los && !o2i)
1402 {
1403 table3gpp->m_numOfCluster = 20;
1404 table3gpp->m_raysPerCluster = 20;
1405 table3gpp->m_uLgDS = -6.28 - 0.204 * log10(fcGHz);
1406 table3gpp->m_sigLgDS = 0.39;
1407 table3gpp->m_uLgASD = 1.5 - 0.1144 * log10(fcGHz);
1408 table3gpp->m_sigLgASD = 0.28;
1409 table3gpp->m_uLgASA = 2.08 - 0.27 * log10(fcGHz);
1410 table3gpp->m_sigLgASA = 0.11;
1411 table3gpp->m_uLgZSA = -0.3236 * log10(fcGHz) + 1.512;
1412 table3gpp->m_sigLgZSA = 0.16;
1413 table3gpp->m_uLgZSD = uLgZSD;
1414 table3gpp->m_sigLgZSD = 0.49;
1415 table3gpp->m_offsetZOD = offsetZOD;
1416 table3gpp->m_cDS = std::max(0.25, -3.4084 * log10(fcGHz) + 6.5622) * 1e-9;
1417 table3gpp->m_cASD = 2;
1418 table3gpp->m_cASA = 15;
1419 table3gpp->m_cZSA = 7;
1420 table3gpp->m_uK = 0;
1421 table3gpp->m_sigK = 0;
1422 table3gpp->m_rTau = 2.3;
1423 table3gpp->m_uXpr = 7;
1424 table3gpp->m_sigXpr = 3;
1425 table3gpp->m_perClusterShadowingStd = 3;
1426
1427 for (uint8_t row = 0; row < 6; row++)
1428 {
1429 for (uint8_t column = 0; column < 6; column++)
1430 {
1431 table3gpp->m_sqrtC[row][column] = sqrtC_UMa_NLOS[row][column];
1432 }
1433 }
1434 }
1435 else //(o2i)
1436 {
1437 table3gpp->m_numOfCluster = 12;
1438 table3gpp->m_raysPerCluster = 20;
1439 table3gpp->m_uLgDS = -6.62;
1440 table3gpp->m_sigLgDS = 0.32;
1441 table3gpp->m_uLgASD = 1.25;
1442 table3gpp->m_sigLgASD = 0.42;
1443 table3gpp->m_uLgASA = 1.76;
1444 table3gpp->m_sigLgASA = 0.16;
1445 table3gpp->m_uLgZSA = 1.01;
1446 table3gpp->m_sigLgZSA = 0.43;
1447 table3gpp->m_uLgZSD = uLgZSD;
1448 table3gpp->m_sigLgZSD = 0.49;
1449 table3gpp->m_offsetZOD = offsetZOD;
1450 table3gpp->m_cDS = 11e-9;
1451 table3gpp->m_cASD = 5;
1452 table3gpp->m_cASA = 8;
1453 table3gpp->m_cZSA = 3;
1454 table3gpp->m_uK = 0;
1455 table3gpp->m_sigK = 0;
1456 table3gpp->m_rTau = 2.2;
1457 table3gpp->m_uXpr = 9;
1458 table3gpp->m_sigXpr = 5;
1459 table3gpp->m_perClusterShadowingStd = 4;
1460
1461 for (uint8_t row = 0; row < 6; row++)
1462 {
1463 for (uint8_t column = 0; column < 6; column++)
1464 {
1465 table3gpp->m_sqrtC[row][column] = sqrtC_UMa_O2I[row][column];
1466 }
1467 }
1468 }
1469 }
1470 }
1471 else if (m_scenario == "UMi-StreetCanyon")
1472 {
1473 if (los && !o2i)
1474 {
1475 table3gpp->m_numOfCluster = 12;
1476 table3gpp->m_raysPerCluster = 20;
1477 table3gpp->m_uLgDS = -0.24 * log10(1 + fcGHz) - 7.14;
1478 table3gpp->m_sigLgDS = 0.38;
1479 table3gpp->m_uLgASD = -0.05 * log10(1 + fcGHz) + 1.21;
1480 table3gpp->m_sigLgASD = 0.41;
1481 table3gpp->m_uLgASA = -0.08 * log10(1 + fcGHz) + 1.73;
1482 table3gpp->m_sigLgASA = 0.014 * log10(1 + fcGHz) + 0.28;
1483 table3gpp->m_uLgZSA = -0.1 * log10(1 + fcGHz) + 0.73;
1484 table3gpp->m_sigLgZSA = -0.04 * log10(1 + fcGHz) + 0.34;
1485 table3gpp->m_uLgZSD =
1486 std::max(-0.21, -14.8 * distance2D / 1000.0 + 0.01 * std::abs(hUT - hBS) + 0.83);
1487 table3gpp->m_sigLgZSD = 0.35;
1488 table3gpp->m_offsetZOD = 0;
1489 table3gpp->m_cDS = 5e-9;
1490 table3gpp->m_cASD = 3;
1491 table3gpp->m_cASA = 17;
1492 table3gpp->m_cZSA = 7;
1493 table3gpp->m_uK = 9;
1494 table3gpp->m_sigK = 5;
1495 table3gpp->m_rTau = 3;
1496 table3gpp->m_uXpr = 9;
1497 table3gpp->m_sigXpr = 3;
1498 table3gpp->m_perClusterShadowingStd = 3;
1499
1500 for (uint8_t row = 0; row < 7; row++)
1501 {
1502 for (uint8_t column = 0; column < 7; column++)
1503 {
1504 table3gpp->m_sqrtC[row][column] = sqrtC_UMi_LOS[row][column];
1505 }
1506 }
1507 }
1508 else
1509 {
1510 double uLgZSD =
1511 std::max(-0.5, -3.1 * distance2D / 1000.0 + 0.01 * std::max(hUT - hBS, 0.0) + 0.2);
1512 double offsetZOD = -1 * std::pow(10, -1.5 * log10(std::max(10.0, distance2D)) + 3.3);
1513 if (!los && !o2i)
1514 {
1515 table3gpp->m_numOfCluster = 19;
1516 table3gpp->m_raysPerCluster = 20;
1517 table3gpp->m_uLgDS = -0.24 * log10(1 + fcGHz) - 6.83;
1518 table3gpp->m_sigLgDS = 0.16 * log10(1 + fcGHz) + 0.28;
1519 table3gpp->m_uLgASD = -0.23 * log10(1 + fcGHz) + 1.53;
1520 table3gpp->m_sigLgASD = 0.11 * log10(1 + fcGHz) + 0.33;
1521 table3gpp->m_uLgASA = -0.08 * log10(1 + fcGHz) + 1.81;
1522 table3gpp->m_sigLgASA = 0.05 * log10(1 + fcGHz) + 0.3;
1523 table3gpp->m_uLgZSA = -0.04 * log10(1 + fcGHz) + 0.92;
1524 table3gpp->m_sigLgZSA = -0.07 * log10(1 + fcGHz) + 0.41;
1525 table3gpp->m_uLgZSD = uLgZSD;
1526 table3gpp->m_sigLgZSD = 0.35;
1527 table3gpp->m_offsetZOD = offsetZOD;
1528 table3gpp->m_cDS = 11e-9;
1529 table3gpp->m_cASD = 10;
1530 table3gpp->m_cASA = 22;
1531 table3gpp->m_cZSA = 7;
1532 table3gpp->m_uK = 0;
1533 table3gpp->m_sigK = 0;
1534 table3gpp->m_rTau = 2.1;
1535 table3gpp->m_uXpr = 8;
1536 table3gpp->m_sigXpr = 3;
1537 table3gpp->m_perClusterShadowingStd = 3;
1538
1539 for (uint8_t row = 0; row < 6; row++)
1540 {
1541 for (uint8_t column = 0; column < 6; column++)
1542 {
1543 table3gpp->m_sqrtC[row][column] = sqrtC_UMi_NLOS[row][column];
1544 }
1545 }
1546 }
1547 else //(o2i)
1548 {
1549 table3gpp->m_numOfCluster = 12;
1550 table3gpp->m_raysPerCluster = 20;
1551 table3gpp->m_uLgDS = -6.62;
1552 table3gpp->m_sigLgDS = 0.32;
1553 table3gpp->m_uLgASD = 1.25;
1554 table3gpp->m_sigLgASD = 0.42;
1555 table3gpp->m_uLgASA = 1.76;
1556 table3gpp->m_sigLgASA = 0.16;
1557 table3gpp->m_uLgZSA = 1.01;
1558 table3gpp->m_sigLgZSA = 0.43;
1559 table3gpp->m_uLgZSD = uLgZSD;
1560 table3gpp->m_sigLgZSD = 0.35;
1561 table3gpp->m_offsetZOD = offsetZOD;
1562 table3gpp->m_cDS = 11e-9;
1563 table3gpp->m_cASD = 5;
1564 table3gpp->m_cASA = 8;
1565 table3gpp->m_cZSA = 3;
1566 table3gpp->m_uK = 0;
1567 table3gpp->m_sigK = 0;
1568 table3gpp->m_rTau = 2.2;
1569 table3gpp->m_uXpr = 9;
1570 table3gpp->m_sigXpr = 5;
1571 table3gpp->m_perClusterShadowingStd = 4;
1572
1573 for (uint8_t row = 0; row < 6; row++)
1574 {
1575 for (uint8_t column = 0; column < 6; column++)
1576 {
1577 table3gpp->m_sqrtC[row][column] = sqrtC_UMi_O2I[row][column];
1578 }
1579 }
1580 }
1581 }
1582 }
1583 else if (m_scenario == "InH-OfficeMixed" || m_scenario == "InH-OfficeOpen")
1584 {
1585 NS_ASSERT_MSG(!o2i, "The indoor scenario does out support outdoor to indoor");
1586 if (los)
1587 {
1588 table3gpp->m_numOfCluster = 15;
1589 table3gpp->m_raysPerCluster = 20;
1590 table3gpp->m_uLgDS = -0.01 * log10(1 + fcGHz) - 7.692;
1591 table3gpp->m_sigLgDS = 0.18;
1592 table3gpp->m_uLgASD = 1.60;
1593 table3gpp->m_sigLgASD = 0.18;
1594 table3gpp->m_uLgASA = -0.19 * log10(1 + fcGHz) + 1.781;
1595 table3gpp->m_sigLgASA = 0.12 * log10(1 + fcGHz) + 0.119;
1596 table3gpp->m_uLgZSA = -0.26 * log10(1 + fcGHz) + 1.44;
1597 table3gpp->m_sigLgZSA = -0.04 * log10(1 + fcGHz) + 0.264;
1598 table3gpp->m_uLgZSD = -1.43 * log10(1 + fcGHz) + 2.228;
1599 table3gpp->m_sigLgZSD = 0.13 * log10(1 + fcGHz) + 0.30;
1600 table3gpp->m_offsetZOD = 0;
1601 table3gpp->m_cDS = 3.91e-9;
1602 table3gpp->m_cASD = 5;
1603 table3gpp->m_cASA = 8;
1604 table3gpp->m_cZSA = 9;
1605 table3gpp->m_uK = 7;
1606 table3gpp->m_sigK = 4;
1607 table3gpp->m_rTau = 3.6;
1608 table3gpp->m_uXpr = 11;
1609 table3gpp->m_sigXpr = 4;
1610 table3gpp->m_perClusterShadowingStd = 6;
1611
1612 for (uint8_t row = 0; row < 7; row++)
1613 {
1614 for (uint8_t column = 0; column < 7; column++)
1615 {
1616 table3gpp->m_sqrtC[row][column] = sqrtC_office_LOS[row][column];
1617 }
1618 }
1619 }
1620 else
1621 {
1622 table3gpp->m_numOfCluster = 19;
1623 table3gpp->m_raysPerCluster = 20;
1624 table3gpp->m_uLgDS = -0.28 * log10(1 + fcGHz) - 7.173;
1625 table3gpp->m_sigLgDS = 0.1 * log10(1 + fcGHz) + 0.055;
1626 table3gpp->m_uLgASD = 1.62;
1627 table3gpp->m_sigLgASD = 0.25;
1628 table3gpp->m_uLgASA = -0.11 * log10(1 + fcGHz) + 1.863;
1629 table3gpp->m_sigLgASA = 0.12 * log10(1 + fcGHz) + 0.059;
1630 table3gpp->m_uLgZSA = -0.15 * log10(1 + fcGHz) + 1.387;
1631 table3gpp->m_sigLgZSA = -0.09 * log10(1 + fcGHz) + 0.746;
1632 table3gpp->m_uLgZSD = 1.08;
1633 table3gpp->m_sigLgZSD = 0.36;
1634 table3gpp->m_offsetZOD = 0;
1635 table3gpp->m_cDS = 3.91e-9;
1636 table3gpp->m_cASD = 5;
1637 table3gpp->m_cASA = 11;
1638 table3gpp->m_cZSA = 9;
1639 table3gpp->m_uK = 0;
1640 table3gpp->m_sigK = 0;
1641 table3gpp->m_rTau = 3;
1642 table3gpp->m_uXpr = 10;
1643 table3gpp->m_sigXpr = 4;
1644 table3gpp->m_perClusterShadowingStd = 3;
1645
1646 for (uint8_t row = 0; row < 6; row++)
1647 {
1648 for (uint8_t column = 0; column < 6; column++)
1649 {
1650 table3gpp->m_sqrtC[row][column] = sqrtC_office_NLOS[row][column];
1651 }
1652 }
1653 }
1654 }
1655 else if (m_scenario == "V2V-Urban")
1656 {
1657 if (channelCondition->IsLos())
1658 {
1659 // 3GPP mentioned that 3.91 ns should be used when the Cluster DS (cDS)
1660 // entry is N/A.
1661 table3gpp->m_numOfCluster = 12;
1662 table3gpp->m_raysPerCluster = 20;
1663 table3gpp->m_uLgDS = -0.2 * log10(1 + fcGHz) - 7.5;
1664 table3gpp->m_sigLgDS = 0.1;
1665 table3gpp->m_uLgASD = -0.1 * log10(1 + fcGHz) + 1.6;
1666 table3gpp->m_sigLgASD = 0.1;
1667 table3gpp->m_uLgASA = -0.1 * log10(1 + fcGHz) + 1.6;
1668 table3gpp->m_sigLgASA = 0.1;
1669 table3gpp->m_uLgZSA = -0.1 * log10(1 + fcGHz) + 0.73;
1670 table3gpp->m_sigLgZSA = -0.04 * log10(1 + fcGHz) + 0.34;
1671 table3gpp->m_uLgZSD = -0.1 * log10(1 + fcGHz) + 0.73;
1672 table3gpp->m_sigLgZSD = -0.04 * log10(1 + fcGHz) + 0.34;
1673 table3gpp->m_offsetZOD = 0;
1674 table3gpp->m_cDS = 5 * 1e-9;
1675 table3gpp->m_cASD = 17;
1676 table3gpp->m_cASA = 17;
1677 table3gpp->m_cZSA = 7;
1678 table3gpp->m_uK = 3.48;
1679 table3gpp->m_sigK = 2;
1680 table3gpp->m_rTau = 3;
1681 table3gpp->m_uXpr = 9;
1682 table3gpp->m_sigXpr = 3;
1683 table3gpp->m_perClusterShadowingStd = 4;
1684
1685 for (uint8_t row = 0; row < 7; row++)
1686 {
1687 for (uint8_t column = 0; column < 7; column++)
1688 {
1689 table3gpp->m_sqrtC[row][column] = sqrtC_UMi_LOS[row][column];
1690 }
1691 }
1692 }
1693 else if (channelCondition->IsNlos())
1694 {
1695 table3gpp->m_numOfCluster = 19;
1696 table3gpp->m_raysPerCluster = 20;
1697 table3gpp->m_uLgDS = -0.3 * log10(1 + fcGHz) - 7;
1698 table3gpp->m_sigLgDS = 0.28;
1699 table3gpp->m_uLgASD = -0.08 * log10(1 + fcGHz) + 1.81;
1700 table3gpp->m_sigLgASD = 0.05 * log10(1 + fcGHz) + 0.3;
1701 table3gpp->m_uLgASA = -0.08 * log10(1 + fcGHz) + 1.81;
1702 table3gpp->m_sigLgASA = 0.05 * log10(1 + fcGHz) + 0.3;
1703 table3gpp->m_uLgZSA = -0.04 * log10(1 + fcGHz) + 0.92;
1704 table3gpp->m_sigLgZSA = -0.07 * log10(1 + fcGHz) + 0.41;
1705 table3gpp->m_uLgZSD = -0.04 * log10(1 + fcGHz) + 0.92;
1706 table3gpp->m_sigLgZSD = -0.07 * log10(1 + fcGHz) + 0.41;
1707 table3gpp->m_offsetZOD = 0;
1708 table3gpp->m_cDS = 11 * 1e-9;
1709 table3gpp->m_cASD = 22;
1710 table3gpp->m_cASA = 22;
1711 table3gpp->m_cZSA = 7;
1712 table3gpp->m_uK = 0; // N/A
1713 table3gpp->m_sigK = 0; // N/A
1714 table3gpp->m_rTau = 2.1;
1715 table3gpp->m_uXpr = 8;
1716 table3gpp->m_sigXpr = 3;
1717 table3gpp->m_perClusterShadowingStd = 4;
1718
1719 for (uint8_t row = 0; row < 6; row++)
1720 {
1721 for (uint8_t column = 0; column < 6; column++)
1722 {
1723 table3gpp->m_sqrtC[row][column] = sqrtC_UMi_NLOS[row][column];
1724 }
1725 }
1726 }
1727 else if (channelCondition->IsNlosv())
1728 {
1729 table3gpp->m_numOfCluster = 19;
1730 table3gpp->m_raysPerCluster = 20;
1731 table3gpp->m_uLgDS = -0.4 * log10(1 + fcGHz) - 7;
1732 table3gpp->m_sigLgDS = 0.1;
1733 table3gpp->m_uLgASD = -0.1 * log10(1 + fcGHz) + 1.7;
1734 table3gpp->m_sigLgASD = 0.1;
1735 table3gpp->m_uLgASA = -0.1 * log10(1 + fcGHz) + 1.7;
1736 table3gpp->m_sigLgASA = 0.1;
1737 table3gpp->m_uLgZSA = -0.04 * log10(1 + fcGHz) + 0.92;
1738 table3gpp->m_sigLgZSA = -0.07 * log10(1 + fcGHz) + 0.41;
1739 table3gpp->m_uLgZSD = -0.04 * log10(1 + fcGHz) + 0.92;
1740 table3gpp->m_sigLgZSD = -0.07 * log10(1 + fcGHz) + 0.41;
1741 table3gpp->m_offsetZOD = 0;
1742 table3gpp->m_cDS = 11 * 1e-9;
1743 table3gpp->m_cASD = 22;
1744 table3gpp->m_cASA = 22;
1745 table3gpp->m_cZSA = 7;
1746 table3gpp->m_uK = 0;
1747 table3gpp->m_sigK = 4.5;
1748 table3gpp->m_rTau = 2.1;
1749 table3gpp->m_uXpr = 8;
1750 table3gpp->m_sigXpr = 3;
1751 table3gpp->m_perClusterShadowingStd = 4;
1752
1753 for (uint8_t row = 0; row < 6; row++)
1754 {
1755 for (uint8_t column = 0; column < 6; column++)
1756 {
1757 table3gpp->m_sqrtC[row][column] = sqrtC_UMi_LOS[row][column];
1758 }
1759 }
1760 }
1761 else
1762 {
1763 NS_FATAL_ERROR("Unknown channel condition");
1764 }
1765 }
1766 else if (m_scenario == "V2V-Highway")
1767 {
1768 if (channelCondition->IsLos())
1769 {
1770 table3gpp->m_numOfCluster = 12;
1771 table3gpp->m_raysPerCluster = 20;
1772 table3gpp->m_uLgDS = -8.3;
1773 table3gpp->m_sigLgDS = 0.2;
1774 table3gpp->m_uLgASD = 1.4;
1775 table3gpp->m_sigLgASD = 0.1;
1776 table3gpp->m_uLgASA = 1.4;
1777 table3gpp->m_sigLgASA = 0.1;
1778 table3gpp->m_uLgZSA = -0.1 * log10(1 + fcGHz) + 0.73;
1779 table3gpp->m_sigLgZSA = -0.04 * log10(1 + fcGHz) + 0.34;
1780 table3gpp->m_uLgZSD = -0.1 * log10(1 + fcGHz) + 0.73;
1781 table3gpp->m_sigLgZSD = -0.04 * log10(1 + fcGHz) + 0.34;
1782 table3gpp->m_offsetZOD = 0;
1783 table3gpp->m_cDS = 5 * 1e-9;
1784 table3gpp->m_cASD = 17;
1785 table3gpp->m_cASA = 17;
1786 table3gpp->m_cZSA = 7;
1787 table3gpp->m_uK = 9;
1788 table3gpp->m_sigK = 3.5;
1789 table3gpp->m_rTau = 3;
1790 table3gpp->m_uXpr = 9;
1791 table3gpp->m_sigXpr = 3;
1792 table3gpp->m_perClusterShadowingStd = 4;
1793
1794 for (uint8_t row = 0; row < 7; row++)
1795 {
1796 for (uint8_t column = 0; column < 7; column++)
1797 {
1798 table3gpp->m_sqrtC[row][column] = sqrtC_UMi_LOS[row][column];
1799 }
1800 }
1801 }
1802 else if (channelCondition->IsNlosv())
1803 {
1804 table3gpp->m_numOfCluster = 19;
1805 table3gpp->m_raysPerCluster = 20;
1806 table3gpp->m_uLgDS = -8.3;
1807 table3gpp->m_sigLgDS = 0.3;
1808 table3gpp->m_uLgASD = 1.5;
1809 table3gpp->m_sigLgASD = 0.1;
1810 table3gpp->m_uLgASA = 1.5;
1811 table3gpp->m_sigLgASA = 0.1;
1812 table3gpp->m_uLgZSA = -0.04 * log10(1 + fcGHz) + 0.92;
1813 table3gpp->m_sigLgZSA = -0.07 * log10(1 + fcGHz) + 0.41;
1814 table3gpp->m_uLgZSD = -0.04 * log10(1 + fcGHz) + 0.92;
1815 table3gpp->m_sigLgZSD = -0.07 * log10(1 + fcGHz) + 0.41;
1816 table3gpp->m_offsetZOD = 0;
1817 table3gpp->m_cDS = 11 * 1e-9;
1818 table3gpp->m_cASD = 22;
1819 table3gpp->m_cASA = 22;
1820 table3gpp->m_cZSA = 7;
1821 table3gpp->m_uK = 0;
1822 table3gpp->m_sigK = 4.5;
1823 table3gpp->m_rTau = 2.1;
1824 table3gpp->m_uXpr = 8.0;
1825 table3gpp->m_sigXpr = 3;
1826 table3gpp->m_perClusterShadowingStd = 4;
1827
1828 for (uint8_t row = 0; row < 6; row++)
1829 {
1830 for (uint8_t column = 0; column < 6; column++)
1831 {
1832 table3gpp->m_sqrtC[row][column] = sqrtC_UMi_LOS[row][column];
1833 }
1834 }
1835 }
1836 else if (channelCondition->IsNlos())
1837 {
1838 NS_LOG_WARN(
1839 "The fast fading parameters for the NLOS condition in the Highway scenario are not "
1840 "defined in TR 37.885, use the ones defined in TDoc R1-1803671 instead");
1841
1842 table3gpp->m_numOfCluster = 19;
1843 table3gpp->m_raysPerCluster = 20;
1844 table3gpp->m_uLgDS = -0.3 * log10(1 + fcGHz) - 7;
1845 table3gpp->m_sigLgDS = 0.28;
1846 table3gpp->m_uLgASD = -0.08 * log10(1 + fcGHz) + 1.81;
1847 table3gpp->m_sigLgASD = 0.05 * log10(1 + fcGHz) + 0.3;
1848 table3gpp->m_uLgASA = -0.08 * log10(1 + fcGHz) + 1.81;
1849 table3gpp->m_sigLgASA = 0.05 * log10(1 + fcGHz) + 0.3;
1850 table3gpp->m_uLgZSA = -0.04 * log10(1 + fcGHz) + 0.92;
1851 table3gpp->m_sigLgZSA = -0.07 * log10(1 + fcGHz) + 0.41;
1852 table3gpp->m_uLgZSD = -0.04 * log10(1 + fcGHz) + 0.92;
1853 table3gpp->m_sigLgZSD = -0.07 * log10(1 + fcGHz) + 0.41;
1854 table3gpp->m_offsetZOD = 0;
1855 table3gpp->m_cDS = 11 * 1e-9;
1856 table3gpp->m_cASD = 22;
1857 table3gpp->m_cASA = 22;
1858 table3gpp->m_cZSA = 7;
1859 table3gpp->m_uK = 0; // N/A
1860 table3gpp->m_sigK = 0; // N/A
1861 table3gpp->m_rTau = 2.1;
1862 table3gpp->m_uXpr = 8;
1863 table3gpp->m_sigXpr = 3;
1864 table3gpp->m_perClusterShadowingStd = 4;
1865
1866 for (uint8_t row = 0; row < 6; row++)
1867 {
1868 for (uint8_t column = 0; column < 6; column++)
1869 {
1870 table3gpp->m_sqrtC[row][column] = sqrtC_UMi_NLOS[row][column];
1871 }
1872 }
1873 }
1874 else
1875 {
1876 NS_FATAL_ERROR("Unknown channel condition");
1877 }
1878 }
1879 else if (m_scenario.substr(0, 3) == "NTN")
1880 {
1881 std::string freqBand = (fcGHz < 13) ? "S" : "Ka";
1882
1883 double elevAngle = 0;
1884 bool isSatellite = false; // flag to indicate if one of the two nodes is a satellite
1885 // if so, parameters will be set accordingly to NOTE 8 of
1886 // Table 6.7.2 from 3GPP 38.811 V15.4.0 (2020-09)
1887
1888 Ptr<MobilityModel> aMobNonConst = ConstCast<MobilityModel>(aMob);
1889 Ptr<MobilityModel> bMobNonConst = ConstCast<MobilityModel>(bMob);
1890
1891 if (DynamicCast<GeocentricConstantPositionMobilityModel>(
1892 ConstCast<MobilityModel>(aMob)) && // Transform to NS_ASSERT
1893 DynamicCast<GeocentricConstantPositionMobilityModel>(
1894 ConstCast<MobilityModel>(bMob))) // check if aMob and bMob are of type
1895 // GeocentricConstantPositionMobilityModel
1896 {
1897 Ptr<GeocentricConstantPositionMobilityModel> aNTNMob =
1898 DynamicCast<GeocentricConstantPositionMobilityModel>(aMobNonConst);
1899 Ptr<GeocentricConstantPositionMobilityModel> bNTNMob =
1900 DynamicCast<GeocentricConstantPositionMobilityModel>(bMobNonConst);
1901
1902 if (aNTNMob->GetGeographicPosition().z <
1903 bNTNMob->GetGeographicPosition().z) // b is the HAPS/Satellite
1904 {
1905 elevAngle = aNTNMob->GetElevationAngle(bNTNMob);
1906 if (bNTNMob->GetGeographicPosition().z > 50000)
1907 {
1908 isSatellite = true;
1909 }
1910 }
1911 else // a is the HAPS/Satellite
1912 {
1913 elevAngle = bNTNMob->GetElevationAngle(aNTNMob);
1914 if (aNTNMob->GetGeographicPosition().z > 50000)
1915 {
1916 isSatellite = true;
1917 }
1918 }
1919 }
1920 else
1921 {
1922 NS_FATAL_ERROR("Mobility Models needs to be of type Geocentric for NTN scenarios");
1923 }
1924
1925 // Round the elevation angle into a two-digits integer between 10 and 90.
1926 int elevAngleQuantized = (elevAngle < 10) ? 10 : round(elevAngle / 10) * 10;
1927
1928 if (m_scenario == "NTN-DenseUrban")
1929 {
1930 if (channelCondition->IsLos())
1931 {
1932 table3gpp->m_uLgDS =
1933 NTNDenseUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgDS];
1934 table3gpp->m_sigLgDS =
1935 NTNDenseUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgDS];
1936
1937 // table3gpp->m_uLgASD=-1.79769e+308; //FOR SATELLITES
1938 table3gpp->m_uLgASD =
1939 NTNDenseUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgASD];
1940 // table3gpp->m_sigLgASD=0; //FOR SATELLITES
1941 table3gpp->m_sigLgASD =
1942 NTNDenseUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgASD];
1943
1944 table3gpp->m_uLgASA =
1945 NTNDenseUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgASA];
1946 table3gpp->m_sigLgASA =
1947 NTNDenseUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgASA];
1948 table3gpp->m_uLgZSA =
1949 NTNDenseUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgZSA];
1950 table3gpp->m_sigLgZSA =
1951 NTNDenseUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgZSA];
1952
1953 // table3gpp->m_uLgZSD=-1.79769e+308; //FOR SATELLITES
1954 table3gpp->m_uLgZSD =
1955 NTNDenseUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgZSD];
1956 // table3gpp->m_sigLgZSD= 0; //FOR SATELLITES
1957 table3gpp->m_sigLgZSD =
1958 NTNDenseUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgZSD];
1959
1960 table3gpp->m_uK =
1961 NTNDenseUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uK];
1962 table3gpp->m_sigK =
1963 NTNDenseUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigK];
1964 table3gpp->m_rTau =
1965 NTNDenseUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::rTau];
1966 table3gpp->m_uXpr =
1967 NTNDenseUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uXpr];
1968 table3gpp->m_sigXpr =
1969 NTNDenseUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigXpr];
1970 table3gpp->m_numOfCluster = NTNDenseUrbanLOS.at(freqBand).at(
1971 elevAngleQuantized)[Table3gppParams::numOfCluster];
1972 table3gpp->m_raysPerCluster = NTNDenseUrbanLOS.at(freqBand).at(
1973 elevAngleQuantized)[Table3gppParams::raysPerCluster];
1974 table3gpp->m_cDS =
1975 NTNDenseUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cDS] *
1976 1e-9;
1977 table3gpp->m_cASD =
1978 NTNDenseUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cASD];
1979 table3gpp->m_cASA =
1980 NTNDenseUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cASA];
1981 table3gpp->m_cZSA =
1982 NTNDenseUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cZSA];
1983 table3gpp->m_perClusterShadowingStd = NTNDenseUrbanLOS.at(freqBand).at(
1984 elevAngleQuantized)[Table3gppParams::perClusterShadowingStd];
1985
1986 for (uint8_t row = 0; row < 7; row++)
1987 {
1988 for (uint8_t column = 0; column < 7; column++)
1989 {
1990 table3gpp->m_sqrtC[row][column] = sqrtC_NTN_DenseUrban_LOS[row][column];
1991 }
1992 }
1993 }
1994 else if (channelCondition->IsNlos())
1995 {
1996 NS_LOG_UNCOND("Dense Urban NLOS");
1997 table3gpp->m_uLgDS =
1998 NTNDenseUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgDS];
1999 table3gpp->m_sigLgDS =
2000 NTNDenseUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgDS];
2001 table3gpp->m_uLgASD =
2002 NTNDenseUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgASD];
2003 table3gpp->m_sigLgASD = NTNDenseUrbanNLOS.at(freqBand).at(
2004 elevAngleQuantized)[Table3gppParams::sigLgASD];
2005 table3gpp->m_uLgASA =
2006 NTNDenseUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgASA];
2007 table3gpp->m_sigLgASA = NTNDenseUrbanNLOS.at(freqBand).at(
2008 elevAngleQuantized)[Table3gppParams::sigLgASA];
2009 table3gpp->m_uLgZSA =
2010 NTNDenseUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgZSA];
2011 table3gpp->m_sigLgZSA = NTNDenseUrbanNLOS.at(freqBand).at(
2012 elevAngleQuantized)[Table3gppParams::sigLgZSA];
2013 table3gpp->m_uLgZSD =
2014 NTNDenseUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgZSD];
2015 table3gpp->m_sigLgZSD = NTNDenseUrbanNLOS.at(freqBand).at(
2016 elevAngleQuantized)[Table3gppParams::sigLgZSD];
2017 table3gpp->m_rTau =
2018 NTNDenseUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::rTau];
2019 table3gpp->m_uXpr =
2020 NTNDenseUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uXpr];
2021 table3gpp->m_sigXpr =
2022 NTNDenseUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigXpr];
2023 table3gpp->m_numOfCluster = NTNDenseUrbanNLOS.at(freqBand).at(
2024 elevAngleQuantized)[Table3gppParams::numOfCluster];
2025 table3gpp->m_raysPerCluster = NTNDenseUrbanNLOS.at(freqBand).at(
2026 elevAngleQuantized)[Table3gppParams::raysPerCluster];
2027 table3gpp->m_cDS =
2028 NTNDenseUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cDS] *
2029 1e-9;
2030 table3gpp->m_cASD =
2031 NTNDenseUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cASD];
2032 table3gpp->m_cASA =
2033 NTNDenseUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cASA];
2034 table3gpp->m_cZSA =
2035 NTNDenseUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cZSA];
2036 table3gpp->m_perClusterShadowingStd = NTNDenseUrbanNLOS.at(freqBand).at(
2037 elevAngleQuantized)[Table3gppParams::perClusterShadowingStd];
2038
2039 for (uint8_t row = 0; row < 6; row++)
2040 {
2041 for (uint8_t column = 0; column < 6; column++)
2042 {
2043 table3gpp->m_sqrtC[row][column] = sqrtC_NTN_DenseUrban_NLOS[row][column];
2044 }
2045 }
2046 }
2047 }
2048 else if (m_scenario == "NTN-Urban")
2049 {
2050 if (channelCondition->IsLos())
2051 {
2052 table3gpp->m_uLgDS =
2053 NTNUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgDS];
2054 table3gpp->m_sigLgDS =
2055 NTNUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgDS];
2056 table3gpp->m_uLgASD =
2057 NTNUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgASD];
2058 table3gpp->m_sigLgASD =
2059 NTNUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgASD];
2060 table3gpp->m_uLgASA =
2061 NTNUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgASA];
2062 table3gpp->m_sigLgASA =
2063 NTNUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgASA];
2064 table3gpp->m_uLgZSA =
2065 NTNUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgZSA];
2066 table3gpp->m_sigLgZSA =
2067 NTNUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgZSA];
2068 table3gpp->m_uLgZSD =
2069 NTNUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgZSD];
2070 table3gpp->m_sigLgZSD =
2071 NTNUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgZSD];
2072 table3gpp->m_uK =
2073 NTNUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uK];
2074 table3gpp->m_sigK =
2075 NTNUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigK];
2076 table3gpp->m_rTau =
2077 NTNUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::rTau];
2078 table3gpp->m_uXpr =
2079 NTNUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uXpr];
2080 table3gpp->m_sigXpr =
2081 NTNUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigXpr];
2082 table3gpp->m_numOfCluster =
2083 NTNUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::numOfCluster];
2084 table3gpp->m_raysPerCluster = NTNUrbanLOS.at(freqBand).at(
2085 elevAngleQuantized)[Table3gppParams::raysPerCluster];
2086 table3gpp->m_cDS =
2087 NTNUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cDS] * 1e-9;
2088 table3gpp->m_cASD =
2089 NTNUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cASD];
2090 table3gpp->m_cASA =
2091 NTNUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cASA];
2092 table3gpp->m_cZSA =
2093 NTNUrbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cZSA];
2094 table3gpp->m_perClusterShadowingStd = NTNUrbanLOS.at(freqBand).at(
2095 elevAngleQuantized)[Table3gppParams::perClusterShadowingStd];
2096
2097 for (uint8_t row = 0; row < 7; row++)
2098 {
2099 for (uint8_t column = 0; column < 7; column++)
2100 {
2101 table3gpp->m_sqrtC[row][column] = sqrtC_NTN_Urban_LOS[row][column];
2102 }
2103 }
2104 }
2105 else if (channelCondition->IsNlos())
2106 {
2107 table3gpp->m_uLgDS =
2108 NTNUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgDS];
2109 table3gpp->m_sigLgDS =
2110 NTNUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgDS];
2111 table3gpp->m_uLgASD =
2112 NTNUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgASD];
2113 table3gpp->m_sigLgASD =
2114 NTNUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgASD];
2115 table3gpp->m_uLgASA =
2116 NTNUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgASA];
2117 table3gpp->m_sigLgASA =
2118 NTNUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgASA];
2119 table3gpp->m_uLgZSA =
2120 NTNUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgZSA];
2121 table3gpp->m_sigLgZSA =
2122 NTNUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgZSA];
2123 table3gpp->m_uLgZSD =
2124 NTNUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgZSD];
2125 table3gpp->m_sigLgZSD =
2126 NTNUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgZSD];
2127 table3gpp->m_uK =
2128 NTNUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uK];
2129 table3gpp->m_sigK =
2130 NTNUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigK];
2131 table3gpp->m_rTau =
2132 NTNUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::rTau];
2133 table3gpp->m_uXpr =
2134 NTNUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uXpr];
2135 table3gpp->m_sigXpr =
2136 NTNUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigXpr];
2137 table3gpp->m_numOfCluster =
2138 NTNUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::numOfCluster];
2139 table3gpp->m_raysPerCluster = NTNUrbanNLOS.at(freqBand).at(
2140 elevAngleQuantized)[Table3gppParams::raysPerCluster];
2141 table3gpp->m_cDS =
2142 NTNUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cDS] * 1e-9;
2143 table3gpp->m_cASD =
2144 NTNUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cASD];
2145 table3gpp->m_cASA =
2146 NTNUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cASA];
2147 table3gpp->m_cZSA =
2148 NTNUrbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cZSA];
2149 table3gpp->m_perClusterShadowingStd = NTNUrbanNLOS.at(freqBand).at(
2150 elevAngleQuantized)[Table3gppParams::perClusterShadowingStd];
2151
2152 for (uint8_t row = 0; row < 6; row++)
2153 {
2154 for (uint8_t column = 0; column < 6; column++)
2155 {
2156 table3gpp->m_sqrtC[row][column] =
2157 sqrtC_NTN_Urban_NLOS.at(elevAngleQuantized)[row][column];
2158 }
2159 }
2160 }
2161 }
2162 else if (m_scenario == "NTN-Suburban")
2163 {
2164 if (channelCondition->IsLos())
2165 {
2166 table3gpp->m_uLgDS =
2167 NTNSuburbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgDS];
2168 table3gpp->m_sigLgDS =
2169 NTNSuburbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgDS];
2170 table3gpp->m_uLgASD =
2171 NTNSuburbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgASD];
2172 table3gpp->m_sigLgASD =
2173 NTNSuburbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgASD];
2174 table3gpp->m_uLgASA =
2175 NTNSuburbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgASA];
2176 table3gpp->m_sigLgASA =
2177 NTNSuburbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgASA];
2178 table3gpp->m_uLgZSA =
2179 NTNSuburbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgZSA];
2180 table3gpp->m_sigLgZSA =
2181 NTNSuburbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgZSA];
2182 table3gpp->m_uLgZSD =
2183 NTNSuburbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgZSD];
2184 table3gpp->m_sigLgZSD =
2185 NTNSuburbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgZSD];
2186 table3gpp->m_uK =
2187 NTNSuburbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uK];
2188 table3gpp->m_sigK =
2189 NTNSuburbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigK];
2190 table3gpp->m_rTau =
2191 NTNSuburbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::rTau];
2192 table3gpp->m_uXpr =
2193 NTNSuburbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uXpr];
2194 table3gpp->m_sigXpr =
2195 NTNSuburbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigXpr];
2196 table3gpp->m_numOfCluster = NTNSuburbanLOS.at(freqBand).at(
2197 elevAngleQuantized)[Table3gppParams::numOfCluster];
2198 table3gpp->m_raysPerCluster = NTNSuburbanLOS.at(freqBand).at(
2199 elevAngleQuantized)[Table3gppParams::raysPerCluster];
2200 table3gpp->m_cDS =
2201 NTNSuburbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cDS] * 1e-9;
2202 table3gpp->m_cASD =
2203 NTNSuburbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cASD];
2204 table3gpp->m_cASA =
2205 NTNSuburbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cASA];
2206 table3gpp->m_cZSA =
2207 NTNSuburbanLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cZSA];
2208 table3gpp->m_perClusterShadowingStd = NTNSuburbanLOS.at(freqBand).at(
2209 elevAngleQuantized)[Table3gppParams::perClusterShadowingStd];
2210
2211 for (uint8_t row = 0; row < 7; row++)
2212 {
2213 for (uint8_t column = 0; column < 7; column++)
2214 {
2215 table3gpp->m_sqrtC[row][column] = sqrtC_NTN_Suburban_LOS[row][column];
2216 }
2217 }
2218 }
2219 else if (channelCondition->IsNlos())
2220 {
2221 table3gpp->m_uLgDS =
2222 NTNSuburbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgDS];
2223 table3gpp->m_sigLgDS =
2224 NTNSuburbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgDS];
2225 table3gpp->m_uLgASD =
2226 NTNSuburbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgASD];
2227 table3gpp->m_sigLgASD =
2228 NTNSuburbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgASD];
2229 table3gpp->m_uLgASA =
2230 NTNSuburbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgASA];
2231 table3gpp->m_sigLgASA =
2232 NTNSuburbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgASA];
2233 table3gpp->m_uLgZSA =
2234 NTNSuburbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgZSA];
2235 table3gpp->m_sigLgZSA =
2236 NTNSuburbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgZSA];
2237 table3gpp->m_uLgZSD =
2238 NTNSuburbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgZSD];
2239 table3gpp->m_sigLgZSD =
2240 NTNSuburbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgZSD];
2241 table3gpp->m_uK =
2242 NTNSuburbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uK];
2243 table3gpp->m_sigK =
2244 NTNSuburbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigK];
2245 table3gpp->m_rTau =
2246 NTNSuburbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::rTau];
2247 table3gpp->m_uXpr =
2248 NTNSuburbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uXpr];
2249 table3gpp->m_sigXpr =
2250 NTNSuburbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigXpr];
2251 table3gpp->m_numOfCluster = NTNSuburbanNLOS.at(freqBand).at(
2252 elevAngleQuantized)[Table3gppParams::numOfCluster];
2253 table3gpp->m_raysPerCluster = NTNSuburbanNLOS.at(freqBand).at(
2254 elevAngleQuantized)[Table3gppParams::raysPerCluster];
2255 table3gpp->m_cDS =
2256 NTNSuburbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cDS] *
2257 1e-9;
2258 table3gpp->m_cASD =
2259 NTNSuburbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cASD];
2260 table3gpp->m_cASA =
2261 NTNSuburbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cASA];
2262 table3gpp->m_cZSA =
2263 NTNSuburbanNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cZSA];
2264 table3gpp->m_perClusterShadowingStd = NTNSuburbanNLOS.at(freqBand).at(
2265 elevAngleQuantized)[Table3gppParams::perClusterShadowingStd];
2266
2267 for (uint8_t row = 0; row < 6; row++)
2268 {
2269 for (uint8_t column = 0; column < 6; column++)
2270 {
2271 table3gpp->m_sqrtC[row][column] = sqrtC_NTN_Suburban_NLOS[row][column];
2272 }
2273 }
2274 }
2275 }
2276 else if (m_scenario == "NTN-Rural")
2277 {
2278 if (channelCondition->IsLos())
2279 {
2280 table3gpp->m_uLgDS =
2281 NTNRuralLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgDS];
2282 table3gpp->m_sigLgDS =
2283 NTNRuralLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgDS];
2284 table3gpp->m_uLgASD =
2285 NTNRuralLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgASD];
2286 table3gpp->m_sigLgASD =
2287 NTNRuralLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgASD];
2288 table3gpp->m_uLgASA =
2289 NTNRuralLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgASA];
2290 table3gpp->m_sigLgASA =
2291 NTNRuralLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgASA];
2292 table3gpp->m_uLgZSA =
2293 NTNRuralLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgZSA];
2294 table3gpp->m_sigLgZSA =
2295 NTNRuralLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgZSA];
2296 table3gpp->m_uLgZSD =
2297 NTNRuralLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgZSD];
2298 table3gpp->m_sigLgZSD =
2299 NTNRuralLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgZSD];
2300 table3gpp->m_uK =
2301 NTNRuralLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uK];
2302 table3gpp->m_sigK =
2303 NTNRuralLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigK];
2304 table3gpp->m_rTau =
2305 NTNRuralLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::rTau];
2306 table3gpp->m_uXpr =
2307 NTNRuralLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uXpr];
2308 table3gpp->m_sigXpr =
2309 NTNRuralLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigXpr];
2310 table3gpp->m_numOfCluster =
2311 NTNRuralLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::numOfCluster];
2312 table3gpp->m_raysPerCluster = NTNRuralLOS.at(freqBand).at(
2313 elevAngleQuantized)[Table3gppParams::raysPerCluster];
2314 table3gpp->m_cDS =
2315 NTNRuralLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cDS] * 1e-9;
2316 table3gpp->m_cASD =
2317 NTNRuralLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cASD];
2318 table3gpp->m_cASA =
2319 NTNRuralLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cASA];
2320 table3gpp->m_cZSA =
2321 NTNRuralLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cZSA];
2322 table3gpp->m_perClusterShadowingStd = NTNRuralLOS.at(freqBand).at(
2323 elevAngleQuantized)[Table3gppParams::perClusterShadowingStd];
2324
2325 for (uint8_t row = 0; row < 7; row++)
2326 {
2327 for (uint8_t column = 0; column < 7; column++)
2328 {
2329 table3gpp->m_sqrtC[row][column] = sqrtC_NTN_Rural_LOS[row][column];
2330 }
2331 }
2332 }
2333 else if (channelCondition->IsNlos())
2334 {
2335 table3gpp->m_uLgDS =
2336 NTNRuralNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgDS];
2337 table3gpp->m_sigLgDS =
2338 NTNRuralNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgDS];
2339 table3gpp->m_uLgASD =
2340 NTNRuralNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgASD];
2341 table3gpp->m_sigLgASD =
2342 NTNRuralNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgASD];
2343 table3gpp->m_uLgASA =
2344 NTNRuralNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgASA];
2345 table3gpp->m_sigLgASA =
2346 NTNRuralNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgASA];
2347 table3gpp->m_uLgZSA =
2348 NTNRuralNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgZSA];
2349 table3gpp->m_sigLgZSA =
2350 NTNRuralNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgZSA];
2351 table3gpp->m_uLgZSD =
2352 NTNRuralNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uLgZSD];
2353 table3gpp->m_sigLgZSD =
2354 NTNRuralNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigLgZSD];
2355 table3gpp->m_uK =
2356 NTNRuralNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uK];
2357 table3gpp->m_sigK =
2358 NTNRuralNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigK];
2359 table3gpp->m_rTau =
2360 NTNRuralNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::rTau];
2361 table3gpp->m_uXpr =
2362 NTNRuralNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::uXpr];
2363 table3gpp->m_sigXpr =
2364 NTNRuralNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::sigXpr];
2365 table3gpp->m_numOfCluster =
2366 NTNRuralNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::numOfCluster];
2367 table3gpp->m_raysPerCluster = NTNRuralNLOS.at(freqBand).at(
2368 elevAngleQuantized)[Table3gppParams::raysPerCluster];
2369 table3gpp->m_cDS =
2370 NTNRuralNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cDS] * 1e-9;
2371 table3gpp->m_cASD =
2372 NTNRuralNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cASD];
2373 table3gpp->m_cASA =
2374 NTNRuralNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cASA];
2375 table3gpp->m_cZSA =
2376 NTNRuralNLOS.at(freqBand).at(elevAngleQuantized)[Table3gppParams::cZSA];
2377 table3gpp->m_perClusterShadowingStd = NTNRuralNLOS.at(freqBand).at(
2378 elevAngleQuantized)[Table3gppParams::perClusterShadowingStd];
2379
2380 if (freqBand == "S")
2381 {
2382 for (uint8_t row = 0; row < 6; row++)
2383 {
2384 for (uint8_t column = 0; column < 6; column++)
2385 {
2386 table3gpp->m_sqrtC[row][column] =
2387 sqrtC_NTN_Rural_NLOS_S.at(elevAngleQuantized)[row][column];
2388 }
2389 }
2390 }
2391 else if (freqBand == "Ka")
2392 {
2393 for (uint8_t row = 0; row < 6; row++)
2394 {
2395 for (uint8_t column = 0; column < 6; column++)
2396 {
2397 table3gpp->m_sqrtC[row][column] =
2398 sqrtC_NTN_Rural_NLOS_Ka.at(elevAngleQuantized)[row][column];
2399 }
2400 }
2401 }
2402 }
2403 }
2404 // Parameters that should be set to -inf are instead set to the minimum
2405 // value of double
2406 if (isSatellite)
2407 {
2408 table3gpp->m_uLgASD = std::numeric_limits<double>::min();
2409 table3gpp->m_sigLgASD = 0;
2410 table3gpp->m_uLgZSD = std::numeric_limits<double>::min();
2411 table3gpp->m_sigLgZSD = 0;
2412 }
2413 }
2414 else
2415 {
2416 NS_FATAL_ERROR("unknown scenarios");
2417 }
2418
2419 return table3gpp;
2420}
2421
2422bool
2423ThreeGppChannelModel::ChannelParamsNeedsUpdate(Ptr<const ThreeGppChannelParams> channelParams,
2424 Ptr<const ChannelCondition> channelCondition) const
2425{
2426 NS_LOG_FUNCTION(this);
2427
2428 bool update = false;
2429
2430 // if the channel condition is different the channel has to be updated
2431 if (!channelCondition->IsEqual(channelParams->m_losCondition, channelParams->m_o2iCondition))
2432 {
2433 NS_LOG_DEBUG("Update the channel condition");
2434 update = true;
2435 }
2436
2437 // if the coherence time is over the channel has to be updated
2438 if (!m_updatePeriod.IsZero() &&
2439 Simulator::Now() - channelParams->m_generatedTime > m_updatePeriod)
2440 {
2441 NS_LOG_DEBUG("Generation time " << channelParams->m_generatedTime.As(Time::NS) << " now "
2442 << Now().As(Time::NS));
2443 update = true;
2444 }
2445
2446 return update;
2447}
2448
2449bool
2455
2456bool
2457ThreeGppChannelModel::AntennaSetupChanged(Ptr<const PhasedArrayModel> aAntenna,
2458 Ptr<const PhasedArrayModel> bAntenna,
2459 Ptr<const ChannelMatrix> channelMatrix)
2460{
2461 // This allows changing the number of antenna ports during execution,
2462 // which is used by nr's initial association.
2463 size_t sAntNumElems = aAntenna->GetNumElems();
2464 size_t uAntNumElems = bAntenna->GetNumElems();
2465 size_t chanNumRows = channelMatrix->m_channel.GetNumRows();
2466 size_t chanNumCols = channelMatrix->m_channel.GetNumCols();
2467 return (((uAntNumElems != chanNumRows) || (sAntNumElems != chanNumCols)) &&
2468 ((uAntNumElems != chanNumCols) || (sAntNumElems != chanNumRows))) ||
2469 aAntenna->IsChannelOutOfDate(bAntenna);
2470}
2471
2472Ptr<const MatrixBasedChannelModel::ChannelMatrix>
2473ThreeGppChannelModel::GetChannel(Ptr<const MobilityModel> aMob,
2474 Ptr<const MobilityModel> bMob,
2475 Ptr<const PhasedArrayModel> aAntenna,
2476 Ptr<const PhasedArrayModel> bAntenna)
2477{
2478 NS_LOG_FUNCTION(this);
2479
2480 // Compute the channel params key. The key is reciprocal, i.e., key (a, b) = key (b, a)
2481 uint64_t channelParamsKey =
2482 GetKey(aMob->GetObject<Node>()->GetId(), bMob->GetObject<Node>()->GetId());
2483 // Compute the channel matrix key. The key is reciprocal, i.e., key (a, b) = key (b, a)
2484 uint64_t channelMatrixKey = GetKey(aAntenna->GetId(), bAntenna->GetId());
2485
2486 // retrieve the channel condition
2487 Ptr<const ChannelCondition> condition =
2488 m_channelConditionModel->GetChannelCondition(aMob, bMob);
2489
2490 // Check if the channel is present in the map and return it, otherwise
2491 // generate a new channel
2492 bool updateParams = false;
2493 bool updateMatrix = false;
2494 bool notFoundParams = false;
2495 bool notFoundMatrix = false;
2496 Ptr<ChannelMatrix> channelMatrix;
2497 Ptr<ThreeGppChannelParams> channelParams;
2498
2499 if (m_channelParamsMap.find(channelParamsKey) != m_channelParamsMap.end())
2500 {
2501 channelParams = m_channelParamsMap[channelParamsKey];
2502 // check if it has to be updated
2503 updateParams = ChannelParamsNeedsUpdate(channelParams, condition);
2504 }
2505 else
2506 {
2507 NS_LOG_DEBUG("channel params not found");
2508 notFoundParams = true;
2509 }
2510
2511 // get the 3GPP parameters
2512 Ptr<const ParamsTable> table3gpp = GetThreeGppTable(aMob, bMob, condition);
2513
2514 if (notFoundParams || updateParams)
2515 {
2516 // Step 4: Generate large scale parameters. All LSPS are uncorrelated.
2517 // Step 5: Generate Delays.
2518 // Step 6: Generate cluster powers.
2519 // Step 7: Generate arrival and departure angles for both azimuth and elevation.
2520 // Step 8: Coupling of rays within a cluster for both azimuth and elevation
2521 // shuffle all the arrays to perform random coupling
2522 // Step 9: Generate the cross polarization power ratios
2523 // Step 10: Draw initial phases
2524 channelParams = GenerateChannelParameters(condition, table3gpp, aMob, bMob);
2525 // store or replace the channel parameters
2526 m_channelParamsMap[channelParamsKey] = channelParams;
2527 }
2528
2529 if (m_channelMatrixMap.find(channelMatrixKey) != m_channelMatrixMap.end())
2530 {
2531 // channel matrix present in the map
2532 NS_LOG_DEBUG("channel matrix present in the map");
2533 channelMatrix = m_channelMatrixMap[channelMatrixKey];
2534 updateMatrix = ChannelMatrixNeedsUpdate(channelParams, channelMatrix);
2535 updateMatrix |= AntennaSetupChanged(aAntenna, bAntenna, channelMatrix);
2536 }
2537 else
2538 {
2539 NS_LOG_DEBUG("channel matrix not found");
2540 notFoundMatrix = true;
2541 }
2542
2543 // If the channel is not present in the map or if it has to be updated
2544 // generate a new realization
2545 if (notFoundMatrix || updateMatrix)
2546 {
2547 // channel matrix not found or has to be updated, generate a new one
2548 channelMatrix = GetNewChannel(channelParams, table3gpp, aMob, bMob, aAntenna, bAntenna);
2549 channelMatrix->m_antennaPair =
2550 std::make_pair(aAntenna->GetId(),
2551 bAntenna->GetId()); // save antenna pair, with the exact order of s and u
2552 // antennas at the moment of the channel generation
2553
2554 // store or replace the channel matrix in the channel map
2555 m_channelMatrixMap[channelMatrixKey] = channelMatrix;
2556 }
2557
2558 return channelMatrix;
2559}
2560
2561Ptr<const MatrixBasedChannelModel::ChannelParams>
2562ThreeGppChannelModel::GetParams(Ptr<const MobilityModel> aMob, Ptr<const MobilityModel> bMob) const
2563{
2564 NS_LOG_FUNCTION(this);
2565
2566 // Compute the channel key. The key is reciprocal, i.e., key (a, b) = key (b, a)
2567 uint64_t channelParamsKey =
2568 GetKey(aMob->GetObject<Node>()->GetId(), bMob->GetObject<Node>()->GetId());
2569
2570 if (m_channelParamsMap.find(channelParamsKey) != m_channelParamsMap.end())
2571 {
2572 return m_channelParamsMap.find(channelParamsKey)->second;
2573 }
2574 else
2575 {
2576 NS_LOG_WARN("Channel params map not found. Returning a nullptr.");
2577 return nullptr;
2578 }
2579}
2580
2581Ptr<ThreeGppChannelModel::ThreeGppChannelParams>
2582ThreeGppChannelModel::GenerateChannelParameters(const Ptr<const ChannelCondition> channelCondition,
2583 const Ptr<const ParamsTable> table3gpp,
2584 const Ptr<const MobilityModel> aMob,
2585 const Ptr<const MobilityModel> bMob) const
2586{
2587 NS_LOG_FUNCTION(this);
2588 // create a channel matrix instance
2589 Ptr<ThreeGppChannelParams> channelParams = Create<ThreeGppChannelParams>();
2590 channelParams->m_generatedTime = Simulator::Now();
2591 channelParams->m_nodeIds =
2592 std::make_pair(aMob->GetObject<Node>()->GetId(), bMob->GetObject<Node>()->GetId());
2593 channelParams->m_losCondition = channelCondition->GetLosCondition();
2594 channelParams->m_o2iCondition = channelCondition->GetO2iCondition();
2595
2596 // Step 4: Generate large scale parameters. All LSPS are uncorrelated.
2597 DoubleVector LSPsIndep;
2598 DoubleVector LSPs;
2599 uint8_t paramNum = 6;
2600 if (channelParams->m_losCondition == ChannelCondition::LOS)
2601 {
2602 paramNum = 7;
2603 }
2604
2605 // Generate paramNum independent LSPs.
2606 for (uint8_t iter = 0; iter < paramNum; iter++)
2607 {
2608 LSPsIndep.push_back(m_normalRv->GetValue());
2609 }
2610 for (uint8_t row = 0; row < paramNum; row++)
2611 {
2612 double temp = 0;
2613 for (uint8_t column = 0; column < paramNum; column++)
2614 {
2615 temp += table3gpp->m_sqrtC[row][column] * LSPsIndep[column];
2616 }
2617 LSPs.push_back(temp);
2618 }
2619
2620 // NOTE the shadowing is generated in the propagation loss model
2621 double DS;
2622 double ASD;
2623 double ASA;
2624 double ZSA;
2625 double ZSD;
2626 double kFactor = 0;
2627 if (channelParams->m_losCondition == ChannelCondition::LOS)
2628 {
2629 kFactor = LSPs[1] * table3gpp->m_sigK + table3gpp->m_uK;
2630 DS = pow(10, LSPs[2] * table3gpp->m_sigLgDS + table3gpp->m_uLgDS);
2631 ASD = pow(10, LSPs[3] * table3gpp->m_sigLgASD + table3gpp->m_uLgASD);
2632 ASA = pow(10, LSPs[4] * table3gpp->m_sigLgASA + table3gpp->m_uLgASA);
2633 ZSD = pow(10, LSPs[5] * table3gpp->m_sigLgZSD + table3gpp->m_uLgZSD);
2634 ZSA = pow(10, LSPs[6] * table3gpp->m_sigLgZSA + table3gpp->m_uLgZSA);
2635 }
2636 else
2637 {
2638 DS = pow(10, LSPs[1] * table3gpp->m_sigLgDS + table3gpp->m_uLgDS);
2639 ASD = pow(10, LSPs[2] * table3gpp->m_sigLgASD + table3gpp->m_uLgASD);
2640 ASA = pow(10, LSPs[3] * table3gpp->m_sigLgASA + table3gpp->m_uLgASA);
2641 ZSD = pow(10, LSPs[4] * table3gpp->m_sigLgZSD + table3gpp->m_uLgZSD);
2642 ZSA = pow(10, LSPs[5] * table3gpp->m_sigLgZSA + table3gpp->m_uLgZSA);
2643 }
2644 ASD = std::min(ASD, 104.0);
2645 ASA = std::min(ASA, 104.0);
2646 ZSD = std::min(ZSD, 52.0);
2647 ZSA = std::min(ZSA, 52.0);
2648
2649 // save DS and K_factor parameters in the structure
2650 channelParams->m_DS = DS;
2651 channelParams->m_K_factor = kFactor;
2652
2653 NS_LOG_INFO("K-factor=" << kFactor << ", DS=" << DS << ", ASD=" << ASD << ", ASA=" << ASA
2654 << ", ZSD=" << ZSD << ", ZSA=" << ZSA);
2655
2656 // Step 5: Generate Delays.
2657 DoubleVector clusterDelay;
2658 double minTau = 100.0;
2659 for (uint8_t cIndex = 0; cIndex < table3gpp->m_numOfCluster; cIndex++)
2660 {
2661 double tau = -1 * table3gpp->m_rTau * DS * log(m_uniformRv->GetValue(0, 1)); //(7.5-1)
2662 if (minTau > tau)
2663 {
2664 minTau = tau;
2665 }
2666 clusterDelay.push_back(tau);
2667 }
2668
2669 for (uint8_t cIndex = 0; cIndex < table3gpp->m_numOfCluster; cIndex++)
2670 {
2671 clusterDelay[cIndex] -= minTau;
2672 }
2673 std::sort(clusterDelay.begin(), clusterDelay.end()); //(7.5-2)
2674
2675 /* since the scaled Los delays are not to be used in cluster power generation,
2676 * we will generate cluster power first and resume to compute Los cluster delay later.*/
2677
2678 // Step 6: Generate cluster powers.
2679 DoubleVector clusterPower;
2680 double powerSum = 0;
2681 for (uint8_t cIndex = 0; cIndex < table3gpp->m_numOfCluster; cIndex++)
2682 {
2683 double power =
2684 exp(-1 * clusterDelay[cIndex] * (table3gpp->m_rTau - 1) / table3gpp->m_rTau / DS) *
2685 pow(10,
2686 -1 * m_normalRv->GetValue() * table3gpp->m_perClusterShadowingStd / 10.0); //(7.5-5)
2687 powerSum += power;
2688 clusterPower.push_back(power);
2689 }
2690 channelParams->m_clusterPower = clusterPower;
2691
2692 double powerMax = 0;
2693
2694 for (uint8_t cIndex = 0; cIndex < table3gpp->m_numOfCluster; cIndex++)
2695 {
2696 channelParams->m_clusterPower[cIndex] =
2697 channelParams->m_clusterPower[cIndex] / powerSum; //(7.5-6)
2698 }
2699
2700 DoubleVector clusterPowerForAngles; // this power is only for equation (7.5-9) and (7.5-14), not
2701 // for (7.5-22)
2702 if (channelParams->m_losCondition == ChannelCondition::LOS)
2703 {
2704 double kLinear = pow(10, kFactor / 10.0);
2705
2706 for (uint8_t cIndex = 0; cIndex < table3gpp->m_numOfCluster; cIndex++)
2707 {
2708 if (cIndex == 0)
2709 {
2710 clusterPowerForAngles.push_back(channelParams->m_clusterPower[cIndex] /
2711 (1 + kLinear) +
2712 kLinear / (1 + kLinear)); //(7.5-8)
2713 }
2714 else
2715 {
2716 clusterPowerForAngles.push_back(channelParams->m_clusterPower[cIndex] /
2717 (1 + kLinear)); //(7.5-8)
2718 }
2719 if (powerMax < clusterPowerForAngles[cIndex])
2720 {
2721 powerMax = clusterPowerForAngles[cIndex];
2722 }
2723 }
2724 }
2725 else
2726 {
2727 for (uint8_t cIndex = 0; cIndex < table3gpp->m_numOfCluster; cIndex++)
2728 {
2729 clusterPowerForAngles.push_back(channelParams->m_clusterPower[cIndex]); //(7.5-6)
2730 if (powerMax < clusterPowerForAngles[cIndex])
2731 {
2732 powerMax = clusterPowerForAngles[cIndex];
2733 }
2734 }
2735 }
2736
2737 // remove clusters with less than -25 dB power compared to the maxim cluster power;
2738 // double thresh = pow(10, -2.5);
2739 double thresh = 0.0032;
2740 for (uint8_t cIndex = table3gpp->m_numOfCluster; cIndex > 0; cIndex--)
2741 {
2742 if (clusterPowerForAngles[cIndex - 1] < thresh * powerMax)
2743 {
2744 clusterPowerForAngles.erase(clusterPowerForAngles.begin() + cIndex - 1);
2745 channelParams->m_clusterPower.erase(channelParams->m_clusterPower.begin() + cIndex - 1);
2746 clusterDelay.erase(clusterDelay.begin() + cIndex - 1);
2747 }
2748 }
2749
2750 NS_ASSERT(channelParams->m_clusterPower.size() < UINT8_MAX);
2751 channelParams->m_reducedClusterNumber = channelParams->m_clusterPower.size();
2752 // Resume step 5 to compute the delay for LoS condition.
2753 if (channelParams->m_losCondition == ChannelCondition::LOS)
2754 {
2755 double cTau =
2756 0.7705 - 0.0433 * kFactor + 2e-4 * pow(kFactor, 2) + 17e-6 * pow(kFactor, 3); //(7.5-3)
2757 for (uint8_t cIndex = 0; cIndex < channelParams->m_reducedClusterNumber; cIndex++)
2758 {
2759 clusterDelay[cIndex] = clusterDelay[cIndex] / cTau; //(7.5-4)
2760 }
2761 }
2762
2763 // Step 7: Generate arrival and departure angles for both azimuth and elevation.
2764
2765 double cNlos;
2766 // According to table 7.5-6, only cluster number equals to 8, 10, 11, 12, 19 and 20 is valid.
2767 // Not sure why the other cases are in Table 7.5-2.
2768 // Added case 2 and 3 for the NTN according to table 6.7.2-1aa (28.811)
2769 switch (table3gpp->m_numOfCluster) // Table 7.5-2
2770 {
2771 case 2:
2772 cNlos = 0.501;
2773 break;
2774 case 3:
2775 cNlos = 0.680;
2776 break;
2777 case 4:
2778 cNlos = 0.779;
2779 break;
2780 case 5:
2781 cNlos = 0.860;
2782 break;
2783 case 8:
2784 cNlos = 1.018;
2785 break;
2786 case 10:
2787 cNlos = 1.090;
2788 break;
2789 case 11:
2790 cNlos = 1.123;
2791 break;
2792 case 12:
2793 cNlos = 1.146;
2794 break;
2795 case 14:
2796 cNlos = 1.190;
2797 break;
2798 case 15:
2799 cNlos = 1.221;
2800 break;
2801 case 16:
2802 cNlos = 1.226;
2803 break;
2804 case 19:
2805 cNlos = 1.273;
2806 break;
2807 case 20:
2808 cNlos = 1.289;
2809 break;
2810 default:
2811 NS_FATAL_ERROR("Invalid cluster number");
2812 }
2813
2814 double cPhi = cNlos;
2815
2816 if (channelParams->m_losCondition == ChannelCondition::LOS)
2817 {
2818 cPhi *= (1.1035 - 0.028 * kFactor - 2e-3 * pow(kFactor, 2) +
2819 1e-4 * pow(kFactor, 3)); //(7.5-10))
2820 }
2821
2822 // Added case 2, 3 and 4 for the NTN according to table 6.7.2-1ab (28.811)
2823 switch (table3gpp->m_numOfCluster) // Table 7.5-4
2824 {
2825 case 2:
2826 cNlos = 0.430;
2827 break;
2828 case 3:
2829 cNlos = 0.594;
2830 break;
2831 case 4:
2832 cNlos = 0.697;
2833 break;
2834 case 8:
2835 cNlos = 0.889;
2836 break;
2837 case 10:
2838 cNlos = 0.957;
2839 break;
2840 case 11:
2841 cNlos = 1.031;
2842 break;
2843 case 12:
2844 cNlos = 1.104;
2845 break;
2846 case 15:
2847 cNlos = 1.1088;
2848 break;
2849 case 19:
2850 cNlos = 1.184;
2851 break;
2852 case 20:
2853 cNlos = 1.178;
2854 break;
2855 default:
2856 NS_FATAL_ERROR("Invalid cluster number");
2857 }
2858
2859 double cTheta = cNlos;
2860 if (channelCondition->IsLos())
2861 {
2862 cTheta *= (1.3086 + 0.0339 * kFactor - 0.0077 * pow(kFactor, 2) +
2863 2e-4 * pow(kFactor, 3)); //(7.5-15)
2864 }
2865
2866 DoubleVector clusterAoa;
2867 DoubleVector clusterAod;
2868 DoubleVector clusterZoa;
2869 DoubleVector clusterZod;
2870 for (uint8_t cIndex = 0; cIndex < channelParams->m_reducedClusterNumber; cIndex++)
2871 {
2872 double logCalc = -1 * log(clusterPowerForAngles[cIndex] / powerMax);
2873 double angle = 2 * sqrt(logCalc) / 1.4 / cPhi; //(7.5-9)
2874 clusterAoa.push_back(ASA * angle);
2875 clusterAod.push_back(ASD * angle);
2876 angle = logCalc / cTheta; //(7.5-14)
2877 clusterZoa.push_back(ZSA * angle);
2878 clusterZod.push_back(ZSD * angle);
2879 }
2880
2881 Angles sAngle(bMob->GetPosition(), aMob->GetPosition());
2882 Angles uAngle(aMob->GetPosition(), bMob->GetPosition());
2883
2884 for (uint8_t cIndex = 0; cIndex < channelParams->m_reducedClusterNumber; cIndex++)
2885 {
2886 int Xn = 1;
2887 if (m_uniformRv->GetValue(0, 1) < 0.5)
2888 {
2889 Xn = -1;
2890 }
2891 clusterAoa[cIndex] = clusterAoa[cIndex] * Xn + (m_normalRv->GetValue() * ASA / 7.0) +
2892 RadiansToDegrees(uAngle.GetAzimuth()); //(7.5-11)
2893 clusterAod[cIndex] = clusterAod[cIndex] * Xn + (m_normalRv->GetValue() * ASD / 7.0) +
2894 RadiansToDegrees(sAngle.GetAzimuth());
2895 if (channelCondition->IsO2i())
2896 {
2897 clusterZoa[cIndex] =
2898 clusterZoa[cIndex] * Xn + (m_normalRv->GetValue() * ZSA / 7.0) + 90; //(7.5-16)
2899 }
2900 else
2901 {
2902 clusterZoa[cIndex] = clusterZoa[cIndex] * Xn + (m_normalRv->GetValue() * ZSA / 7.0) +
2903 RadiansToDegrees(uAngle.GetInclination()); //(7.5-16)
2904 }
2905 clusterZod[cIndex] = clusterZod[cIndex] * Xn + (m_normalRv->GetValue() * ZSD / 7.0) +
2906 RadiansToDegrees(sAngle.GetInclination()) +
2907 table3gpp->m_offsetZOD; //(7.5-19)
2908 }
2909
2910 if (channelParams->m_losCondition == ChannelCondition::LOS)
2911 {
2912 // The 7.5-12 can be rewrite as Theta_n,ZOA = Theta_n,ZOA - (Theta_1,ZOA - Theta_LOS,ZOA) =
2913 // Theta_n,ZOA - diffZOA, Similar as AOD, ZSA and ZSD.
2914 double diffAoa = clusterAoa[0] - RadiansToDegrees(uAngle.GetAzimuth());
2915 double diffAod = clusterAod[0] - RadiansToDegrees(sAngle.GetAzimuth());
2916 double diffZsa = clusterZoa[0] - RadiansToDegrees(uAngle.GetInclination());
2917 double diffZsd = clusterZod[0] - RadiansToDegrees(sAngle.GetInclination());
2918
2919 for (uint8_t cIndex = 0; cIndex < channelParams->m_reducedClusterNumber; cIndex++)
2920 {
2921 clusterAoa[cIndex] -= diffAoa; //(7.5-12)
2922 clusterAod[cIndex] -= diffAod;
2923 clusterZoa[cIndex] -= diffZsa; //(7.5-17)
2924 clusterZod[cIndex] -= diffZsd;
2925 }
2926 }
2927
2928 double sizeTemp = clusterZoa.size();
2929 for (uint8_t ind = 0; ind < 4; ind++)
2930 {
2931 DoubleVector angleDegree;
2932 switch (ind)
2933 {
2934 case 0:
2935 angleDegree = clusterAoa;
2936 break;
2937 case 1:
2938 angleDegree = clusterZoa;
2939 break;
2940 case 2:
2941 angleDegree = clusterAod;
2942 break;
2943 case 3:
2944 angleDegree = clusterZod;
2945 break;
2946 default:
2947 NS_FATAL_ERROR("Programming Error");
2948 }
2949 for (uint8_t nIndex = 0; nIndex < sizeTemp; nIndex++)
2950 {
2951 while (angleDegree[nIndex] > 360)
2952 {
2953 angleDegree[nIndex] -= 360;
2954 }
2955
2956 while (angleDegree[nIndex] < 0)
2957 {
2958 angleDegree[nIndex] += 360;
2959 }
2960
2961 if (ind == 1 || ind == 3)
2962 {
2963 if (angleDegree[nIndex] > 180)
2964 {
2965 angleDegree[nIndex] = 360 - angleDegree[nIndex];
2966 }
2967 }
2968 }
2969 switch (ind)
2970 {
2971 case 0:
2972 clusterAoa = angleDegree;
2973 break;
2974 case 1:
2975 clusterZoa = angleDegree;
2976 break;
2977 case 2:
2978 clusterAod = angleDegree;
2979 break;
2980 case 3:
2981 clusterZod = angleDegree;
2982 break;
2983 default:
2984 NS_FATAL_ERROR("Programming Error");
2985 }
2986 }
2987
2988 DoubleVector attenuationDb;
2989 if (m_blockage)
2990 {
2991 attenuationDb = CalcAttenuationOfBlockage(channelParams, clusterAoa, clusterZoa);
2992 for (uint8_t cInd = 0; cInd < channelParams->m_reducedClusterNumber; cInd++)
2993 {
2994 channelParams->m_clusterPower[cInd] =
2995 channelParams->m_clusterPower[cInd] / pow(10, attenuationDb[cInd] / 10.0);
2996 }
2997 }
2998 else
2999 {
3000 attenuationDb.push_back(0);
3001 }
3002
3003 // store attenuation
3004 channelParams->m_attenuation_dB = attenuationDb;
3005
3006 // Step 8: Coupling of rays within a cluster for both azimuth and elevation
3007 // shuffle all the arrays to perform random coupling
3008 MatrixBasedChannelModel::Double2DVector rayAoaRadian(
3009 channelParams->m_reducedClusterNumber,
3010 DoubleVector(table3gpp->m_raysPerCluster,
3011 0)); // rayAoaRadian[n][m], where n is cluster index, m is ray index
3012 MatrixBasedChannelModel::Double2DVector rayAodRadian(
3013 channelParams->m_reducedClusterNumber,
3014 DoubleVector(table3gpp->m_raysPerCluster,
3015 0)); // rayAodRadian[n][m], where n is cluster index, m is ray index
3016 MatrixBasedChannelModel::Double2DVector rayZoaRadian(
3017 channelParams->m_reducedClusterNumber,
3018 DoubleVector(table3gpp->m_raysPerCluster,
3019 0)); // rayZoaRadian[n][m], where n is cluster index, m is ray index
3020 MatrixBasedChannelModel::Double2DVector rayZodRadian(
3021 channelParams->m_reducedClusterNumber,
3022 DoubleVector(table3gpp->m_raysPerCluster,
3023 0)); // rayZodRadian[n][m], where n is cluster index, m is ray index
3024
3025 const double pow10_uLgZSD = pow(10, table3gpp->m_uLgZSD);
3026 for (uint8_t nInd = 0; nInd < channelParams->m_reducedClusterNumber; nInd++)
3027 {
3028 for (uint8_t mInd = 0; mInd < table3gpp->m_raysPerCluster; mInd++)
3029 {
3030 double tempAoa = clusterAoa[nInd] + table3gpp->m_cASA * offSetAlpha[mInd]; //(7.5-13)
3031 double tempZoa = clusterZoa[nInd] + table3gpp->m_cZSA * offSetAlpha[mInd]; //(7.5-18)
3032 std::tie(rayAoaRadian[nInd][mInd], rayZoaRadian[nInd][mInd]) =
3033 WrapAngles(DegreesToRadians(tempAoa), DegreesToRadians(tempZoa));
3034
3035 double tempAod = clusterAod[nInd] + table3gpp->m_cASD * offSetAlpha[mInd]; //(7.5-13)
3036 double tempZod = clusterZod[nInd] + 0.375 * pow10_uLgZSD * offSetAlpha[mInd]; //(7.5-20)
3037 std::tie(rayAodRadian[nInd][mInd], rayZodRadian[nInd][mInd]) =
3038 WrapAngles(DegreesToRadians(tempAod), DegreesToRadians(tempZod));
3039 }
3040 }
3041
3042 for (uint8_t cIndex = 0; cIndex < channelParams->m_reducedClusterNumber; cIndex++)
3043 {
3044 Shuffle(rayAodRadian[cIndex].begin(), rayAodRadian[cIndex].end(), m_uniformRvShuffle);
3045 Shuffle(rayAoaRadian[cIndex].begin(), rayAoaRadian[cIndex].end(), m_uniformRvShuffle);
3046 Shuffle(rayZodRadian[cIndex].begin(), rayZodRadian[cIndex].end(), m_uniformRvShuffle);
3047 Shuffle(rayZoaRadian[cIndex].begin(), rayZoaRadian[cIndex].end(), m_uniformRvShuffle);
3048 }
3049
3050 // store values
3051 channelParams->m_rayAodRadian = rayAodRadian;
3052 channelParams->m_rayAoaRadian = rayAoaRadian;
3053 channelParams->m_rayZodRadian = rayZodRadian;
3054 channelParams->m_rayZoaRadian = rayZoaRadian;
3055
3056 // Step 9: Generate the cross polarization power ratios
3057 // Step 10: Draw initial phases
3058
3059 // vector containing the cross polarization power ratios, as defined by 7.5-21
3060 auto& crossPolarizationPowerRatios = channelParams->m_crossPolarizationPowerRatios;
3061 // rayAoaRadian[n][m], where n is cluster index, m is ray index
3062 auto& clusterPhase = channelParams->m_clusterPhase;
3063
3064 const double uXprLinear = pow(10, table3gpp->m_uXpr / 10.0); // convert to linear
3065 const double sigXprLinear = pow(10, table3gpp->m_sigXpr / 10.0); // convert to linear
3066
3067 // store the PHI values for all the possible combination of polarization
3068 clusterPhase.resize(channelParams->m_reducedClusterNumber);
3069 crossPolarizationPowerRatios.resize(channelParams->m_reducedClusterNumber);
3070 for (uint8_t nInd = 0; nInd < channelParams->m_reducedClusterNumber; nInd++)
3071 {
3072 clusterPhase[nInd].resize(table3gpp->m_raysPerCluster);
3073 crossPolarizationPowerRatios[nInd].resize(table3gpp->m_raysPerCluster);
3074 for (uint8_t mInd = 0; mInd < table3gpp->m_raysPerCluster; mInd++)
3075 {
3076 clusterPhase[nInd][mInd].resize(4);
3077 // used to store the XPR values
3078 crossPolarizationPowerRatios[nInd][mInd] =
3079 std::pow(10, (m_normalRv->GetValue() * sigXprLinear + uXprLinear) / 10.0);
3080 for (uint8_t pInd = 0; pInd < 4; pInd++)
3081 {
3082 // used to store the PHI values
3083 clusterPhase[nInd][mInd][pInd] = m_uniformRv->GetValue(-1 * M_PI, M_PI);
3084 }
3085 }
3086 }
3087
3088 uint8_t cluster1st = 0;
3089 uint8_t cluster2nd = 0; // first and second strongest cluster;
3090 double maxPower = 0;
3091 for (uint8_t cIndex = 0; cIndex < channelParams->m_reducedClusterNumber; cIndex++)
3092 {
3093 if (maxPower < channelParams->m_clusterPower[cIndex])
3094 {
3095 maxPower = channelParams->m_clusterPower[cIndex];
3096 cluster1st = cIndex;
3097 }
3098 }
3099 channelParams->m_cluster1st = cluster1st;
3100 maxPower = 0;
3101 for (uint8_t cIndex = 0; cIndex < channelParams->m_reducedClusterNumber; cIndex++)
3102 {
3103 if (maxPower < channelParams->m_clusterPower[cIndex] && cluster1st != cIndex)
3104 {
3105 maxPower = channelParams->m_clusterPower[cIndex];
3106 cluster2nd = cIndex;
3107 }
3108 }
3109 channelParams->m_cluster2nd = cluster2nd;
3110
3111 NS_LOG_INFO("1st strongest cluster:" << +cluster1st
3112 << ", 2nd strongest cluster:" << +cluster2nd);
3113
3114 // store the delays and the angles for the subclusters
3115 if (cluster1st == cluster2nd)
3116 {
3117 clusterDelay.push_back(clusterDelay[cluster1st] + 1.28 * table3gpp->m_cDS);
3118 clusterDelay.push_back(clusterDelay[cluster1st] + 2.56 * table3gpp->m_cDS);
3119
3120 clusterAoa.push_back(clusterAoa[cluster1st]);
3121 clusterAoa.push_back(clusterAoa[cluster1st]);
3122
3123 clusterZoa.push_back(clusterZoa[cluster1st]);
3124 clusterZoa.push_back(clusterZoa[cluster1st]);
3125
3126 clusterAod.push_back(clusterAod[cluster1st]);
3127 clusterAod.push_back(clusterAod[cluster1st]);
3128
3129 clusterZod.push_back(clusterZod[cluster1st]);
3130 clusterZod.push_back(clusterZod[cluster1st]);
3131 }
3132 else
3133 {
3134 double min;
3135 double max;
3136 if (cluster1st < cluster2nd)
3137 {
3138 min = cluster1st;
3139 max = cluster2nd;
3140 }
3141 else
3142 {
3143 min = cluster2nd;
3144 max = cluster1st;
3145 }
3146 clusterDelay.push_back(clusterDelay[min] + 1.28 * table3gpp->m_cDS);
3147 clusterDelay.push_back(clusterDelay[min] + 2.56 * table3gpp->m_cDS);
3148 clusterDelay.push_back(clusterDelay[max] + 1.28 * table3gpp->m_cDS);
3149 clusterDelay.push_back(clusterDelay[max] + 2.56 * table3gpp->m_cDS);
3150
3151 clusterAoa.push_back(clusterAoa[min]);
3152 clusterAoa.push_back(clusterAoa[min]);
3153 clusterAoa.push_back(clusterAoa[max]);
3154 clusterAoa.push_back(clusterAoa[max]);
3155
3156 clusterZoa.push_back(clusterZoa[min]);
3157 clusterZoa.push_back(clusterZoa[min]);
3158 clusterZoa.push_back(clusterZoa[max]);
3159 clusterZoa.push_back(clusterZoa[max]);
3160
3161 clusterAod.push_back(clusterAod[min]);
3162 clusterAod.push_back(clusterAod[min]);
3163 clusterAod.push_back(clusterAod[max]);
3164 clusterAod.push_back(clusterAod[max]);
3165
3166 clusterZod.push_back(clusterZod[min]);
3167 clusterZod.push_back(clusterZod[min]);
3168 clusterZod.push_back(clusterZod[max]);
3169 clusterZod.push_back(clusterZod[max]);
3170 }
3171
3172 channelParams->m_delay = clusterDelay;
3173 channelParams->m_angle.clear();
3174 channelParams->m_angle.push_back(clusterAoa);
3175 channelParams->m_angle.push_back(clusterZoa);
3176 channelParams->m_angle.push_back(clusterAod);
3177 channelParams->m_angle.push_back(clusterZod);
3178
3179 // Precompute angles sincos
3180 channelParams->m_cachedAngleSincos.resize(channelParams->m_angle.size());
3181 for (size_t direction = 0; direction < channelParams->m_angle.size(); direction++)
3182 {
3183 channelParams->m_cachedAngleSincos[direction].resize(
3184 channelParams->m_angle[direction].size());
3185 for (size_t cluster = 0; cluster < channelParams->m_angle[direction].size(); cluster++)
3186 {
3187 channelParams->m_cachedAngleSincos[direction][cluster] = {
3188 sin(channelParams->m_angle[direction][cluster] * DEG2RAD),
3189 cos(channelParams->m_angle[direction][cluster] * DEG2RAD)};
3190 }
3191 }
3192
3193 // Compute alpha and D as described in 3GPP TR 37.885 v15.3.0, Sec. 6.2.3
3194 // These terms account for an additional Doppler contribution due to the
3195 // presence of moving objects in the surrounding environment, such as in
3196 // vehicular scenarios.
3197 // This contribution is applied only to the delayed (reflected) paths and
3198 // must be properly configured by setting the value of
3199 // m_vScatt, which is defined as "maximum speed of the vehicle in the
3200 // layout".
3201 // By default, m_vScatt is set to 0, so there is no additional Doppler
3202 // contribution.
3203
3204 DoubleVector dopplerTermAlpha;
3205 DoubleVector dopplerTermD;
3206
3207 // 2 or 4 is added to account for additional subrays for the 1st and 2nd clusters, if there is
3208 // only one cluster then would be added 2 more subrays (see creation of Husn channel matrix)
3209 uint8_t updatedClusterNumber = (channelParams->m_reducedClusterNumber == 1)
3210 ? channelParams->m_reducedClusterNumber + 2
3211 : channelParams->m_reducedClusterNumber + 4;
3212
3213 for (uint8_t cIndex = 0; cIndex < updatedClusterNumber; cIndex++)
3214 {
3215 double alpha = 0;
3216 double D = 0;
3217 if (cIndex != 0)
3218 {
3219 alpha = m_uniformRvDoppler->GetValue(-1, 1);
3220 D = m_uniformRvDoppler->GetValue(-m_vScatt, m_vScatt);
3221 }
3222 dopplerTermAlpha.push_back(alpha);
3223 dopplerTermD.push_back(D);
3224 }
3225 channelParams->m_alpha = dopplerTermAlpha;
3226 channelParams->m_D = dopplerTermD;
3227
3228 return channelParams;
3229}
3230
3231Ptr<MatrixBasedChannelModel::ChannelMatrix>
3232ThreeGppChannelModel::GetNewChannel(Ptr<const ThreeGppChannelParams> channelParams,
3233 Ptr<const ParamsTable> table3gpp,
3234 const Ptr<const MobilityModel> sMob,
3235 const Ptr<const MobilityModel> uMob,
3236 Ptr<const PhasedArrayModel> sAntenna,
3237 Ptr<const PhasedArrayModel> uAntenna) const
3238{
3239 NS_LOG_FUNCTION(this);
3240
3241 NS_ASSERT_MSG(m_frequency > 0.0, "Set the operating frequency first!");
3242
3243 // create a channel matrix instance
3244 Ptr<ChannelMatrix> channelMatrix = Create<ChannelMatrix>();
3245 channelMatrix->m_generatedTime = Simulator::Now();
3246 // save in which order is generated this matrix
3247 channelMatrix->m_nodeIds =
3248 std::make_pair(sMob->GetObject<Node>()->GetId(), uMob->GetObject<Node>()->GetId());
3249 // check if channelParams structure is generated in direction s-to-u or u-to-s
3250 bool isSameDirection = (channelParams->m_nodeIds == channelMatrix->m_nodeIds);
3251
3252 MatrixBasedChannelModel::Double2DVector rayAodRadian;
3253 MatrixBasedChannelModel::Double2DVector rayAoaRadian;
3254 MatrixBasedChannelModel::Double2DVector rayZodRadian;
3255 MatrixBasedChannelModel::Double2DVector rayZoaRadian;
3256
3257 // if channel params is generated in the same direction in which we
3258 // generate the channel matrix, angles and zenith od departure and arrival are ok,
3259 // just set them to corresponding variable that will be used for the generation
3260 // of channel matrix, otherwise we need to flip angles and zeniths of departure and arrival
3261 if (isSameDirection)
3262 {
3263 rayAodRadian = channelParams->m_rayAodRadian;
3264 rayAoaRadian = channelParams->m_rayAoaRadian;
3265 rayZodRadian = channelParams->m_rayZodRadian;
3266 rayZoaRadian = channelParams->m_rayZoaRadian;
3267 }
3268 else
3269 {
3270 rayAodRadian = channelParams->m_rayAoaRadian;
3271 rayAoaRadian = channelParams->m_rayAodRadian;
3272 rayZodRadian = channelParams->m_rayZoaRadian;
3273 rayZoaRadian = channelParams->m_rayZodRadian;
3274 }
3275
3276 // Step 11: Generate channel coefficients for each cluster n and each receiver
3277 // and transmitter element pair u,s.
3278 // where n is cluster index, u and s are receive and transmit antenna element.
3279 size_t uSize = uAntenna->GetNumElems();
3280 size_t sSize = sAntenna->GetNumElems();
3281
3282 // NOTE: Since each of the strongest 2 clusters are divided into 3 sub-clusters,
3283 // the total cluster will generally be numReducedCLuster + 4.
3284 // However, it might be that m_cluster1st = m_cluster2nd. In this case the
3285 // total number of clusters will be numReducedCLuster + 2.
3286 uint16_t numOverallCluster = (channelParams->m_cluster1st != channelParams->m_cluster2nd)
3287 ? channelParams->m_reducedClusterNumber + 4
3288 : channelParams->m_reducedClusterNumber + 2;
3289 Complex3DVector hUsn(uSize, sSize, numOverallCluster); // channel coefficient hUsn (u, s, n);
3290 NS_ASSERT(channelParams->m_reducedClusterNumber <= channelParams->m_clusterPhase.size());
3291 NS_ASSERT(channelParams->m_reducedClusterNumber <= channelParams->m_clusterPower.size());
3292 NS_ASSERT(channelParams->m_reducedClusterNumber <=
3293 channelParams->m_crossPolarizationPowerRatios.size());
3294 NS_ASSERT(channelParams->m_reducedClusterNumber <= rayZoaRadian.size());
3295 NS_ASSERT(channelParams->m_reducedClusterNumber <= rayZodRadian.size());
3296 NS_ASSERT(channelParams->m_reducedClusterNumber <= rayAoaRadian.size());
3297 NS_ASSERT(channelParams->m_reducedClusterNumber <= rayAodRadian.size());
3298 NS_ASSERT(table3gpp->m_raysPerCluster <= channelParams->m_clusterPhase[0].size());
3299 NS_ASSERT(table3gpp->m_raysPerCluster <=
3300 channelParams->m_crossPolarizationPowerRatios[0].size());
3301 NS_ASSERT(table3gpp->m_raysPerCluster <= rayZoaRadian[0].size());
3302 NS_ASSERT(table3gpp->m_raysPerCluster <= rayZodRadian[0].size());
3303 NS_ASSERT(table3gpp->m_raysPerCluster <= rayAoaRadian[0].size());
3304 NS_ASSERT(table3gpp->m_raysPerCluster <= rayAodRadian[0].size());
3305
3306 double x = sMob->GetPosition().x - uMob->GetPosition().x;
3307 double y = sMob->GetPosition().y - uMob->GetPosition().y;
3308 double distance2D = sqrt(x * x + y * y);
3309 // NOTE we assume hUT = min (height(a), height(b)) and
3310 // hBS = max (height (a), height (b))
3311 double hUt = std::min(sMob->GetPosition().z, uMob->GetPosition().z);
3312 double hBs = std::max(sMob->GetPosition().z, uMob->GetPosition().z);
3313 // compute the 3D distance using eq. 7.4-1
3314 double distance3D = std::sqrt(distance2D * distance2D + (hBs - hUt) * (hBs - hUt));
3315
3316 Angles sAngle(uMob->GetPosition(), sMob->GetPosition());
3317 Angles uAngle(sMob->GetPosition(), uMob->GetPosition());
3318
3319 Double2DVector sinCosA; // cached multiplications of sin and cos of the ZoA and AoA angles
3320 Double2DVector sinSinA; // cached multiplications of sines of the ZoA and AoA angles
3321 Double2DVector cosZoA; // cached cos of the ZoA angle
3322 Double2DVector sinCosD; // cached multiplications of sin and cos of the ZoD and AoD angles
3323 Double2DVector sinSinD; // cached multiplications of the cosines of the ZoA and AoA angles
3324 Double2DVector cosZoD; // cached cos of the ZoD angle
3325
3326 // contains part of the ray expression, cached as independent from the u- and s-indexes,
3327 // but calculate it for different polarization angles of s and u
3328 std::map<std::pair<uint8_t, uint8_t>, Complex2DVector> raysPreComp;
3329 for (size_t polSa = 0; polSa < sAntenna->GetNumPols(); ++polSa)
3330 {
3331 for (size_t polUa = 0; polUa < uAntenna->GetNumPols(); ++polUa)
3332 {
3333 raysPreComp[std::make_pair(polSa, polUa)] =
3334 Complex2DVector(channelParams->m_reducedClusterNumber, table3gpp->m_raysPerCluster);
3335 }
3336 }
3337
3338 // resize to appropriate dimensions
3339 sinCosA.resize(channelParams->m_reducedClusterNumber);
3340 sinSinA.resize(channelParams->m_reducedClusterNumber);
3341 cosZoA.resize(channelParams->m_reducedClusterNumber);
3342 sinCosD.resize(channelParams->m_reducedClusterNumber);
3343 sinSinD.resize(channelParams->m_reducedClusterNumber);
3344 cosZoD.resize(channelParams->m_reducedClusterNumber);
3345 for (uint8_t nIndex = 0; nIndex < channelParams->m_reducedClusterNumber; nIndex++)
3346 {
3347 sinCosA[nIndex].resize(table3gpp->m_raysPerCluster);
3348 sinSinA[nIndex].resize(table3gpp->m_raysPerCluster);
3349 cosZoA[nIndex].resize(table3gpp->m_raysPerCluster);
3350 sinCosD[nIndex].resize(table3gpp->m_raysPerCluster);
3351 sinSinD[nIndex].resize(table3gpp->m_raysPerCluster);
3352 cosZoD[nIndex].resize(table3gpp->m_raysPerCluster);
3353 }
3354 // pre-compute the terms which are independent from uIndex and sIndex
3355 for (uint8_t nIndex = 0; nIndex < channelParams->m_reducedClusterNumber; nIndex++)
3356 {
3357 for (uint8_t mIndex = 0; mIndex < table3gpp->m_raysPerCluster; mIndex++)
3358 {
3359 DoubleVector initialPhase = channelParams->m_clusterPhase[nIndex][mIndex];
3360 NS_ASSERT(4 <= initialPhase.size());
3361 double k = channelParams->m_crossPolarizationPowerRatios[nIndex][mIndex];
3362
3363 // cache the component of the "rays" terms which depend on the random angle of arrivals
3364 // and departures and initial phases only
3365 for (uint8_t polUa = 0; polUa < uAntenna->GetNumPols(); ++polUa)
3366 {
3367 auto [rxFieldPatternPhi, rxFieldPatternTheta] = uAntenna->GetElementFieldPattern(
3368 Angles(channelParams->m_rayAoaRadian[nIndex][mIndex],
3369 channelParams->m_rayZoaRadian[nIndex][mIndex]),
3370 polUa);
3371 for (uint8_t polSa = 0; polSa < sAntenna->GetNumPols(); ++polSa)
3372 {
3373 auto [txFieldPatternPhi, txFieldPatternTheta] =
3374 sAntenna->GetElementFieldPattern(
3375 Angles(channelParams->m_rayAodRadian[nIndex][mIndex],
3376 channelParams->m_rayZodRadian[nIndex][mIndex]),
3377 polSa);
3378 raysPreComp[std::make_pair(polSa, polUa)](nIndex, mIndex) =
3379 std::complex<double>(cos(initialPhase[0]), sin(initialPhase[0])) *
3380 rxFieldPatternTheta * txFieldPatternTheta +
3381 std::complex<double>(cos(initialPhase[1]), sin(initialPhase[1])) *
3382 std::sqrt(1.0 / k) * rxFieldPatternTheta * txFieldPatternPhi +
3383 std::complex<double>(cos(initialPhase[2]), sin(initialPhase[2])) *
3384 std::sqrt(1.0 / k) * rxFieldPatternPhi * txFieldPatternTheta +
3385 std::complex<double>(cos(initialPhase[3]), sin(initialPhase[3])) *
3386 rxFieldPatternPhi * txFieldPatternPhi;
3387 }
3388 }
3389
3390 // cache the component of the "rxPhaseDiff" terms which depend on the random angle of
3391 // arrivals only
3392 double sinRayZoa = sin(rayZoaRadian[nIndex][mIndex]);
3393 double sinRayAoa = sin(rayAoaRadian[nIndex][mIndex]);
3394 double cosRayAoa = cos(rayAoaRadian[nIndex][mIndex]);
3395 sinCosA[nIndex][mIndex] = sinRayZoa * cosRayAoa;
3396 sinSinA[nIndex][mIndex] = sinRayZoa * sinRayAoa;
3397 cosZoA[nIndex][mIndex] = cos(rayZoaRadian[nIndex][mIndex]);
3398
3399 // cache the component of the "txPhaseDiff" terms which depend on the random angle of
3400 // departure only
3401 double sinRayZod = sin(rayZodRadian[nIndex][mIndex]);
3402 double sinRayAod = sin(rayAodRadian[nIndex][mIndex]);
3403 double cosRayAod = cos(rayAodRadian[nIndex][mIndex]);
3404 sinCosD[nIndex][mIndex] = sinRayZod * cosRayAod;
3405 sinSinD[nIndex][mIndex] = sinRayZod * sinRayAod;
3406 cosZoD[nIndex][mIndex] = cos(rayZodRadian[nIndex][mIndex]);
3407 }
3408 }
3409
3410 // The following for loops computes the channel coefficients
3411 // Keeps track of how many sub-clusters have been added up to now
3412 uint8_t numSubClustersAdded = 0;
3413 for (uint8_t nIndex = 0; nIndex < channelParams->m_reducedClusterNumber; nIndex++)
3414 {
3415 for (size_t uIndex = 0; uIndex < uSize; uIndex++)
3416 {
3417 Vector uLoc = uAntenna->GetElementLocation(uIndex);
3418
3419 for (size_t sIndex = 0; sIndex < sSize; sIndex++)
3420 {
3421 Vector sLoc = sAntenna->GetElementLocation(sIndex);
3422 // Compute the N-2 weakest cluster, assuming 0 slant angle and a
3423 // polarization slant angle configured in the array (7.5-22)
3424 if (nIndex != channelParams->m_cluster1st && nIndex != channelParams->m_cluster2nd)
3425 {
3426 std::complex<double> rays(0, 0);
3427 for (uint8_t mIndex = 0; mIndex < table3gpp->m_raysPerCluster; mIndex++)
3428 {
3429 // lambda_0 is accounted in the antenna spacing uLoc and sLoc.
3430 double rxPhaseDiff =
3431 2 * M_PI *
3432 (sinCosA[nIndex][mIndex] * uLoc.x + sinSinA[nIndex][mIndex] * uLoc.y +
3433 cosZoA[nIndex][mIndex] * uLoc.z);
3434
3435 double txPhaseDiff =
3436 2 * M_PI *
3437 (sinCosD[nIndex][mIndex] * sLoc.x + sinSinD[nIndex][mIndex] * sLoc.y +
3438 cosZoD[nIndex][mIndex] * sLoc.z);
3439 // NOTE Doppler is computed in the CalcBeamformingGain function and is
3440 // simplified to only account for the center angle of each cluster.
3441 rays += raysPreComp[std::make_pair(sAntenna->GetElemPol(sIndex),
3442 uAntenna->GetElemPol(uIndex))](nIndex,
3443 mIndex) *
3444 std::complex<double>(cos(rxPhaseDiff), sin(rxPhaseDiff)) *
3445 std::complex<double>(cos(txPhaseDiff), sin(txPhaseDiff));
3446 }
3447 rays *=
3448 sqrt(channelParams->m_clusterPower[nIndex] / table3gpp->m_raysPerCluster);
3449 hUsn(uIndex, sIndex, nIndex) = rays;
3450 }
3451 else //(7.5-28)
3452 {
3453 std::complex<double> raysSub1(0, 0);
3454 std::complex<double> raysSub2(0, 0);
3455 std::complex<double> raysSub3(0, 0);
3456
3457 for (uint8_t mIndex = 0; mIndex < table3gpp->m_raysPerCluster; mIndex++)
3458 {
3459 // ZML:Just remind me that the angle offsets for the 3 subclusters were not
3460 // generated correctly.
3461 double rxPhaseDiff =
3462 2 * M_PI *
3463 (sinCosA[nIndex][mIndex] * uLoc.x + sinSinA[nIndex][mIndex] * uLoc.y +
3464 cosZoA[nIndex][mIndex] * uLoc.z);
3465
3466 double txPhaseDiff =
3467 2 * M_PI *
3468 (sinCosD[nIndex][mIndex] * sLoc.x + sinSinD[nIndex][mIndex] * sLoc.y +
3469 cosZoD[nIndex][mIndex] * sLoc.z);
3470
3471 std::complex<double> raySub =
3472 raysPreComp[std::make_pair(sAntenna->GetElemPol(sIndex),
3473 uAntenna->GetElemPol(uIndex))](nIndex,
3474 mIndex) *
3475 std::complex<double>(cos(rxPhaseDiff), sin(rxPhaseDiff)) *
3476 std::complex<double>(cos(txPhaseDiff), sin(txPhaseDiff));
3477
3478 switch (mIndex)
3479 {
3480 case 9:
3481 case 10:
3482 case 11:
3483 case 12:
3484 case 17:
3485 case 18:
3486 raysSub2 += raySub;
3487 break;
3488 case 13:
3489 case 14:
3490 case 15:
3491 case 16:
3492 raysSub3 += raySub;
3493 break;
3494 default: // case 1,2,3,4,5,6,7,8,19,20
3495 raysSub1 += raySub;
3496 break;
3497 }
3498 }
3499 raysSub1 *=
3500 sqrt(channelParams->m_clusterPower[nIndex] / table3gpp->m_raysPerCluster);
3501 raysSub2 *=
3502 sqrt(channelParams->m_clusterPower[nIndex] / table3gpp->m_raysPerCluster);
3503 raysSub3 *=
3504 sqrt(channelParams->m_clusterPower[nIndex] / table3gpp->m_raysPerCluster);
3505 hUsn(uIndex, sIndex, nIndex) = raysSub1;
3506 hUsn(uIndex,
3507 sIndex,
3508 channelParams->m_reducedClusterNumber + numSubClustersAdded) = raysSub2;
3509 hUsn(uIndex,
3510 sIndex,
3511 channelParams->m_reducedClusterNumber + numSubClustersAdded + 1) =
3512 raysSub3;
3513 }
3514 }
3515 }
3516 if (nIndex == channelParams->m_cluster1st || nIndex == channelParams->m_cluster2nd)
3517 {
3518 numSubClustersAdded += 2;
3519 }
3520 }
3521
3522 if (channelParams->m_losCondition == ChannelCondition::LOS) //(7.5-29) && (7.5-30)
3523 {
3524 double lambda = 3.0e8 / m_frequency; // the wavelength of the carrier frequency
3525 std::complex<double> phaseDiffDueToDistance(cos(-2 * M_PI * distance3D / lambda),
3526 sin(-2 * M_PI * distance3D / lambda));
3527
3528 const double sinUAngleIncl = sin(uAngle.GetInclination());
3529 const double cosUAngleIncl = cos(uAngle.GetInclination());
3530 const double sinUAngleAz = sin(uAngle.GetAzimuth());
3531 const double cosUAngleAz = cos(uAngle.GetAzimuth());
3532 const double sinSAngleIncl = sin(sAngle.GetInclination());
3533 const double cosSAngleIncl = cos(sAngle.GetInclination());
3534 const double sinSAngleAz = sin(sAngle.GetAzimuth());
3535 const double cosSAngleAz = cos(sAngle.GetAzimuth());
3536
3537 for (size_t uIndex = 0; uIndex < uSize; uIndex++)
3538 {
3539 Vector uLoc = uAntenna->GetElementLocation(uIndex);
3540 double rxPhaseDiff = 2 * M_PI *
3541 (sinUAngleIncl * cosUAngleAz * uLoc.x +
3542 sinUAngleIncl * sinUAngleAz * uLoc.y + cosUAngleIncl * uLoc.z);
3543
3544 for (size_t sIndex = 0; sIndex < sSize; sIndex++)
3545 {
3546 Vector sLoc = sAntenna->GetElementLocation(sIndex);
3547 std::complex<double> ray(0, 0);
3548 double txPhaseDiff =
3549 2 * M_PI *
3550 (sinSAngleIncl * cosSAngleAz * sLoc.x + sinSAngleIncl * sinSAngleAz * sLoc.y +
3551 cosSAngleIncl * sLoc.z);
3552
3553 auto [rxFieldPatternPhi, rxFieldPatternTheta] = uAntenna->GetElementFieldPattern(
3554 Angles(uAngle.GetAzimuth(), uAngle.GetInclination()),
3555 uAntenna->GetElemPol(uIndex));
3556 auto [txFieldPatternPhi, txFieldPatternTheta] = sAntenna->GetElementFieldPattern(
3557 Angles(sAngle.GetAzimuth(), sAngle.GetInclination()),
3558 sAntenna->GetElemPol(sIndex));
3559
3560 ray = (rxFieldPatternTheta * txFieldPatternTheta -
3561 rxFieldPatternPhi * txFieldPatternPhi) *
3562 phaseDiffDueToDistance *
3563 std::complex<double>(cos(rxPhaseDiff), sin(rxPhaseDiff)) *
3564 std::complex<double>(cos(txPhaseDiff), sin(txPhaseDiff));
3565
3566 double kLinear = pow(10, channelParams->m_K_factor / 10.0);
3567 // the LOS path should be attenuated if blockage is enabled.
3568 hUsn(uIndex, sIndex, 0) =
3569 sqrt(1.0 / (kLinear + 1)) * hUsn(uIndex, sIndex, 0) +
3570 sqrt(kLinear / (1 + kLinear)) * ray /
3571 pow(10,
3572 channelParams->m_attenuation_dB[0] / 10.0); //(7.5-30) for tau = tau1
3573 for (size_t nIndex = 1; nIndex < hUsn.GetNumPages(); nIndex++)
3574 {
3575 hUsn(uIndex, sIndex, nIndex) *=
3576 sqrt(1.0 / (kLinear + 1)); //(7.5-30) for tau = tau2...tauN
3577 }
3578 }
3579 }
3580 }
3581
3582 NS_LOG_DEBUG("Husn (sAntenna, uAntenna):" << sAntenna->GetId() << ", " << uAntenna->GetId());
3583 for (size_t cIndex = 0; cIndex < hUsn.GetNumPages(); cIndex++)
3584 {
3585 for (size_t rowIdx = 0; rowIdx < hUsn.GetNumRows(); rowIdx++)
3586 {
3587 for (size_t colIdx = 0; colIdx < hUsn.GetNumCols(); colIdx++)
3588 {
3589 NS_LOG_DEBUG(" " << hUsn(rowIdx, colIdx, cIndex) << ",");
3590 }
3591 }
3592 }
3593
3594 NS_LOG_INFO("size of coefficient matrix (rows, columns, clusters) = ("
3595 << hUsn.GetNumRows() << ", " << hUsn.GetNumCols() << ", " << hUsn.GetNumPages()
3596 << ")");
3597 channelMatrix->m_channel = hUsn;
3598 return channelMatrix;
3599}
3600
3601std::pair<double, double>
3602ThreeGppChannelModel::WrapAngles(double azimuthRad, double inclinationRad)
3603{
3604 inclinationRad = WrapTo2Pi(inclinationRad);
3605 if (inclinationRad > M_PI)
3606 {
3607 // inclination must be in [0, M_PI]
3608 inclinationRad -= M_PI;
3609 azimuthRad += M_PI;
3610 }
3611
3612 azimuthRad = WrapTo2Pi(azimuthRad);
3613
3614 NS_ASSERT_MSG(0 <= inclinationRad && inclinationRad <= M_PI,
3615 "inclinationRad=" << inclinationRad << " not valid, should be in [0, pi]");
3616 NS_ASSERT_MSG(0 <= azimuthRad && azimuthRad <= 2 * M_PI,
3617 "azimuthRad=" << azimuthRad << " not valid, should be in [0, 2*pi]");
3618
3619 return std::make_pair(azimuthRad, inclinationRad);
3620}
3621
3622MatrixBasedChannelModel::DoubleVector
3623ThreeGppChannelModel::CalcAttenuationOfBlockage(
3624 const Ptr<ThreeGppChannelModel::ThreeGppChannelParams> channelParams,
3625 const DoubleVector& clusterAOA,
3626 const DoubleVector& clusterZOA) const
3627{
3628 NS_LOG_FUNCTION(this);
3629
3630 auto clusterNum = clusterAOA.size();
3631
3632 // Initial power attenuation for all clusters to be 0 dB
3633 DoubleVector powerAttenuation(clusterNum, 0);
3634
3635 // step a: the number of non-self blocking blockers is stored in m_numNonSelfBlocking.
3636
3637 // step b:Generate the size and location of each blocker
3638 // generate self blocking (i.e., for blockage from the human body)
3639 // table 7.6.4.1-1 Self-blocking region parameters.
3640 // Defaults: landscape mode
3641 double phiSb = 40;
3642 double xSb = 160;
3643 double thetaSb = 110;
3644 double ySb = 75;
3645 if (m_portraitMode)
3646 {
3647 phiSb = 260;
3648 xSb = 120;
3649 thetaSb = 100;
3650 ySb = 80;
3651 }
3652
3653 // generate or update non-self blocking
3654 if (channelParams->m_nonSelfBlocking.empty()) // generate new blocking regions
3655 {
3656 for (uint16_t blockInd = 0; blockInd < m_numNonSelfBlocking; blockInd++)
3657 {
3658 // draw value from table 7.6.4.1-2 Blocking region parameters
3659 DoubleVector table;
3660 table.push_back(m_normalRv->GetValue()); // phi_k: store the normal RV that will be
3661 // mapped to uniform (0,360) later.
3662 if (m_scenario == "InH-OfficeMixed" || m_scenario == "InH-OfficeOpen")
3663 {
3664 table.push_back(m_uniformRv->GetValue(15, 45)); // x_k
3665 table.push_back(90); // Theta_k
3666 table.push_back(m_uniformRv->GetValue(5, 15)); // y_k
3667 table.push_back(2); // r
3668 }
3669 else
3670 {
3671 table.push_back(m_uniformRv->GetValue(5, 15)); // x_k
3672 table.push_back(90); // Theta_k
3673 table.push_back(5); // y_k
3674 table.push_back(10); // r
3675 }
3676 channelParams->m_nonSelfBlocking.push_back(table);
3677 }
3678 }
3679 else
3680 {
3681 double deltaX = sqrt(pow(channelParams->m_preLocUT.x - channelParams->m_locUT.x, 2) +
3682 pow(channelParams->m_preLocUT.y - channelParams->m_locUT.y, 2));
3683 // if deltaX and speed are both 0, the autocorrelation is 1, skip updating
3684 if (deltaX > 1e-6 || m_blockerSpeed > 1e-6)
3685 {
3686 double corrDis;
3687 // draw value from table 7.6.4.1-4: Spatial correlation distance for different
3688 // m_scenarios.
3689 if (m_scenario == "InH-OfficeMixed" || m_scenario == "InH-OfficeOpen")
3690 {
3691 // InH, correlation distance = 5;
3692 corrDis = 5;
3693 }
3694 else
3695 {
3696 if (channelParams->m_o2iCondition == ChannelCondition::O2I) // outdoor to indoor
3697 {
3698 corrDis = 5;
3699 }
3700 else // LOS or NLOS
3701 {
3702 corrDis = 10;
3703 }
3704 }
3705 double R;
3706 if (m_blockerSpeed > 1e-6) // speed not equal to 0
3707 {
3708 double corrT = corrDis / m_blockerSpeed;
3709 R = exp(-1 * (deltaX / corrDis +
3710 (Now().GetSeconds() - channelParams->m_generatedTime.GetSeconds()) /
3711 corrT));
3712 }
3713 else
3714 {
3715 R = exp(-1 * (deltaX / corrDis));
3716 }
3717
3718 NS_LOG_INFO("Distance change:"
3719 << deltaX << " Speed:" << m_blockerSpeed << " Time difference:"
3720 << Now().GetSeconds() - channelParams->m_generatedTime.GetSeconds()
3721 << " correlation:" << R);
3722
3723 // In order to generate correlated uniform random variables, we first generate
3724 // correlated normal random variables and map the normal RV to uniform RV. Notice the
3725 // correlation will change if the RV is transformed from normal to uniform. To
3726 // compensate the distortion, the correlation of the normal RV is computed such that the
3727 // uniform RV would have the desired correlation when transformed from normal RV.
3728
3729 // The following formula was obtained from MATLAB numerical simulation.
3730
3731 if (R * R * (-0.069) + R * 1.074 - 0.002 <
3732 1) // transform only when the correlation of normal RV is smaller than 1
3733 {
3734 R = R * R * (-0.069) + R * 1.074 - 0.002;
3735 }
3736 for (uint16_t blockInd = 0; blockInd < m_numNonSelfBlocking; blockInd++)
3737 {
3738 // Generate a new correlated normal RV with the following formula
3739 channelParams->m_nonSelfBlocking[blockInd][PHI_INDEX] =
3740 R * channelParams->m_nonSelfBlocking[blockInd][PHI_INDEX] +
3741 sqrt(1 - R * R) * m_normalRv->GetValue();
3742 }
3743 }
3744 }
3745
3746 // step c: Determine the attenuation of each blocker due to blockers
3747 for (std::size_t cInd = 0; cInd < clusterNum; cInd++)
3748 {
3749 NS_ASSERT_MSG(clusterAOA[cInd] >= 0 && clusterAOA[cInd] <= 360,
3750 "the AOA should be the range of [0,360]");
3751 NS_ASSERT_MSG(clusterZOA[cInd] >= 0 && clusterZOA[cInd] <= 180,
3752 "the ZOA should be the range of [0,180]");
3753
3754 // check self blocking
3755 NS_LOG_INFO("AOA=" << clusterAOA[cInd] << " Block Region[" << phiSb - xSb / 2.0 << ","
3756 << phiSb + xSb / 2.0 << "]");
3757 NS_LOG_INFO("ZOA=" << clusterZOA[cInd] << " Block Region[" << thetaSb - ySb / 2.0 << ","
3758 << thetaSb + ySb / 2.0 << "]");
3759 if (std::abs(clusterAOA[cInd] - phiSb) < (xSb / 2.0) &&
3760 std::abs(clusterZOA[cInd] - thetaSb) < (ySb / 2.0))
3761 {
3762 powerAttenuation[cInd] += 30; // attenuate by 30 dB.
3763 NS_LOG_INFO("Cluster[" << +cInd
3764 << "] is blocked by self blocking region and reduce 30 dB power,"
3765 "the attenuation is ["
3766 << powerAttenuation[cInd] << " dB]");
3767 }
3768
3769 // check non-self blocking
3770 for (uint16_t blockInd = 0; blockInd < m_numNonSelfBlocking; blockInd++)
3771 {
3772 // The normal RV is transformed to uniform RV with the desired correlation.
3773 double phiK =
3774 (0.5 * erfc(-1 * channelParams->m_nonSelfBlocking[blockInd][PHI_INDEX] / sqrt(2))) *
3775 360;
3776 while (phiK > 360)
3777 {
3778 phiK -= 360;
3779 }
3780
3781 while (phiK < 0)
3782 {
3783 phiK += 360;
3784 }
3785
3786 double xK = channelParams->m_nonSelfBlocking[blockInd][X_INDEX];
3787 double thetaK = channelParams->m_nonSelfBlocking[blockInd][THETA_INDEX];
3788 double yK = channelParams->m_nonSelfBlocking[blockInd][Y_INDEX];
3789
3790 NS_LOG_INFO("AOA=" << clusterAOA[cInd] << " Block Region[" << phiK - xK << ","
3791 << phiK + xK << "]");
3792 NS_LOG_INFO("ZOA=" << clusterZOA[cInd] << " Block Region[" << thetaK - yK << ","
3793 << thetaK + yK << "]");
3794
3795 if (std::abs(clusterAOA[cInd] - phiK) < (xK) &&
3796 std::abs(clusterZOA[cInd] - thetaK) < (yK))
3797 {
3798 double A1 = clusterAOA[cInd] - (phiK + xK / 2.0); //(7.6-24)
3799 double A2 = clusterAOA[cInd] - (phiK - xK / 2.0); //(7.6-25)
3800 double Z1 = clusterZOA[cInd] - (thetaK + yK / 2.0); //(7.6-26)
3801 double Z2 = clusterZOA[cInd] - (thetaK - yK / 2.0); //(7.6-27)
3802 int signA1;
3803 int signA2;
3804 int signZ1;
3805 int signZ2;
3806 // draw sign for the above parameters according to table 7.6.4.1-3 Description of
3807 // signs
3808 if (xK / 2.0 < clusterAOA[cInd] - phiK && clusterAOA[cInd] - phiK <= xK)
3809 {
3810 signA1 = -1;
3811 }
3812 else
3813 {
3814 signA1 = 1;
3815 }
3816 if (-1 * xK < clusterAOA[cInd] - phiK && clusterAOA[cInd] - phiK <= -1 * xK / 2.0)
3817 {
3818 signA2 = -1;
3819 }
3820 else
3821 {
3822 signA2 = 1;
3823 }
3824
3825 if (yK / 2.0 < clusterZOA[cInd] - thetaK && clusterZOA[cInd] - thetaK <= yK)
3826 {
3827 signZ1 = -1;
3828 }
3829 else
3830 {
3831 signZ1 = 1;
3832 }
3833 if (-1 * yK < clusterZOA[cInd] - thetaK &&
3834 clusterZOA[cInd] - thetaK <= -1 * yK / 2.0)
3835 {
3836 signZ2 = -1;
3837 }
3838 else
3839 {
3840 signZ2 = 1;
3841 }
3842 double lambda = 3e8 / m_frequency;
3843 double fA1 =
3844 atan(signA1 * M_PI / 2.0 *
3845 sqrt(M_PI / lambda * channelParams->m_nonSelfBlocking[blockInd][R_INDEX] *
3846 (1.0 / cos(DegreesToRadians(A1)) - 1))) /
3847 M_PI; //(7.6-23)
3848 double fA2 =
3849 atan(signA2 * M_PI / 2.0 *
3850 sqrt(M_PI / lambda * channelParams->m_nonSelfBlocking[blockInd][R_INDEX] *
3851 (1.0 / cos(DegreesToRadians(A2)) - 1))) /
3852 M_PI;
3853 double fZ1 =
3854 atan(signZ1 * M_PI / 2.0 *
3855 sqrt(M_PI / lambda * channelParams->m_nonSelfBlocking[blockInd][R_INDEX] *
3856 (1.0 / cos(DegreesToRadians(Z1)) - 1))) /
3857 M_PI;
3858 double fZ2 =
3859 atan(signZ2 * M_PI / 2.0 *
3860 sqrt(M_PI / lambda * channelParams->m_nonSelfBlocking[blockInd][R_INDEX] *
3861 (1.0 / cos(DegreesToRadians(Z2)) - 1))) /
3862 M_PI;
3863 double lDb = -20 * log10(1 - (fA1 + fA2) * (fZ1 + fZ2)); //(7.6-22)
3864 powerAttenuation[cInd] += lDb;
3865 NS_LOG_INFO("Cluster[" << +cInd << "] is blocked by no-self blocking, the loss is ["
3866 << lDb << "] dB");
3867 }
3868 }
3869 }
3870 return powerAttenuation;
3871}
3872
3873int64_t
3874ThreeGppChannelModel::AssignStreams(int64_t stream)
3875{
3876 NS_LOG_FUNCTION(this << stream);
3877 m_normalRv->SetStream(stream);
3878 m_uniformRv->SetStream(stream + 1);
3879 m_uniformRvShuffle->SetStream(stream + 2);
3880 m_uniformRvDoppler->SetStream(stream + 3);
3881 return 4;
3882}
3883
3884} // namespace ns3
ns3::Angles
Class holding the azimuth and inclination angles of spherical coordinates.
Definition angles.h:107
ns3::BooleanValue
AttributeValue implementation for Boolean.
Definition boolean.h:26
ns3::DoubleValue
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition double.h:31
ns3::IntegerValue
Hold a signed integer type.
Definition integer.h:34
ns3::MatrixBasedChannelModel
This is an interface for a channel model that can be described by a channel matrix,...
Definition matrix-based-channel-model.h:35
ns3::MatrixBasedChannelModel::DoubleVector
std::vector< double > DoubleVector
Type definition for vectors of doubles.
Definition matrix-based-channel-model.h:43
ns3::MatrixBasedChannelModel::Complex2DVector
ComplexMatrixArray Complex2DVector
Create an alias for 2D complex vectors.
Definition matrix-based-channel-model.h:51
ns3::MatrixBasedChannelModel::Double2DVector
std::vector< DoubleVector > Double2DVector
Type definition for matrices of doubles.
Definition matrix-based-channel-model.h:46
ns3::MatrixBasedChannelModel::GetKey
static uint64_t GetKey(uint32_t a, uint32_t b)
Generate a unique value for the pair of unsigned integer of 32 bits, where the order does not matter,...
Definition matrix-based-channel-model.h:210
ns3::Node
A network Node.
Definition node.h:46
ns3::Node::GetId
uint32_t GetId() const
Definition node.cc:106
ns3::PointerValue
AttributeValue implementation for Pointer.
Definition pointer.h:37
ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition ptr.h:66
ns3::Simulator::Now
static Time Now()
Return the current simulation virtual time.
Definition simulator.cc:197
ns3::StringValue
Hold variables of type string.
Definition string.h:45
ns3::ThreeGppChannelModel::CalcAttenuationOfBlockage
DoubleVector CalcAttenuationOfBlockage(const Ptr< ThreeGppChannelModel::ThreeGppChannelParams > channelParams, const DoubleVector &clusterAOA, const DoubleVector &clusterZOA) const
Applies the blockage model A described in 3GPP TR 38.901.
Definition three-gpp-channel-model.cc:3623
ns3::ThreeGppChannelModel::AssignStreams
int64_t AssignStreams(int64_t stream)
Assign a fixed random variable stream number to the random variables used by this model.
Definition three-gpp-channel-model.cc:3874
ns3::ThreeGppChannelModel::AntennaSetupChanged
bool AntennaSetupChanged(Ptr< const PhasedArrayModel > aAntenna, Ptr< const PhasedArrayModel > bAntenna, Ptr< const ChannelMatrix > channelMatrix)
Check if the channel matrix has to be updated due to changes in the number of antenna ports.
Definition three-gpp-channel-model.cc:2457
ns3::ThreeGppChannelModel::m_portraitMode
bool m_portraitMode
true if portrait mode, false if landscape
Definition three-gpp-channel-model.h:374
ns3::ThreeGppChannelModel::ChannelParamsNeedsUpdate
bool ChannelParamsNeedsUpdate(Ptr< const ThreeGppChannelParams > channelParams, Ptr< const ChannelCondition > channelCondition) const
Check if the channel params has to be updated.
Definition three-gpp-channel-model.cc:2423
ns3::ThreeGppChannelModel::m_normalRv
Ptr< NormalRandomVariable > m_normalRv
normal random variable
Definition three-gpp-channel-model.h:360
ns3::ThreeGppChannelModel::Y_INDEX
static const uint8_t Y_INDEX
index of the Y value in the m_nonSelfBlocking array
Definition three-gpp-channel-model.h:381
ns3::ThreeGppChannelModel::m_blockage
bool m_blockage
enables the blockage model A
Definition three-gpp-channel-model.h:372
ns3::ThreeGppChannelModel::GetParams
Ptr< const ChannelParams > GetParams(Ptr< const MobilityModel > aMob, Ptr< const MobilityModel > bMob) const override
Looks for the channel params associated to the aMob and bMob pair in m_channelParamsMap.
Definition three-gpp-channel-model.cc:2562
ns3::ThreeGppChannelModel::~ThreeGppChannelModel
~ThreeGppChannelModel() override
Destructor.
Definition three-gpp-channel-model.cc:1080
ns3::ThreeGppChannelModel::ChannelMatrixNeedsUpdate
bool ChannelMatrixNeedsUpdate(Ptr< const ThreeGppChannelParams > channelParams, Ptr< const ChannelMatrix > channelMatrix)
Check if the channel matrix has to be updated (it needs update when the channel params generation tim...
Definition three-gpp-channel-model.cc:2450
ns3::ThreeGppChannelModel::THETA_INDEX
static const uint8_t THETA_INDEX
index of the THETA value in the m_nonSelfBlocking array
Definition three-gpp-channel-model.h:379
ns3::ThreeGppChannelModel::m_channelParamsMap
std::unordered_map< uint64_t, Ptr< ThreeGppChannelParams > > m_channelParamsMap
map containing the common channel parameters per pair of nodes, the key of this map is reciprocal and...
Definition three-gpp-channel-model.h:352
ns3::ThreeGppChannelModel::WrapAngles
static std::pair< double, double > WrapAngles(double azimuthRad, double inclinationRad)
Wrap an (azimuth, inclination) angle pair in a valid range.
Definition three-gpp-channel-model.cc:3602
ns3::ThreeGppChannelModel::m_blockerSpeed
double m_blockerSpeed
the blocker speed
Definition three-gpp-channel-model.h:375
ns3::ThreeGppChannelModel::GetChannel
Ptr< const ChannelMatrix > GetChannel(Ptr< const MobilityModel > aMob, Ptr< const MobilityModel > bMob, Ptr< const PhasedArrayModel > aAntenna, Ptr< const PhasedArrayModel > bAntenna) override
Looks for the channel matrix associated to the aMob and bMob pair in m_channelMatrixMap.
Definition three-gpp-channel-model.cc:2473
ns3::ThreeGppChannelModel::SetFrequency
void SetFrequency(double f)
Sets the center frequency of the model.
Definition three-gpp-channel-model.cc:1180
ns3::ThreeGppChannelModel::m_channelMatrixMap
std::unordered_map< uint64_t, Ptr< ChannelMatrix > > m_channelMatrixMap
map containing the channel realizations per pair of PhasedAntennaArray instances, the key of this map...
Definition three-gpp-channel-model.h:348
ns3::ThreeGppChannelModel::m_uniformRv
Ptr< UniformRandomVariable > m_uniformRv
uniform random variable
Definition three-gpp-channel-model.h:359
ns3::ThreeGppChannelModel::DoDispose
void DoDispose() override
Destructor implementation.
Definition three-gpp-channel-model.cc:1086
ns3::ThreeGppChannelModel::SetScenario
void SetScenario(const std::string &scenario)
Sets the propagation scenario.
Definition three-gpp-channel-model.cc:1196
ns3::ThreeGppChannelModel::SetChannelConditionModel
void SetChannelConditionModel(Ptr< ChannelConditionModel > model)
Set the channel condition model.
Definition three-gpp-channel-model.cc:1166
ns3::ThreeGppChannelModel::m_uniformRvDoppler
Ptr< UniformRandomVariable > m_uniformRvDoppler
uniform random variable, used to compute the additional Doppler contribution
Definition three-gpp-channel-model.h:368
ns3::ThreeGppChannelModel::m_numNonSelfBlocking
uint16_t m_numNonSelfBlocking
number of non-self-blocking regions
Definition three-gpp-channel-model.h:373
ns3::ThreeGppChannelModel::GetThreeGppTable
Ptr< const ParamsTable > GetThreeGppTable(Ptr< const ChannelCondition > channelCondition, double hBS, double hUT, double distance2D) const
Get the parameters needed to apply the channel generation procedure.
ns3::ThreeGppChannelModel::GetScenario
std::string GetScenario() const
Returns the propagation scenario.
Definition three-gpp-channel-model.cc:1211
ns3::ThreeGppChannelModel::GetNewChannel
virtual Ptr< ChannelMatrix > GetNewChannel(Ptr< const ThreeGppChannelParams > channelParams, Ptr< const ParamsTable > table3gpp, const Ptr< const MobilityModel > sMob, const Ptr< const MobilityModel > uMob, Ptr< const PhasedArrayModel > sAntenna, Ptr< const PhasedArrayModel > uAntenna) const
Compute the channel matrix between two nodes a and b, and their antenna arrays aAntenna and bAntenna ...
Definition three-gpp-channel-model.cc:3232
ns3::ThreeGppChannelModel::PHI_INDEX
static const uint8_t PHI_INDEX
index of the PHI value in the m_nonSelfBlocking array
Definition three-gpp-channel-model.h:377
ns3::ThreeGppChannelModel::m_frequency
double m_frequency
the operating frequency
Definition three-gpp-channel-model.h:356
ns3::ThreeGppChannelModel::m_vScatt
double m_vScatt
value used to compute the additional Doppler contribution for the delayed paths
Definition three-gpp-channel-model.h:366
ns3::ThreeGppChannelModel::GetChannelConditionModel
Ptr< ChannelConditionModel > GetChannelConditionModel() const
Get the associated channel condition model.
Definition three-gpp-channel-model.cc:1173
ns3::ThreeGppChannelModel::m_channelConditionModel
Ptr< ChannelConditionModel > m_channelConditionModel
the channel condition model
Definition three-gpp-channel-model.h:358
ns3::ThreeGppChannelModel::m_scenario
std::string m_scenario
the 3GPP scenario
Definition three-gpp-channel-model.h:357
ns3::ThreeGppChannelModel::R_INDEX
static const uint8_t R_INDEX
index of the R value in the m_nonSelfBlocking array
Definition three-gpp-channel-model.h:382
ns3::ThreeGppChannelModel::GetTypeId
static TypeId GetTypeId()
Get the type ID.
Definition three-gpp-channel-model.cc:1099
ns3::ThreeGppChannelModel::GenerateChannelParameters
Ptr< ThreeGppChannelParams > GenerateChannelParameters(const Ptr< const ChannelCondition > channelCondition, const Ptr< const ParamsTable > table3gpp, const Ptr< const MobilityModel > aMob, const Ptr< const MobilityModel > bMob) const
Prepare 3gpp channel parameters among the nodes a and b.
Definition three-gpp-channel-model.cc:2582
ns3::ThreeGppChannelModel::GetFrequency
double GetFrequency() const
Returns the center frequency.
Definition three-gpp-channel-model.cc:1189
ns3::ThreeGppChannelModel::m_updatePeriod
Time m_updatePeriod
the channel update period
Definition three-gpp-channel-model.h:355
ns3::ThreeGppChannelModel::X_INDEX
static const uint8_t X_INDEX
index of the X value in the m_nonSelfBlocking array
Definition three-gpp-channel-model.h:378
ns3::ThreeGppChannelModel::m_uniformRvShuffle
Ptr< UniformRandomVariable > m_uniformRvShuffle
uniform random variable used to shuffle array in GetNewChannel
Definition three-gpp-channel-model.h:362
ns3::Time::GetSeconds
double GetSeconds() const
Get an approximation of the time stored in this instance in the indicated unit.
Definition nstime.h:392
ns3::Time::NS
@ NS
nanosecond
Definition nstime.h:108
ns3::Time::IsZero
bool IsZero() const
Exactly equivalent to t == 0.
Definition nstime.h:304
ns3::TimeValue
AttributeValue implementation for Time.
Definition nstime.h:1431
ns3::TypeId
a unique identifier for an interface.
Definition type-id.h:49
ns3::TypeId::SetGroupName
TypeId SetGroupName(std::string groupName)
Set the group name.
Definition type-id.cc:1009
ns3::TypeId::SetParent
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition type-id.cc:1001
NS_ASSERT
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
Definition assert.h:55
NS_ASSERT_MSG
#define NS_ASSERT_MSG(condition, message)
At runtime, in debugging builds, if this condition is not true, the program prints the message to out...
Definition assert.h:75
ns3::MakeTimeChecker
Ptr< const AttributeChecker > MakeTimeChecker()
Helper to make an unbounded Time checker.
Definition nstime.h:1452
NS_FATAL_ERROR
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition fatal-error.h:168
NS_LOG_UNCOND
#define NS_LOG_UNCOND(msg)
Output the requested message unconditionally.
Definition log-macros-enabled.h:253
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition log.h:191
NS_LOG_DEBUG
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition log.h:257
NS_LOG_FUNCTION
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
Definition log-macros-enabled.h:229
NS_LOG_WARN
#define NS_LOG_WARN(msg)
Use NS_LOG to output a message of level LOG_WARN.
Definition log.h:250
NS_LOG_INFO
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition log.h:264
NS_OBJECT_ENSURE_REGISTERED
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition object-base.h:35
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
ns3::Now
Time Now()
create an ns3::Time instance which contains the current simulation time.
Definition simulator.cc:294
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::sqrtC_office_LOS
static constexpr std::array< std::array< double, 7 >, 7 > sqrtC_office_LOS
The square root matrix for Indoor-Office LOS, which is generated using the Cholesky decomposition acc...
Definition three-gpp-channel-model.cc:214
ns3::MakeBooleanChecker
Ptr< const AttributeChecker > MakeBooleanChecker()
Definition boolean.cc:113
ns3::sqrtC_NTN_Rural_NLOS_S
static const std::map< int, std::array< std::array< double, 6 >, 6 > > sqrtC_NTN_Rural_NLOS_S
The square root matrix for NTN Rural NLOS S Band, which is generated using the Cholesky decomposition...
Definition three-gpp-channel-model.cc:452
ns3::MakeIntegerAccessor
Ptr< const AttributeAccessor > MakeIntegerAccessor(T1 a1)
Definition integer.h:35
ns3::Table3gppParams
Table3gppParams
The enumerator used for code clarity when performing parameter assignment in GetThreeGppTable.
Definition three-gpp-channel-model.cc:635
ns3::NTNUrbanLOS
static const std::map< std::string, std::map< int, std::array< float, 22 > > > NTNUrbanLOS
The nested map containing the 3GPP value tables for the NTN Urban LOS scenario.
Definition three-gpp-channel-model.cc:768
ns3::sqrtC_NTN_Suburban_LOS
static constexpr std::array< std::array< double, 7 >, 7 > sqrtC_NTN_Suburban_LOS
The square root matrix for NTN Suburban LOS, which is generated using the Cholesky decomposition acco...
Definition three-gpp-channel-model.cc:397
ns3::DEG2RAD
static constexpr double DEG2RAD
Conversion factor: degrees to radians.
Definition three-gpp-channel-model.cc:38
ns3::sqrtC_UMi_NLOS
static constexpr std::array< std::array< double, 6 >, 6 > sqrtC_UMi_NLOS
The square root matrix for UMi NLOS, which is generated using the Cholesky decomposition according to...
Definition three-gpp-channel-model.cc:180
ns3::sqrtC_UMa_LOS
static constexpr std::array< std::array< double, 7 >, 7 > sqrtC_UMa_LOS
The square root matrix for UMa LOS, which is generated using the Cholesky decomposition according to ...
Definition three-gpp-channel-model.cc:108
ns3::sqrtC_office_NLOS
static constexpr std::array< std::array< double, 6 >, 6 > sqrtC_office_NLOS
The square root matrix for Indoor-Office NLOS, which is generated using the Cholesky decomposition ac...
Definition three-gpp-channel-model.cc:233
ns3::MakeTimeAccessor
Ptr< const AttributeAccessor > MakeTimeAccessor(T1 a1)
Definition nstime.h:1432
ns3::NTNUrbanNLOS
static const std::map< std::string, std::map< int, std::array< float, 22 > > > NTNUrbanNLOS
The nested map containing the 3GPP value tables for the NTN Urban NLOS scenario.
Definition three-gpp-channel-model.cc:819
ns3::sqrtC_UMa_NLOS
static constexpr std::array< std::array< double, 6 >, 6 > sqrtC_UMa_NLOS
The square root matrix for UMa NLOS, which is generated using the Cholesky decomposition according to...
Definition three-gpp-channel-model.cc:127
ns3::MakePointerAccessor
Ptr< const AttributeAccessor > MakePointerAccessor(T1 a1)
Definition pointer.h:248
ns3::sqrtC_RMa_LOS
static constexpr std::array< std::array< double, 7 >, 7 > sqrtC_RMa_LOS
The square root matrix for RMa LOS, which is generated using the Cholesky decomposition according to ...
Definition three-gpp-channel-model.cc:55
ns3::sqrtC_NTN_Rural_LOS
static constexpr std::array< std::array< double, 7 >, 7 > sqrtC_NTN_Rural_LOS
The square root matrix for NTN Rural LOS, which is generated using the Cholesky decomposition accordi...
Definition three-gpp-channel-model.cc:432
ns3::sqrtC_NTN_DenseUrban_NLOS
static constexpr std::array< std::array< double, 6 >, 6 > sqrtC_NTN_DenseUrban_NLOS
The square root matrix for NTN Dense Urban NLOS, which is generated using the Cholesky decomposition ...
Definition three-gpp-channel-model.cc:268
ns3::sqrtC_NTN_Urban_LOS
static constexpr std::array< std::array< double, 7 >, 7 > sqrtC_NTN_Urban_LOS
The square root matrix for NTN Urban LOS, which is generated using the Cholesky decomposition accordi...
Definition three-gpp-channel-model.cc:285
ns3::Shuffle
void Shuffle(RND_ACCESS_ITER first, RND_ACCESS_ITER last, Ptr< UniformRandomVariable > rv)
Shuffle the elements in the range first to last.
Definition shuffle.h:48
ns3::NTNSuburbanLOS
static const std::map< std::string, std::map< int, std::array< float, 22 > > > NTNSuburbanLOS
The nested map containing the 3GPP value tables for the NTN Suburban LOS scenario.
Definition three-gpp-channel-model.cc:870
ns3::NTNRuralNLOS
static const std::map< std::string, std::map< int, std::array< float, 22 > > > NTNRuralNLOS
The nested map containing the 3GPP value tables for the NTN Rural NLOS scenario The outer key specifi...
Definition three-gpp-channel-model.cc:1023
ns3::NTNDenseUrbanLOS
static const std::map< std::string, std::map< int, std::array< float, 22 > > > NTNDenseUrbanLOS
The nested map containing the 3GPP value tables for the NTN Dense Urban LOS scenario.
Definition three-gpp-channel-model.cc:666
ns3::sqrtC_UMa_O2I
static constexpr std::array< std::array< double, 6 >, 6 > sqrtC_UMa_O2I
The square root matrix for UMa O2I, which is generated using the Cholesky decomposition according to ...
Definition three-gpp-channel-model.cc:144
ns3::sqrtC_RMa_NLOS
static constexpr std::array< std::array< double, 6 >, 6 > sqrtC_RMa_NLOS
The square root matrix for RMa NLOS, which is generated using the Cholesky decomposition according to...
Definition three-gpp-channel-model.cc:74
ns3::DegreesToRadians
double DegreesToRadians(double degrees)
converts degrees to radians
Definition angles.cc:28
ns3::sqrtC_NTN_Rural_NLOS_Ka
static const std::map< int, std::array< std::array< double, 6 >, 6 > > sqrtC_NTN_Rural_NLOS_Ka
The square root matrix for NTN Rural NLOS Ka Band, which is generated using the Cholesky decompositio...
Definition three-gpp-channel-model.cc:547
ns3::MakeStringChecker
Ptr< const AttributeChecker > MakeStringChecker()
Definition string.cc:19
ns3::offSetAlpha
static constexpr std::array< double, 20 > offSetAlpha
The ray offset angles within a cluster, given for rms angle spread normalized to 1.
Definition three-gpp-channel-model.cc:42
ns3::MakeStringAccessor
Ptr< const AttributeAccessor > MakeStringAccessor(T1 a1)
Definition string.h:46
ns3::MakeBooleanAccessor
Ptr< const AttributeAccessor > MakeBooleanAccessor(T1 a1)
Definition boolean.h:70
ns3::MakeDoubleAccessor
Ptr< const AttributeAccessor > MakeDoubleAccessor(T1 a1)
Definition double.h:32
ns3::sqrtC_RMa_O2I
static constexpr std::array< std::array< double, 6 >, 6 > sqrtC_RMa_O2I
The square root matrix for RMa O2I, which is generated using the Cholesky decomposition according to ...
Definition three-gpp-channel-model.cc:91
ns3::NTNDenseUrbanNLOS
static const std::map< std::string, std::map< int, std::array< float, 22 > > > NTNDenseUrbanNLOS
The nested map containing the 3GPP value tables for the NTN Dense Urban NLOS scenario.
Definition three-gpp-channel-model.cc:717
ns3::sqrtC_NTN_DenseUrban_LOS
static constexpr std::array< std::array< double, 7 >, 7 > sqrtC_NTN_DenseUrban_LOS
The square root matrix for NTN Dense Urban LOS, which is generated using the Cholesky decomposition a...
Definition three-gpp-channel-model.cc:250
ns3::sqrtC_UMi_LOS
static constexpr std::array< std::array< double, 7 >, 7 > sqrtC_UMi_LOS
The square root matrix for UMi LOS, which is generated using the Cholesky decomposition according to ...
Definition three-gpp-channel-model.cc:161
ns3::sqrtC_NTN_Suburban_NLOS
static constexpr std::array< std::array< double, 6 >, 6 > sqrtC_NTN_Suburban_NLOS
The square root matrix for NTN Suburban NLOS, which is generated using the Cholesky decomposition acc...
Definition three-gpp-channel-model.cc:415
ns3::WrapTo2Pi
double WrapTo2Pi(double a)
Wrap angle in [0, 2*M_PI)
Definition angles.cc:106
ns3::NTNSuburbanNLOS
static const std::map< std::string, std::map< int, std::array< float, 22 > > > NTNSuburbanNLOS
The nested map containing the 3GPP value tables for the NTN Suburban NLOS scenario.
Definition three-gpp-channel-model.cc:921
ns3::sqrtC_UMi_O2I
static constexpr std::array< std::array< double, 6 >, 6 > sqrtC_UMi_O2I
The square root matrix for UMi O2I, which is generated using the Cholesky decomposition according to ...
Definition three-gpp-channel-model.cc:197
ns3::sqrtC_NTN_Urban_NLOS
static const std::map< int, std::array< std::array< double, 6 >, 6 > > sqrtC_NTN_Urban_NLOS
The square root matrix for NTN Urban NLOS, which is generated using the Cholesky decomposition accord...
Definition three-gpp-channel-model.cc:305
ns3::RadiansToDegrees
double RadiansToDegrees(double radians)
converts radians to degrees
Definition angles.cc:34
ns3::NTNRuralLOS
static const std::map< std::string, std::map< int, std::array< float, 22 > > > NTNRuralLOS
The nested map containing the 3GPP value tables for the NTN Rural LOS scenario.
Definition three-gpp-channel-model.cc:972