Scattering MIMO channel

The `phased.ScatteringMIMOChannel`

System
object™ models
a multipath propagation channel in which radiated signals from a transmitting
array are reflected from multiple scatterers back toward a receiving
array. In this channel, propagation paths are line of sight from point
to point. The object models range-dependent time delay, gain, Doppler
shift, phase change, and atmospheric loss due to gases, rain, fog,
and clouds.

The attenuation models for atmospheric gases and rain are valid for electromagnetic signals in the frequency range 1–1000 GHz. The attenuation model for fog and clouds is valid from 10–1000 GHz. Outside these frequency ranges, the object uses the nearest valid value.

To compute the multipath propagation for specified source and receiver points:

Define and set up your scattering MIMO channel using the Construction procedure. You can set the System object properties during construction or leave them at their default values.

Call the

`step`

method to compute the propagated signals using the properties of the`phased.ScatteringMIMOChannel`

System object. You can change tunable properties before or after any call to the`step`

method.

Instead of using the `step`

method to perform
the operation defined by the System
object, you can call the object
with arguments, as if it were a function. For example, ```
y
= step(obj,x)
```

and `y = obj(x)`

perform
equivalent operations.

`channel = phased.ScatteringMIMOChannel`

creates
a scattering MIMO propagation channel System
object, `channel`

.

`channel = phased.ScatteringMIMOChannel(`

creates
a System
object, `Name`

,`Value`

)`channel`

, with each specified
property `Name`

set to the specified `Value`

.
You can specify additional name and value pair arguments in any order
as (`Name1,Value1`

,...,`NameN,ValueN`

).

`TransmitArray`

— Transmitting arrayPhased Array System Toolbox™ antenna array System object

Transmitting array, specified as a Phased Array System Toolbox antenna array System object.

**Example: **`phased.URA`

`ReceiveArray`

— Receiving arrayPhased Array System Toolbox antenna array System object

Receiving array, specified as a Phased Array System Toolbox antenna array System object.

**Example: **`phased.URA`

`PropagationSpeed`

— Signal propagation speed`physconst('LightSpeed')`

(default) | positive scalarSignal propagation speed, specified as a positive scalar. Units are in meters per second. The
default propagation speed is the value returned by
`physconst('LightSpeed')`

. See `physconst`

.

**Example: **`3e8`

**Data Types: **`double`

`CarrierFrequency`

— Signal carrier frequency`300e6`

(default) | positive real-valued scalarSignal carrier frequency, specified as a positive real-valued scalar. Units are in Hz.

**Example: **`100e6`

**Data Types: **`double`

`Polarization`

— Polarization configuration`'None'`

(default) | `'Combined'`

| `'Dual'`

Polarization configuration, specified as `'None'`

,
`'Combined'`

, or `'Dual'`

. When you set this
property to `'None'`

, the output field is considered a scalar field.
When you set this property to `'Combined'`

, the radiated fields are
polarized and are interpreted as a single signal in the sensor's inherent polarization.
When you set this property to `'Dual'`

, the *H* and
*V* polarization components of the radiated field are independent
signals.

**Example: **`'Dual'`

**Data Types: **`char`

`SpecifyAtmosphere`

— Enable atmospheric attenuation model`false`

(default) | `true`

Option to enable the atmospheric attenuation model, specified
as a `false`

or `true`

. Set this
property to `true`

to add signal attenuation caused
by atmospheric gases, rain, fog, or clouds. Set this property to `false`

to
ignore atmospheric effects in propagation.

Setting `SpecifyAtmosphere`

to `true`

,
enables the `Temperature`

, `DryAirPressure`

, `WaterVapourDensity`

, `LiquidWaterDensity`

,
and `RainRate`

properties.

**Data Types: **`logical`

`Temperature`

— Ambient temperature`15`

(default) | real-valued scalarAmbient temperature, specified as a real-valued scalar. Units are in degrees Celsius.

**Example: **`20.0`

To enable this property, set `SpecifyAtmosphere`

to `true`

.

**Data Types: **`double`

`DryAirPressure`

— Atmospheric dry air pressure`101.325e3`

