Documentation

### This is machine translation

Translated by
Mouseover text to see original. Click the button below to return to the English version of the page.

# phased.ScatteringMIMOChannel

Scattering MIMO channel

## Description

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:

1. 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.

2. 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.

### Note

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.

## Construction

`channel = phased.ScatteringMIMOChannel` creates a scattering MIMO propagation channel System object, `channel`.

`channel = phased.ScatteringMIMOChannel(Name,Value)` creates a System object, `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`).

## Properties

expand all

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

Example: `phased.URA`

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

Example: `phased.URA`

Signal 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`

Signal carrier frequency, specified as a positive real-valued scalar. Units are in Hz.

Example: `100e6`

Data Types: `double`

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`

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`

Ambient temperature, specified as a real-valued scalar. Units are in degrees Celsius.

Example: `20.0`

#### Dependencies

To enable this property, set `SpecifyAtmosphere` to `true`.

Data Types: `double`

Atmospheric 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`

#### Dependencies

To enable this property, set `SpecifyAtmosphere` to `true`.

Data Types: `double`

Atmospheric water vapor density, specified as a positive real-valued scalar. Units are in g/m3.

Example: `7.4`

#### Dependencies

To enable this property, set `SpecifyAtmosphere` to `true`.

Data Types: `double`

Liquid water density of fog or clouds, specified as a nonnegative real-valued scalar. Units are in g/m3. Typical values for liquid water density are 0.05 for medium fog and 0.5 for thick fog.

Example: `0.1`

#### Dependencies

To enable this property, set `SpecifyAtmosphere` to `true`.

Data Types: `double`

Rainfall rate, specified as a nonnegative scalar. Units are in mm/hr.

Example: `10.0`

#### Dependencies

To enable this property, set `SpecifyAtmosphere` to `true`.

Data Types: `double`

Sample 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`

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`

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`

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.

Maximum signal delay, specified as a positive scalar. Delays greater than this value are ignored. Units are in seconds.

#### Dependencies

To enable this property, set the `MaximumDelaySource` property to `'Property'`.

Data Types: `double`

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`

Position 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]`

#### Dependencies

To enable this property, set the `TransmitArrayMotionSource` property to `'Property'`.

Data Types: `double`

Orientation 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)`

#### Dependencies

To enable this property, set the `TransmitArrayMotionSource` property to `'Property'`.

Data Types: `double`

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`

Position 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]`

#### Dependencies

To enable this property, set the `ReceiveArrayMotionSource` property to `'Property'`.

Data Types: `double`

Orientation 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)`

#### Dependencies

To enable this property, set the `ReceiveArrayMotionSource` property to `'Property'`.

Data Types: `double`

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`

Number of scatterers, specified as a nonnegative integer.

Example: `9`

#### Dependencies

To enable this property, set the `ScattererSpecificationSource` property to `'Auto'`.

Data Types: `double`

Boundary 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]`

#### Dependencies

To enable this property, set the `ScattererSpecificationSource` property to `'Auto'`.

Data Types: `double`

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]`

#### Dependencies

To enable this property, set the `ScattererSpecificationSource` property to `'Property'`.

Data Types: `double`

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

Example: `2+1i`

#### Dependencies

To enable this property, set the `ScattererSpecificationSource` property to `'Property'`.

Data Types: `double`
Complex Number Support: Yes

Scattering matrices of the scatterers, specified as a complex–valued 2-by-2-by-Ns array where Ns 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.

#### Dependencies

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

Orientation of the scatterers, specified as a real–valued 3-by-3-by-Ns array where Ns 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)`

#### Dependencies

To enable this property, set the `ScatteringMatrixSource` property to `'Property'` and the `Polarization` property to `'Combined'` or `'Dual'`.

Data Types: `double`

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'`.

#### Dependencies

To enable this property, set the `ScattererSpecificationSource` property to `'Auto'`.

Random number generator seed, specified as a nonnegative integer less than 232.

Example: `5005`

#### Dependencies

To enable this property, set the `ScattererSpecificationSource` property to `'Auto'` and the `SeedSource` property to `'Property'`.

Data Types: `double`

## Methods

 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

## Examples

expand all

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 ```

expand all

## References

[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.