A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
three-gpp-channel-model.h
Go to the documentation of this file.
1/*
2 * Copyright (c) 2015, NYU WIRELESS, Tandon School of Engineering,
3 * New York University
4 * Copyright (c) 2019 SIGNET Lab, Department of Information Engineering,
5 * University of Padova
6 *
7 * SPDX-License-Identifier: GPL-2.0-only
8 */
9
10#ifndef THREE_GPP_CHANNEL_H
11#define THREE_GPP_CHANNEL_H
12
14
15#include "ns3/angles.h"
16#include "ns3/deprecated.h"
17#include <ns3/boolean.h>
18#include <ns3/channel-condition-model.h>
19
20#include <complex.h>
21#include <unordered_map>
22
23namespace ns3
24{
25
26class MobilityModel;
27
28/**
29 * \ingroup spectrum
30 * \brief Channel Matrix Generation following 3GPP TR 38.901
31 *
32 * The class implements the channel matrix generation procedure
33 * described in 3GPP TR 38.901.
34 *
35 * \see GetChannel
36 */
38{
39 public:
40 /**
41 * Constructor
42 */
44
45 /**
46 * Destructor
47 */
48 ~ThreeGppChannelModel() override;
49
50 void DoDispose() override;
51
52 /**
53 * Get the type ID
54 * \return the object TypeId
55 */
56 static TypeId GetTypeId();
57
58 /**
59 * Set the channel condition model
60 * \param model a pointer to the ChannelConditionModel object
61 */
63
64 /**
65 * Get the associated channel condition model
66 * \return a pointer to the ChannelConditionModel object
67 */
69
70 /**
71 * Sets the center frequency of the model
72 * \param f the center frequency in Hz
73 */
74 void SetFrequency(double f);
75
76 /**
77 * Returns the center frequency
78 * \return the center frequency in Hz
79 */
80 double GetFrequency() const;
81
82 /**
83 * Sets the propagation scenario
84 * \param scenario the propagation scenario
85 */
86 void SetScenario(const std::string& scenario);
87
88 /**
89 * Returns the propagation scenario
90 * \return the propagation scenario
91 */
92 std::string GetScenario() const;
93
94 /**
95 * Looks for the channel matrix associated to the aMob and bMob pair in m_channelMatrixMap.
96 * If found, it checks if it has to be updated. If not found or if it has to
97 * be updated, it generates a new uncorrelated channel matrix using the
98 * method GetNewChannel and updates m_channelMap.
99 *
100 * \param aMob mobility model of the a device
101 * \param bMob mobility model of the b device
102 * \param aAntenna antenna of the a device
103 * \param bAntenna antenna of the b device
104 * \return the channel matrix
105 */
109 Ptr<const PhasedArrayModel> bAntenna) override;
110
111 /**
112 * Looks for the channel params associated to the aMob and bMob pair in
113 * m_channelParamsMap. If not found it will return a nullptr.
114 *
115 * \param aMob mobility model of the a device
116 * \param bMob mobility model of the b device
117 * \return the channel params
118 */
120 Ptr<const MobilityModel> bMob) const override;
121 /**
122 * \brief Assign a fixed random variable stream number to the random variables
123 * used by this model.
124 *
125 * \param stream first stream index to use
126 * \return the number of stream indices assigned by this model
127 */
128 int64_t AssignStreams(int64_t stream);
129
130 protected:
131 /**
132 * Wrap an (azimuth, inclination) angle pair in a valid range.
133 * Specifically, inclination must be in [0, M_PI] and azimuth in [0, 2*M_PI).
134 * If the inclination angle is outside of its range, the azimuth angle is
135 * rotated by M_PI.
136 * This methods aims specifically at solving the problem of generating angles at
137 * the boundaries of the angle domain, specifically, generating angle distributions
138 * close to inclinationRad=0 and inclinationRad=M_PI.
139 *
140 * \param azimuthRad the azimuth angle in radians
141 * \param inclinationRad the inclination angle in radians
142 * \return the wrapped (azimuth, inclination) angle pair in radians
143 */
144 static std::pair<double, double> WrapAngles(double azimuthRad, double inclinationRad);
145
146 /**
147 * \brief Shuffle the elements of a simple sequence container of type double
148 * \param first Pointer to the first element among the elements to be shuffled
149 * \param last Pointer to the last element among the elements to be shuffled
150 */
151 void Shuffle(double* first, double* last) const;
152
153 /**
154 * Extends the struct ChannelParams by including information that is used
155 * within the ThreeGppChannelModel class
156 */
158 {
160 m_losCondition; //!< contains the information about the LOS state of the channel
162 m_o2iCondition; //!< contains the information about the O2I state of the channel
163 // TODO these are not currently used, they have to be correctly set when including the
164 // spatial consistent update procedure
165 /*The following parameters are stored for spatial consistent updating. The notation is
166 that of 3GPP technical reports, but it can apply also to other channel realizations*/
168 Vector m_preLocUT; //!< location of UT when generating the previous channel
169 Vector m_locUT; //!< location of UT
171 m_norRvAngles; //!< stores the normal variable for random angles angle[cluster][id]
172 //!< generated for equation (7.6-11)-(7.6-14), where id =
173 //!< 0(aoa),1(zoa),2(aod),3(zod)
174 double m_DS; //!< delay spread
175 double m_K_factor; //!< K factor
176 uint8_t m_reducedClusterNumber; //!< reduced cluster number;
178 m_rayAodRadian; //!< the vector containing AOD angles
180 m_rayAoaRadian; //!< the vector containing AOA angles
182 m_rayZodRadian; //!< the vector containing ZOD angles
184 m_rayZoaRadian; //!< the vector containing ZOA angles
187 m_crossPolarizationPowerRatios; //!< cross polarization power ratios
188 Vector m_speed; //!< velocity
189 double m_dis2D; //!< 2D distance between tx and rx
190 double m_dis3D; //!< 3D distance between tx and rx
191 DoubleVector m_clusterPower; //!< cluster powers
192 DoubleVector m_attenuation_dB; //!< vector that stores the attenuation of the blockage
193 uint8_t m_cluster1st; //!< index of the first strongest cluster
194 uint8_t m_cluster2nd; //!< index of the second strongest cluster
195 };
196
197 /**
198 * Data structure that stores the parameters of 3GPP TR 38.901, Table 7.5-6,
199 * for a certain scenario
200 */
201 struct ParamsTable : public SimpleRefCount<ParamsTable>
202 {
203 uint8_t m_numOfCluster = 0; //!< Number of clusters
204 uint8_t m_raysPerCluster = 0; //!< Number of rays per cluster
205 double m_uLgDS = 0; //!< Mean value of 10-base logarithm of delay spread
206 double m_sigLgDS = 0; //!< Standard deviation value of 10-base logarithm of delay spread
207 double m_uLgASD =
208 0; //!< Mean value of 10-base logarithm of azimuth angle spread of departure
209 double m_sigLgASD =
210 0; //!< Standard deviation of 10-base logarithm of azimuth angle spread of departure
211 double m_uLgASA = 0; //!< Mean value of 10-base logarithm of azimuth angle spread of arrival
212 double m_sigLgASA =
213 0; //!< Standard deviation of 10-base logarithm of azimuth angle spread of arrival
214 double m_uLgZSA = 0; //!< Mean value of 10-base logarithm of zenith angle spread of arrival
215 double m_sigLgZSA =
216 0; //!< Standard deviation of 10-base logarithm of zenith angle spread of arrival
217 double m_uLgZSD =
218 0; //!< Mean value of 10-base logarithm of zenith angle spread of departure
219 double m_sigLgZSD =
220 0; //!< Standard deviation of 10-base logarithm of zenith angle spread of departure
221 double m_offsetZOD = 0; //!< Offset of zenith angle of departure
222 double m_cDS = 0; //!< Cluster DS
223 double m_cASD = 0; //!< Cluster ASD (Azimuth angle Spread of Departure)
224 double m_cASA = 0; //!< Cluster ASA (Azimuth angle Spread of Arrival)
225 double m_cZSA = 0; //!< Cluster ZSA (Zenith angle Spread of Arrival)
226 double m_uK = 0; //!< Mean of K-factor
227 double m_sigK = 0; //!< Standard deviation of K-factor
228 double m_rTau = 0; //!< Delay scaling parameter
229 double m_uXpr = 0; //!< Mean of Cross-Polarization Ratio
230 double m_sigXpr = 0; //!< Standard deviation of Cross-Polarization Ratio
231 double m_perClusterShadowingStd = 0; //!< Per cluster shadowing standard deviation
232 double m_sqrtC[7][7]; //!< The square root matrix and follows the order of [SF, K, DS, ASD,
233 //!< ASA, ZSD, ZSA]
234 };
235
236 /**
237 * Get the parameters needed to apply the channel generation procedure
238 * \param channelCondition the channel condition
239 * \param hBS the height of the BS
240 * \param hUT the height of the UT
241 * \param distance2D the 2D distance between tx and rx
242 * \return the parameters table
243 */
244 NS_DEPRECATED_3_41("Use GetThreeGppTable(const Ptr<const MobilityModel>, const Ptr<const "
245 "MobilityModel>, Ptr<const ChannelCondition>) instead")
246 Ptr<const ParamsTable> GetThreeGppTable(Ptr<const ChannelCondition> channelCondition,
247 double hBS,
248 double hUT,
249 double distance2D) const;
250
251 /**
252 * Get the parameters needed to apply the channel generation procedure
253 * \param aMob the mobility model of node A
254 * \param bMob the mobility model of node B
255 * \param channelCondition the channel condition
256 * \return the parameters table
257 */
258 virtual Ptr<const ParamsTable> GetThreeGppTable(
259 const Ptr<const MobilityModel> aMob,
260 const Ptr<const MobilityModel> bMob,
261 Ptr<const ChannelCondition> channelCondition) const;
262
263 /**
264 * Prepare 3gpp channel parameters among the nodes a and b.
265 * The function does the following steps described in 3GPP 38.901:
266 *
267 * Step 4: Generate large scale parameters. All LSPS are uncorrelated.
268 * Step 5: Generate Delays.
269 * Step 6: Generate cluster powers.
270 * Step 7: Generate arrival and departure angles for both azimuth and elevation.
271 * Step 8: Coupling of rays within a cluster for both azimuth and elevation
272 * shuffle all the arrays to perform random coupling
273 * Step 9: Generate the cross polarization power ratios
274 * Step 10: Draw initial phases
275 *
276 * All relevant generated parameters are added then to ThreeGppChannelParams
277 * which is the return value of this function.
278 * \param channelCondition the channel condition
279 * \param table3gpp the 3gpp parameters from the table
280 * \param aMob the a node mobility model
281 * \param bMob the b node mobility model
282 * \return ThreeGppChannelParams structure with all the channel parameters generated
283 * according 38.901 steps from 4 to 10.
284 */
286 const Ptr<const ChannelCondition> channelCondition,
287 const Ptr<const ParamsTable> table3gpp,
288 const Ptr<const MobilityModel> aMob,
289 const Ptr<const MobilityModel> bMob) const;
290
291 /**
292 * Compute the channel matrix between two nodes a and b, and their
293 * antenna arrays aAntenna and bAntenna using the procedure
294 * described in 3GPP TR 38.901
295 * \param channelParams the channel parameters previously generated for the pair of
296 * nodes a and b
297 * \param table3gpp the 3gpp parameters table
298 * \param sMob the mobility model of node s
299 * \param uMob the mobility model of node u
300 * \param sAntenna the antenna array of node s
301 * \param uAntenna the antenna array of node u
302 * \return the channel realization
303 */
304
305 virtual Ptr<ChannelMatrix> GetNewChannel(Ptr<const ThreeGppChannelParams> channelParams,
306 Ptr<const ParamsTable> table3gpp,
307 const Ptr<const MobilityModel> sMob,
308 const Ptr<const MobilityModel> uMob,
309 Ptr<const PhasedArrayModel> sAntenna,
310 Ptr<const PhasedArrayModel> uAntenna) const;
311 /**
312 * Applies the blockage model A described in 3GPP TR 38.901
313 * \param channelParams the channel parameters structure
314 * \param clusterAOA vector containing the azimuth angle of arrival for each cluster
315 * \param clusterZOA vector containing the zenith angle of arrival for each cluster
316 * \return vector containing the power attenuation for each cluster
317 */
319 const Ptr<ThreeGppChannelModel::ThreeGppChannelParams> channelParams,
320 const DoubleVector& clusterAOA,
321 const DoubleVector& clusterZOA) const;
322
323 /**
324 * Check if the channel params has to be updated
325 * \param channelParams channel params
326 * \param channelCondition the channel condition
327 * \return true if the channel params has to be updated, false otherwise
328 */
329 bool ChannelParamsNeedsUpdate(Ptr<const ThreeGppChannelParams> channelParams,
330 Ptr<const ChannelCondition> channelCondition) const;
331
332 /**
333 * Check if the channel matrix has to be updated (it needs update when the channel params
334 * generation time is more recent than channel matrix generation time
335 * \param channelParams channel params structure
336 * \param channelMatrix channel matrix structure
337 * \return true if the channel matrix has to be updated, false otherwise
338 */
339 bool ChannelMatrixNeedsUpdate(Ptr<const ThreeGppChannelParams> channelParams,
340 Ptr<const ChannelMatrix> channelMatrix);
341
342 /**
343 * Check if the channel matrix has to be updated due to
344 * changes in the number of antenna ports
345 * \param aAntenna the antenna array of node a
346 * \param bAntenna the antenna array of node b
347 * \param channelMatrix channel matrix structure
348 * \return true if the channel matrix has to be updated, false otherwise
349 */
350 bool AntennaSetupChanged(Ptr<const PhasedArrayModel> aAntenna,
351 Ptr<const PhasedArrayModel> bAntenna,
352 Ptr<const ChannelMatrix> channelMatrix);
353
354 std::unordered_map<uint64_t, Ptr<ChannelMatrix>>
355 m_channelMatrixMap; //!< map containing the channel realizations per pair of
356 //!< PhasedAntennaArray instances, the key of this map is reciprocal
357 //!< uniquely identifies a pair of PhasedAntennaArrays
358 std::unordered_map<uint64_t, Ptr<ThreeGppChannelParams>>
359 m_channelParamsMap; //!< map containing the common channel parameters per pair of nodes, the
360 //!< key of this map is reciprocal and uniquely identifies a pair of
361 //!< nodes
362 Time m_updatePeriod; //!< the channel update period
363 double m_frequency; //!< the operating frequency
364 std::string m_scenario; //!< the 3GPP scenario
365 Ptr<ChannelConditionModel> m_channelConditionModel; //!< the channel condition model
366 Ptr<UniformRandomVariable> m_uniformRv; //!< uniform random variable
367 Ptr<NormalRandomVariable> m_normalRv; //!< normal random variable
369 m_uniformRvShuffle; //!< uniform random variable used to shuffle array in GetNewChannel
370
371 // Variable used to compute the additional Doppler contribution for the delayed
372 // (reflected) paths, as described in 3GPP TR 37.885 v15.3.0, Sec. 6.2.3.
373 double m_vScatt; //!< value used to compute the additional Doppler contribution for the delayed
374 //!< paths
375 Ptr<UniformRandomVariable> m_uniformRvDoppler; //!< uniform random variable, used to compute the
376 //!< additional Doppler contribution
377
378 // parameters for the blockage model
379 bool m_blockage; //!< enables the blockage model A
380 uint16_t m_numNonSelfBlocking; //!< number of non-self-blocking regions
381 bool m_portraitMode; //!< true if portrait mode, false if landscape
382 double m_blockerSpeed; //!< the blocker speed
383
384 static const uint8_t PHI_INDEX = 0; //!< index of the PHI value in the m_nonSelfBlocking array
385 static const uint8_t X_INDEX = 1; //!< index of the X value in the m_nonSelfBlocking array
386 static const uint8_t THETA_INDEX =
387 2; //!< index of the THETA value in the m_nonSelfBlocking array
388 static const uint8_t Y_INDEX = 3; //!< index of the Y value in the m_nonSelfBlocking array
389 static const uint8_t R_INDEX = 4; //!< index of the R value in the m_nonSelfBlocking array
390};
391} // namespace ns3
392
393#endif /* THREE_GPP_CHANNEL_H */
Carries information about the LOS/NLOS channel state.
O2iConditionValue
Possible values for Outdoor to Indoor condition.
LosConditionValue
Possible values for Line-of-Sight condition.
Models the channel condition.
This is an interface for a channel model that can be described by a channel matrix,...
std::vector< double > DoubleVector
Type definition for vectors of doubles.
std::vector< Double2DVector > Double3DVector
Type definition for 3D matrices of doubles.
std::vector< DoubleVector > Double2DVector
Type definition for matrices of doubles.
Keep track of the current position and velocity of an object.
The normal (Gaussian) distribution Random Number Generator (RNG) that allows stream numbers to be set...
Class implementing the phased array model virtual base class.
Smart pointer class similar to boost::intrusive_ptr.
A template-based reference counting class.
Channel Matrix Generation following 3GPP TR 38.901.
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.
int64_t AssignStreams(int64_t stream)
Assign a fixed random variable stream number to the random variables used by this model.
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.
bool m_portraitMode
true if portrait mode, false if landscape
bool ChannelParamsNeedsUpdate(Ptr< const ThreeGppChannelParams > channelParams, Ptr< const ChannelCondition > channelCondition) const
Check if the channel params has to be updated.
Ptr< NormalRandomVariable > m_normalRv
normal random variable
static const uint8_t Y_INDEX
index of the Y value in the m_nonSelfBlocking array
bool m_blockage
enables the blockage model A
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.
~ThreeGppChannelModel() override
Destructor.
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...
static const uint8_t THETA_INDEX
index of the THETA value in the m_nonSelfBlocking array
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...
static std::pair< double, double > WrapAngles(double azimuthRad, double inclinationRad)
Wrap an (azimuth, inclination) angle pair in a valid range.
double m_blockerSpeed
the blocker speed
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.
void SetFrequency(double f)
Sets the center frequency of the model.
std::unordered_map< uint64_t, Ptr< ChannelMatrix > > m_channelMatrixMap
map containing the channel realizations per pair of PhasedAntennaArray instances, the key of this map...
Ptr< UniformRandomVariable > m_uniformRv
uniform random variable
void DoDispose() override
Destructor implementation.
void SetScenario(const std::string &scenario)
Sets the propagation scenario.
void SetChannelConditionModel(Ptr< ChannelConditionModel > model)
Set the channel condition model.
Ptr< UniformRandomVariable > m_uniformRvDoppler
uniform random variable, used to compute the additional Doppler contribution
uint16_t m_numNonSelfBlocking
number of non-self-blocking regions
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.
std::string GetScenario() const
Returns the propagation scenario.
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 ...
static const uint8_t PHI_INDEX
index of the PHI value in the m_nonSelfBlocking array
double m_frequency
the operating frequency
double m_vScatt
value used to compute the additional Doppler contribution for the delayed paths
Ptr< ChannelConditionModel > GetChannelConditionModel() const
Get the associated channel condition model.
Ptr< ChannelConditionModel > m_channelConditionModel
the channel condition model
std::string m_scenario
the 3GPP scenario
static const uint8_t R_INDEX
index of the R value in the m_nonSelfBlocking array
static TypeId GetTypeId()
Get the type ID.
void Shuffle(double *first, double *last) const
Shuffle the elements of a simple sequence container of type double.
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.
double GetFrequency() const
Returns the center frequency.
Time m_updatePeriod
the channel update period
static const uint8_t X_INDEX
index of the X value in the m_nonSelfBlocking array
Ptr< UniformRandomVariable > m_uniformRvShuffle
uniform random variable used to shuffle array in GetNewChannel
Simulation virtual time values and global simulation resolution.
Definition nstime.h:94
a unique identifier for an interface.
Definition type-id.h:48
The uniform distribution Random Number Generator (RNG).
#define NS_DEPRECATED_3_41(msg)
Tag for things deprecated in version ns-3.41.
Definition deprecated.h:105
Definition first.py:1
Every class exported by the ns3 library is enclosed in the ns3 namespace.
STL namespace.
Data structure that stores a channel realization.
Data structure that stores channel parameters.
Data structure that stores the parameters of 3GPP TR 38.901, Table 7.5-6, for a certain scenario.
double m_sqrtC[7][7]
The square root matrix and follows the order of [SF, K, DS, ASD, ASA, ZSD, ZSA].
double m_sigLgZSD
Standard deviation of 10-base logarithm of zenith angle spread of departure.
double m_cASD
Cluster ASD (Azimuth angle Spread of Departure)
double m_uLgZSD
Mean value of 10-base logarithm of zenith angle spread of departure.
double m_uLgASA
Mean value of 10-base logarithm of azimuth angle spread of arrival.
double m_sigXpr
Standard deviation of Cross-Polarization Ratio.
double m_uLgASD
Mean value of 10-base logarithm of azimuth angle spread of departure.
double m_cASA
Cluster ASA (Azimuth angle Spread of Arrival)
uint8_t m_raysPerCluster
Number of rays per cluster.
double m_sigK
Standard deviation of K-factor.
double m_perClusterShadowingStd
Per cluster shadowing standard deviation.
double m_sigLgASD
Standard deviation of 10-base logarithm of azimuth angle spread of departure.
double m_offsetZOD
Offset of zenith angle of departure.
double m_uLgDS
Mean value of 10-base logarithm of delay spread.
double m_sigLgASA
Standard deviation of 10-base logarithm of azimuth angle spread of arrival.
double m_uLgZSA
Mean value of 10-base logarithm of zenith angle spread of arrival.
double m_cZSA
Cluster ZSA (Zenith angle Spread of Arrival)
double m_sigLgZSA
Standard deviation of 10-base logarithm of zenith angle spread of arrival.
double m_uXpr
Mean of Cross-Polarization Ratio.
double m_sigLgDS
Standard deviation value of 10-base logarithm of delay spread.
Extends the struct ChannelParams by including information that is used within the ThreeGppChannelMode...
MatrixBasedChannelModel::Double2DVector m_rayAoaRadian
the vector containing AOA angles
MatrixBasedChannelModel::Double3DVector m_clusterPhase
the initial random phases
MatrixBasedChannelModel::Double2DVector m_norRvAngles
stores the normal variable for random angles angle[cluster][id] generated for equation (7....
ChannelCondition::LosConditionValue m_losCondition
contains the information about the LOS state of the channel
MatrixBasedChannelModel::Double2DVector m_rayZodRadian
the vector containing ZOD angles
ChannelCondition::O2iConditionValue m_o2iCondition
contains the information about the O2I state of the channel
MatrixBasedChannelModel::Double2DVector m_rayAodRadian
the vector containing AOD angles
DoubleVector m_attenuation_dB
vector that stores the attenuation of the blockage
Vector m_preLocUT
location of UT when generating the previous channel
MatrixBasedChannelModel::Double2DVector m_rayZoaRadian
the vector containing ZOA angles
MatrixBasedChannelModel::Double2DVector m_nonSelfBlocking
store the blockages
uint8_t m_cluster1st
index of the first strongest cluster
MatrixBasedChannelModel::Double2DVector m_crossPolarizationPowerRatios
cross polarization power ratios
uint8_t m_cluster2nd
index of the second strongest cluster