(default) | positive real-valued scalarAtmospheric dry air pressure, specified as a positive real-valued scalar. Units are in pascals (Pa). The default value of this property corresponds to one standard atmosphere.

**Example: **`101.0e3`

To enable this property, set `SpecifyAtmosphere`

to `true`

.

**Data Types: **`double`

`WaterVapourDensity`

— Atmospheric water vapor density`7.5`

(default) | positive real-valued scalarAtmospheric water vapor density, specified as a positive real-valued
scalar. Units are in g/m^{3}.

**Example: **`7.4`

To enable this property, set `SpecifyAtmosphere`

to `true`

.

**Data Types: **`double`

`LiquidWaterDensity`

— Liquid water density`0.0`

(default) | nonnegative real-valued scalarLiquid water density of fog or clouds, specified as a nonnegative
real-valued scalar. Units are in g/m^{3}.
Typical values for liquid water density are 0.05 for medium fog and
0.5 for thick fog.

**Example: **`0.1`

To enable this property, set `SpecifyAtmosphere`

to `true`

.

**Data Types: **`double`

`RainRate`

— Rainfall rate`0.0`

(default) | nonnegative scalarRainfall rate, specified as a nonnegative scalar. Units are in mm/hr.

**Example: **`10.0`

To enable this property, set `SpecifyAtmosphere`

to `true`

.

**Data Types: **`double`

`SampleRate`

— Sample rate of signal`1e6`

(default) | positive scalarSample rate of signal, specified as a positive scalar. Units are in Hz. The System object uses this quantity to calculate the propagation delay in units of samples.

**Example: **`1e6`

**Data Types: **`double`

`SimulateDirectPath`

— Enable propagation along direct path`false`

(default) | `true`

Option to enable signal propagation along the direct path, specified
as `false`

or `true`

. The direct
path is a line-of-sight path from the transmitting array to the receiving
array with no scattering.

**Data Types: **`logical`

`ChannelResponseOutputPort`

— Enable output of channel response`false`

(default) | `true`

Option to enable output of channel response, specified as `false`

or `true`

.
Set this property to `true`

to output the channel
response and time delay by using the `chmatrix`

and `tau`

output
arguments of the `step`

method.

**Data Types: **`logical`

`MaximumDelaySource`

— Source of maximum delay`'Auto'`

(default) | `'Property'`

Source of the maximum delay value, specified as `'Auto'`

or `'Property'`

.
When you set this property to `'Auto'`

, the channel
automatically allocates enough memory to simulate the propagation
delay. When you set this property to `'Property'`

,
you can specify the maximum delay by using the `MaximumDelay`

property.
Signals arriving after the maximum delay are ignored.

`MaximumDelay`

— Maximum signal delay`10e-6`

(default) | positive scalarMaximum signal delay, specified as a positive scalar. Delays greater than this value are ignored. Units are in seconds.

To enable this property, set the `MaximumDelaySource`

property
to `'Property'`

.

**Data Types: **`double`

`TransmitArrayMotionSource`

— Source of transmitting array motion parameters`'Property'`

(default) | `'Input port'`

Source of the transmitting array motion parameters, specified
as `'Property'`

or `'Input port'`

.

When you set this property to

`'Property'`

, the transmitting array is stationary. Then, you can specify the location and orientation of the array using the`TransmitArrayPosition`

and`TransmitArrayOrientationAxes`

properties.When you set this property to

`'Input port'`

, specify the transmitting array location, velocity, and orientation by using the`txpos`

,`txvel`

, and`txaxes`

input arguments of the`step`

method.

**Data Types: **`char`

`TransmitArrayPosition`

— Position of transmitting array phase center`[0;0;0]`

(default) | real-valued three-element vectorPosition of the transmitting array phase center, specified as
a real-valued three-element vector in Cartesian form, `[x;y;z]`

,
with respect to the global coordinate system. Units are in meters.

**Example: **`[1000;-200;55]`

To enable this property, set the `TransmitArrayMotionSource`

property
to `'Property'`

.

**Data Types: **`double`

`TransmitArrayOrientationAxes`

— Orientation of transmitting array`eye(3,3)`

(default) | real-valued 3-by-3 orthonormal matrixOrientation of transmitting array, specified as a real-valued
3-by-3 orthonormal matrix. The matrix specifies the three axes, *(x,y,z)*,
that define the local coordinate system of the array with respect
to the global coordinate system. Each column corresponds to an axis.

**Example: **`rotz(45)`

To enable this property, set the `TransmitArrayMotionSource`

property
to `'Property'`

.

**Data Types: **`double`

`ReceiveArrayMotionSource`

— Source of receiving array motion parameters`'Property'`

(default) | `'Input port'`

Source of the receiving array motion parameters, specified as `'Property'`

or ```
'Input
port'
```

.

When you set this property to

`'Property'`

, the receiving array is stationary. Then, you can specify the location and orientation of the array by using the`ReceiveArrayPosition`

and`ReceiveArrayOrientationAxes`

properties.When you set this property to

`'Input port'`

, you can specify the receiving array location, velocity, and orientation by using the`rxpos`

,`rxvel`

, and`rxaxes`

input arguments of the`step`

method.

**Data Types: **`char`

`ReceiveArrayPosition`

— Position of receiving array`[0;0;0]`

(default) | real-valued three-element vectorPosition of the receiving array phase center, specified as a
real-valued three-element vector in Cartesian form,`[x;y;z]`

,
with respect to the global coordinate system. Units are in meters.

**Example: **`[1000;-200;55]`

To enable this property, set the `ReceiveArrayMotionSource`

property
to `'Property'`

.

**Data Types: **`double`

`ReceiveArrayOrientationAxes`

— Orientation of receiving array`eye(3,3)`

(default) | real-valued 3-by-3 orthonormal matrixOrientation of receiving array, specified as a real-valued 3-by-3
orthonormal matrix. The matrix specifies the three axes, *(x,y,z)*,
that define the local coordinate system of the array with respect
to the global coordinate system. Each column corresponds to an axis.

**Example: **`roty(60)`

To enable this property, set the `ReceiveArrayMotionSource`

property
to `'Property'`

.

**Data Types: **`double`

`ScattererSpecificationSource`

— Source of scatterer parameters`'Auto'`

(default) | `'Property'`

| `'Input port'`

Source of scatterer parameters, specified as `'Auto'`

, `'Property'`

, ```
'Input
port'
```

.

When you set this property to

`'Auto'`

, all scatterer positions and coefficients are randomly generated. Scatterer velocities are zero. The generated positions are contained within the region that is defined by the`ScattererPositionBoundary`

. To set the number of scatterers, use the`NumScatterers`

property.When you set this property to

`'Property'`

, you can set the scatterer positions by using the`ScattererPosition`

property and the scattering coefficients by using the`ScattererCoefficient`

property. All scatterer velocities are zero.When you set this property to

`'Input port'`

, you can specify the scatterer positions, velocities, and scattering coefficients using the`scatpos`

,`scatvel`

, and`scatcoef`

input arguments of the`step`

method.

**Example: **`'Input port'`

**Data Types: **`char`

`NumScatterers`

— Number of scatterers`1`

(default) | nonnegative integerNumber of scatterers, specified as a nonnegative integer.

**Example: **`9`

To enable this property, set the `ScattererSpecificationSource`

property
to `'Auto'`

.

**Data Types: **`double`

`ScattererPositionBoundary`

— Boundary of scatterer positions`[0,1000]`

(default) | 1-by-2 real-valued vector | 3-by-2 real-valued matrixBoundary of the scatterer positions, specified as a 1-by-2 real-valued
row vector or a 3-by-2 real-valued matrix. The vector specifies the
minimum and maximum, `[minbdry maxbdry]`

, for all
three dimensions. The matrix specifies boundaries in all three dimensions
in the form ```
[x_minbdry x_maxbdry;y_minbdry y_maxbdry; z_minbdry
z_maxbdry]
```

.

**Example: **`[-1000 500;-100 100;-200 0]`

To enable this property, set the `ScattererSpecificationSource`

property
to `'Auto'`

.

**Data Types: **`double`

`ScattererPosition`

— Positions of scatterers`[0;0;0]`

(default) | real-valued 3-by-Positions of the scatterers, specified as real-valued 3-by-*K* matrix. *K* is
the number of scatterers. Each column represents a different scatterer
and has the Cartesian form `[x;y;z]`

with respect
to the global coordinate system. Units are in meters.

**Example: **`[1050 -100;-300 55;0 -75]`

To enable this property, set the `ScattererSpecificationSource`

property
to `'Property'`

.

**Data Types: **`double`

`ScattererCoefficient`

— Scattering coefficients`1`

(default) | complex-valued 1-by-Scattering coefficients, specified as a complex-valued 1-by-*K* vector. *K* is
the number of scatterers. Units are dimensionless.

**Example: **`2+1i`

To enable this property, set the `ScattererSpecificationSource`

property
to `'Property'`

.

**Data Types: **`double`

**Complex Number Support: **Yes

`ScatteringMatrix`

— Scattering matrices`[1 0;0 1]`

| complex–valued 2-by-2-by-Scattering matrices of the scatterers, specified as a complex–valued
2-by-2-by-*N*_{s} array where
*N*_{s} is the number of
scatterers. Each page of this array represents the scattering matrix of a
scatterer. Each scattering matrix has the form ```
[s_hh s_hv;s_vh
s_vv]
```

. For example, the component `s_hv`

specifies the complex scattering response when the input signal is
vertically polarized and the reflected signal is horizontally polarized. The
other components are defined similarly. Units are in square meters.

To enable this property, set the
`ScatteringMatrixSource`

property to
`'Property'`

and the
`Polarization`

property to
`'Combined'`

or `'Dual'`

.

**Data Types: **`double`

**Complex Number Support: **Yes

`ScattererOrientationAxes`

— Orientation of scatterers`[1 0 0;0 1 0;0 0 1]`

(default) | real–valued 3-by-3-by-Orientation of the scatterers, specified as a real–valued
3-by-3-by-*N*_{s} array where
*N*_{s} is the number of
scatterers. Each page of this array is an orthonormal matrix. Matrix columns
represent the axis of the local coordinates,
(*x*,*y*,*z*) of the
scatter with respect to the global coordinate system.

**Example: **`roty(45)`

To enable this property, set the
`ScatteringMatrixSource`

property to
`'Property'`

and the
`Polarization`

property to
`'Combined'`

or `'Dual'`

.

**Data Types: **`double`

`SeedSource`

— Source of random number generator seed`'Auto'`

(default) | `'Property'`

Source of random number generator seed, specified as `'Auto'`

or `'Property'`

.

When you set this property to

`'Auto'`

, random numbers are generated using the default MATLAB^{®}random number generator.When you set this property to

`'Property'`

, the object uses a private random number generator with the seed specified by the value of the`Seed`

property.

To use this object with Parallel
Computing Toolbox™ software,
set this property to `'Auto'`

.

To enable this property, set the `ScattererSpecificationSource`

property
to `'Auto'`

.

`Seed`

— Random number generator seed`0`

(default) | nonnegative integerRandom number generator seed, specified as a nonnegative integer
less than 2^{32}.

**Example: **`5005`

To enable this property, set the `ScattererSpecificationSource`

property
to `'Auto'`

and the `SeedSource`

property
to `'Property'`

.

**Data Types: **`double`

reset | Reset state of the System object |

step | Propagate signals in scattering MIMO channel |

Common to All System Objects | |
---|---|

`release` | Allow System object property value changes |

Create a 30 GHz MIMO channel with random scatterers. The scenario contains a stationary 21-element transmitting ULA array and a stationary 15-element receiving ULA array. The transmitting antennas have cosine responses and the receiving antennas are isotropic. Element spacing for both arrays is less than one-half wavelength. The channel has 50 randomly generated static scatterers within a specified bounding box. The transmit array is located at [0;20;50] meters and the receive array is located at [200;10;10] meters. Compute the propagated signal through this channel. The sample rate for the signal is 10 MHz.

fc = 30e9; c = physconst('LightSpeed'); lambda = c/fc; fs = 10e6; txarray = phased.ULA('Element',phased.CosineAntennaElement,... 'NumElements',21,'ElementSpacing',0.45*lambda); rxarray = phased.ULA('Element',phased.IsotropicAntennaElement,... 'NumElements',15,'ElementSpacing',0.45*lambda); channel = phased.ScatteringMIMOChannel('TransmitArray',txarray,... 'ReceiveArray',rxarray,'PropagationSpeed',c,'CarrierFrequency',fc,... 'SampleRate',fs,'TransmitArrayPosition',[0;20;50],... 'ReceiveArrayPosition',[200;10;10],'NumScatterers',50,... 'ScattererPositionBoundary',[10 180; -30 30; -30 30]);

Create a random data signal of ones and zeros for each transmitter.

x = randi(2,[100 21]) - 1;

Compute the received signals after propagating through the channel.

y = channel(x);

Create a MIMO channel containing 3 fixed scatterers. The scenario contains a 21-element transmitting ULA array operating at 72 GHz, and a 15-element receiving ULA array. The transmitting elements have cosine response shapes and the receiving antennas are isotropic. Only the transmitting antenna is moving. Element spacing for both arrays is less than one-half wavelength. The transmitting array starts at (0,20,50) meters and moves towards the receiver at 2 m/s. The receiving array is located at (200,10,10) meters. Compute the propagated signal through this channel. The sample rate for the signal is 10 MHz.

fc = 72e9; c = physconst('LightSpeed'); lambda = c/fc; fs = 10e6; txplatform = phased.Platform('MotionModel','Velocity','InitialPosition', ... [0;20;50],'Velocity',[2;0;0]); txarray = phased.ULA('Element',phased.CosineAntennaElement, ... 'NumElements',21,'ElementSpacing',0.45*lambda); rxarray = phased.ULA('Element',phased.IsotropicAntennaElement, ... 'NumElements',15,'ElementSpacing',0.45*lambda); channel = phased.ScatteringMIMOChannel('TransmitArray',txarray, ... 'ReceiveArray',rxarray,'PropagationSpeed',c,'CarrierFrequency',fc,... 'SampleRate',fs,'TransmitArrayMotionSource','Input port', ... 'ReceiveArrayMotionSource','Property','ReceiveArrayPosition',[200;10;10],... 'ReceiveArrayOrientationAxes',rotz(180),... 'ScattererSpecificationSource','Property','ScattererPosition', ... [75 100 120; -10 20 12; 5 -5 8],'ScattererCoefficient',[1i,2+3i,-1+1i]);

Move the platforms for two time steps at one second intervals. For each time instance:

Create a random data signal of ones and zeros for each transmitter element.

Move the transmitter and receiver. The orientations are fixed.

Propagate the signals from transmitters to scatterers to receiver.

for k =1:2 x = randi(2,[100 21]) - 1; [txpos,txvel] = txplatform(1); txaxes = eye(3); y = channel(x,txpos,txvel,txaxes); end

Create a MIMO channel containing 3 fixed scatterers. The scenario contains a 21-element transmitting ULA array and a 15-element receiving ULA array. Both arrays operating at 72 GHz. The transmitting elements have cosine response shapes and the receiving antennas are isotropic. Only the receiving antenna is moving. Element spacing for both arrays is less than one-half wavelength. The transmitting array is located at (0,20,50) meters. The receiving array starts at (200,10,10) meters and moves toward the transmitter at 2 m/s. Compute the propagated signal through this channel. The sample rate for the signal is 10 MHz.

fc = 72e9; c = physconst('LightSpeed'); lambda = c/fc; fs = 10e6; rxplatform = phased.Platform('MotionModel','Velocity','InitialPosition',... [200;10;10],'Velocity',[-2;0;0]); txarray = phased.ULA('Element',phased.CosineAntennaElement, ... 'NumElements',21,'ElementSpacing',0.45*lambda); rxarray = phased.ULA('Element',phased.IsotropicAntennaElement, ... 'NumElements',15,'ElementSpacing',0.45*lambda); channel = phased.ScatteringMIMOChannel('TransmitArray',txarray, ... 'ReceiveArray',rxarray,'PropagationSpeed',c,'CarrierFrequency',fc, ... 'SampleRate',fs,'TransmitArrayMotionSource','Property',... 'TransmitArrayPosition',[0;20;50],'TransmitArrayOrientationAxes',eye(3,3), ... 'ReceiveArrayMotionSource','Input port','ScattererSpecificationSource', ... 'Property','ScattererPosition',[75 100 120; -10 20 12; 5 -5 8], ... 'ScattererCoefficient',[1i,2+3i,-1+1i],'SpecifyAtmosphere',false);

Move the platforms for two time steps at one-second intervals. For each time instance:

Create a random data signal of ones and zeros for each transmitter element.

Move the transmitter and receiver. Fix the array orientations.

Propagate the signals from transmitters to scatterers to receiver.

for k =1:2 x = randi(2,[100 21]) - 1; [rxpos,rxvel] = rxplatform(1); rxaxes = rotz(45); y = channel(x,rxpos,rxvel,rxaxes); end

Create a MIMO channel at 30 GHz with an 16-element transmit array and a 64-element receive array. Assume the elements are short-dipole antennas and the arrays are uniform linear arrays. The transmit array is located at [0;0;50] meters.

The receive array has an initial position at [200;0;0] meters and is moving at a speed of [10;0;0] meters/second. There are 200 static scatterers randomly located on the *xy* plane within a square centered at [200;0;0] and with a side length of 100 meters.

Use the channel to compute the propagated polarized signal. Assume the sample rate for the signal is 10 MHz and the frame length is 1000 samples. Collect 5 frames of received signal.

fc = 30e9; c = 3e8; lambda = c/fc; fs = 10e6; txarray = phased.ULA('Element',phased.ShortDipoleAntennaElement,... 'NumElements',16,'ElementSpacing',lambda/2); rxarray = phased.ULA('Element',phased.ShortDipoleAntennaElement,... 'NumElements',64,'ElementSpacing',lambda/2); Ns = 200; scatpos = [100*rand(1,Ns) + 150; 100*rand(1,Ns) + 150; zeros(1,Ns)]; temp = randn(1,Ns) + 1i*randn(1,Ns); scatcoef = repmat(eye(2),1,1,Ns).*permute(temp,[1 3 2]); scatax = repmat(eye(3),1,1,Ns); Nframesamp = 1000; Tframe = Nframesamp/fs; rxmobile = phased.Platform('InitialPosition',[200;0;0],... 'Velocity',[10;0;0],'OrientationAxesOutputPort',true); chan = phased.ScatteringMIMOChannel(... 'TransmitArray',txarray,... 'ReceiveArray',rxarray,... 'PropagationSpeed',c,... 'CarrierFrequency',fc,... 'SampleRate',fs,... 'Polarization','Dual',... 'TransmitArrayPosition',[0;0;50],... 'ReceiveArrayMotionSource','Input port',... 'ScattererSpecificationSource','Property',... 'ScattererPosition',scatpos,... 'ScatteringMatrix',scatcoef,... 'ScattererOrientationAxes',scatax); xh = randi(2,[Nframesamp 16])-1; xv = randi(2,[Nframesamp 16])-1; for m = 1:5 [rxpos,rxvel,rxax] = rxmobile(Tframe); [yh,yv] = chan(xh,xv,rxpos,rxvel,rxax); end

Attenuation or path loss in the scattering MIMO channel consists
of four components. *L = L _{fsp}L_{g}L_{c}L_{r}*,
where:

*L*is the free-space path attenuation._{fsp}*L*is the atmospheric path attenuation._{g}*L*is the fog and cloud path attenuation._{c}*L*is the rain path attenuation._{r}

Each component is in magnitude units, not in dB.

When the origin and destination are stationary relative to each
other, you can write the output signal of a free-space channel as *Y(t)
= x(t-τ)/L _{fsp}*.
The quantity

$${L}_{fsp}=\frac{{(4\pi R)}^{2}}{{\lambda}^{2}},$$

where λ is the signal wavelength.

This formula assumes that the target is in the far field of
the transmitting element or array. In the near field, the free-space
path loss formula is not valid and can result in a loss smaller than
one, equivalent to a signal gain. Therefore, the loss is set to unity
for range values, *R ≤ λ/4π*.

When the origin and destination have relative motion, the processing
also introduces a Doppler frequency shift. The frequency shift is *v/λ* for
one-way propagation and *2v/λ* for two-way
propagation. The quantity *v* is the relative speed
of the destination with respect to the origin.

For more details on free space channel propagation, see [8]

This model calculates the attenuation of signals that propagate through atmospheric gases.

Electromagnetic signals attenuate when they propagate through the atmosphere. This effect is
due primarily to the absorption resonance lines of oxygen and water vapor, with smaller
contributions coming from nitrogen gas. The model also includes a continuous absorption
spectrum below 10 GHz. The ITU model *Recommendation ITU-R P.676-10: Attenuation by
atmospheric gases* is used. The model computes the specific attenuation
(attenuation per kilometer) as a function of temperature, pressure, water vapor density, and
signal frequency. The atmospheric gas model is valid for frequencies from 1–1000 GHz and
applies to polarized and nonpolarized fields.

The formula for specific attenuation at each frequency is

$$\gamma ={\gamma}_{o}(f)+{\gamma}_{w}(f)=0.1820f{N}^{\u2033}(f).$$

The quantity *N"()* is the imaginary part of the complex
atmospheric refractivity and consists of a spectral line component and a continuous component:

$${N}^{\u2033}(f)={\displaystyle \sum _{i}{S}_{i}{F}_{i}+{{N}^{\u2033}}_{D}^{}(f)}$$

The spectral component consists of a sum of discrete spectrum terms
composed of a localized frequency bandwidth function,
*F(f)*_{i}, multiplied by a spectral line strength,
*S*_{i}. For atmospheric oxygen, each spectral line
strength is

$${S}_{i}={a}_{1}\times {10}^{-7}{\left(\frac{300}{T}\right)}^{3}\mathrm{exp}\left[{a}_{2}(1-\left(\frac{300}{T}\right)\right]P.$$

For atmospheric water vapor, each spectral line strength is

$${S}_{i}={b}_{1}\times {10}^{-1}{\left(\frac{300}{T}\right)}^{3.5}\mathrm{exp}\left[{b}_{2}(1-\left(\frac{300}{T}\right)\right]W.$$

*P* is the dry air pressure, *W* is the
water vapor partial pressure, and *T* is the ambient temperature. Pressure
units are in hectoPascals (hPa) and temperature is in degrees Kelvin. The water vapor
partial pressure, *W*, is related to the water vapor density, ρ, by

$$W=\frac{\rho T}{216.7}.$$

The total atmospheric pressure is *P* +
*W*.

For each oxygen line, *S _{i}* depends on two parameters,

The localized frequency bandwidth functions *F _{i}(f)* are
complicated functions of frequency described in the ITU references
cited below. The functions depend on empirical model parameters that
are also tabulated in the reference.

To compute the total attenuation for narrowband signals along
a path, the function multiplies the specific attenuation by the path
length, *R*. Then, the total attenuation is *L _{g}=
R(γ_{o} + γ_{w})*.

You can apply the attenuation model to wideband signals. First, divide the wideband signal into frequency subbands, and apply attenuation to each subband. Then, sum all attenuated subband signals into the total attenuated signal.

For a complete description of this models, see [4].

This model calculates the attenuation of signals that propagate through fog or clouds.

Fog and cloud attenuation are the same atmospheric phenomenon. The ITU model,
*Recommendation ITU-R P.840-6: Attenuation due to clouds and fog* is
used. The model computes the specific attenuation (attenuation per kilometer), of a signal
as a function of liquid water density, signal frequency, and temperature. The model applies
to polarized and nonpolarized fields. The formula for specific attenuation at each frequency is

$${\gamma}_{c}={K}_{l}\left(f\right)M,$$

where *M* is the liquid water density in
gm/m^{3}. The quantity
*K _{l}(f)* is the specific attenuation coefficient
and depends on frequency. The cloud and fog attenuation model is valid for frequencies
10–1000 GHz. Units for the specific attenuation coefficient are
(dB/km)/(g/m

To compute the total attenuation for narrowband signals along
a path, the function multiplies the specific attenuation by the path
length *R*. Total attenuation is *L _{c} =
Rγ_{c}*.

You can apply the attenuation model to wideband signals. First, divide the wideband signal into frequency subbands, and apply narrowband attenuation to each subband. Then, sum all attenuated subband signals into the total attenuated signal.

For a complete description of this model, see [5]

This model calculates the attenuation of signals that propagate through regions of rainfall.

Electromagnetic signals are attenuate when propagating through
a region of rainfall. Rainfall attenuation is computed according to
the ITU rainfall model *Recommendation ITU-R P.838-3: Specific
attenuation model for rain for use in prediction methods*.
The model computes the specific attenuation (attenuation per kilometer)
of a signal as a function of rainfall rate, signal frequency, polarization,
and path elevation angle. To compute the attenuation, this model uses

$${\gamma}_{r}=k{r}^{\alpha},$$

where *r* is
the rain rate in mm/hr. The parameter *k* and exponent *α* depend
on the frequency, the polarization state, and the elevation angle
of the signal path. The specific attenuation model is valid for frequencies
from 1–1000 GHz.

To compute the total attenuation for narrowband signals along
a path, the function multiplies the specific attenuation by a propagation
distance, *R*. Then, total attenuation is *L _{r} =
Rγ_{r}*. Instead of using geometric
range as the propagation distance, the toolbox uses a modified range.
The modified range is the geometric range multiplied by a range factor

$$\frac{1}{1+\frac{R}{{R}_{0}}}$$

where

$${R}_{0}=35{e}^{-0.015r}$$

is the effective path
length in kilometers (see Seybold, J. *Introduction to RF
Propagation*.) When there is no rain, the effective path
length is 35 km. When the rain rate is, for example, 10 mm/hr, the
effective path length is 30.1 km. At short range, the propagation
distance is approximately the geometric range. For longer ranges,
the propagation distance asymptotically approaches the effective path
length.

You can apply the attenuation model to wideband signals. First, divide the wideband signal into frequency subbands and apply attenuation to each subband. Then, sum all attenuated subband signals into the total attenuated signal.

[1] Heath, R. Jr. et al. “An Overview of Signal Processing Techniques for Millimeter Wave MIMO Systems”, arXiv.org:1512.03007 [cs.IT], 2015.

[2] Tse, D. and P. Viswanath, *Fundamentals of
Wireless Communications*, Cambridge: Cambridge University
Press, 2005.

[3] Paulraj, A. *Introduction to Space-Time Wireless
Communications*, Cambridge: Cambridge University Press,
2003.

[4] Radiocommunication Sector of the International
Telecommunication Union. *Recommendation ITU-R P.676-10:
Attenuation by atmospheric gases*. 2013.

[5] Radiocommunication Sector of the International
Telecommunication Union. *Recommendation ITU-R P.840-6:
Attenuation due to clouds and fog*. 2013.

[6] Radiocommunication Sector of the International
Telecommunication Union. *Recommendation ITU-R P.838-3:
Specific attenuation model for rain for use in prediction methods*.
2005.

[7] Seybold, J. *Introduction to RF Propagation*.
New York: Wiley & Sons, 2005.

[8] Skolnik, M. *Introduction to Radar
Systems*, 3rd Ed. New York: McGraw-Hill, 2001.

Generate C and C++ code using MATLAB® Coder™.

Usage notes and limitations:

See System Objects in MATLAB Code Generation (MATLAB Coder).

`diagbfweights`

|`fogpl`

|`fspl`

|`gaspl`

|`rainpl`

|`rangeangle`

|`scatteringchanmtx`

|`waterfill`

아래 MATLAB 명령에 해당하는 링크를 클릭하셨습니다.

이 명령을 MATLAB 명령 창에 입력해 실행하십시오. 웹 브라우저에서는 MATLAB 명령을 지원하지 않습니다.

Choose a web site to get translated content where available and see local events and offers. Based on your location, we recommend that you select: .

Select web siteYou can also select a web site from the following list:

Select the China site (in Chinese or English) for best site performance. Other MathWorks country sites are not optimized for visits from your location.

- América Latina (Español)
- Canada (English)
- United States (English)

- Belgium (English)
- Denmark (English)
- Deutschland (Deutsch)
- España (Español)
- Finland (English)
- France (Français)
- Ireland (English)
- Italia (Italiano)
- Luxembourg (English)

- Netherlands (English)
- Norway (English)
- Österreich (Deutsch)
- Portugal (English)
- Sweden (English)
- Switzerland
- United Kingdom (English)