# comm.RicianChannel

Filter input signal through multipath Rician fading channel

## Description

The `comm.RicianChannel`

System object™ filters an input signal through a multipath Rician fading channel. For more
information on fading model processing, see the Methodology for Simulating
Multipath Fading Channels section.

To filter an input signal through a multipath Rician fading channel:

Create the

`comm.RicianChannel`

object and set its properties.Call the object with arguments, as if it were a function.

To learn more about how System objects work, see What Are System Objects?

## Creation

### Description

creates a
frequency-selective or frequency-flat multipath Rician fading channel System object. This
object filters a real or complex input signal through the multipath channel to obtain a
channel-impaired signal.`ricianchan`

= comm.RicianChannel

sets properties using one or more name-value arguments. For example,
`ricianchan`

= comm.RicianChannel(Name,Value)`'SampleRate',2`

sets the input signal sample rate to 2.

## Properties

Unless otherwise indicated, properties are *nontunable*, which means you cannot change their
values after calling the object. Objects lock when you call them, and the
`release`

function unlocks them.

If a property is *tunable*, you can change its value at
any time.

For more information on changing property values, see System Design in MATLAB Using System Objects.

`SampleRate`

— Input signal sample rate

`1`

(default) | positive scalar

Input signal sample rate in hertz, specified as a positive scalar.

**Data Types: **`double`

`PathDelays`

— Discrete path delay

`0`

(default) | scalar | row vector

Discrete path delay in seconds, specified as a scalar or row vector.

When you set

`PathDelays`

to a scalar, the channel is frequency flat.When you set

`PathDelays`

to a vector, the channel is frequency selective.

The `PathDelays`

and `AveragePathGains`

properties must be the same length.

**Data Types: **`double`

`AveragePathGains`

— Average gains of discrete paths

`0`

(default) | scalar | row vector

Average gains of the discrete paths in decibels, specified as a scalar or row
vector. The `AveragePathGains`

and `PathDelays`

properties must be
the same length.

**Data Types: **`double`

`NormalizePathGains`

— Normalize average path gains

`true`

or `1`

(default) | `false`

or `0`

Normalize average path gains, specified as one of these logical values:

`1`

(`true`

) — The fading processes are normalized so that the total power of the path gains, averaged over time, is 0 dB.`0`

(`false`

) — The total power of the path gains is not normalized.

The `AveragePathGains`

property
specifies the average powers of the path gains.

**Data Types: **`logical`

`KFactor`

— K-factor of Rician fading channel

`3`

(default) | positive scalar | 1-by-*N*_{P} vector of nonnegative
values

K-factor of Rician fading channel, specified as a positive scalar or a
1-by-*N*_{P} vector of nonnegative values.
*N*_{P} is the number of discrete path delays
specified by the `PathDelays`

property.

When you set

`KFactor`

to a scalar, the first discrete path is a Rician fading process with a Rician K-factor of`KFactor`

. Any remaining discrete paths are independent Rayleigh fading processes.When you set

`KFactor`

to a vector, the discrete path corresponding to a positive element of the`KFactor`

vector is a Rician fading process with a Rician K-factor specified by that element. The discrete path corresponding to any zero-valued elements of the`KFactor`

vector are Rayleigh fading processes. At least one element must be nonzero.

**Data Types: **`double`

`DirectPathDopplerShift`

— Doppler shifts for line-of-sight components

`0`

(default) | scalar | row vector

Doppler shifts for the line-of-sight components of the multipath Rician fading
channel, specified as a scalar or row vector. Units are in hertz. This property must be
the same size as the `KFactor`

property.

When you set

`DirectPathDopplerShift`

to a scalar, the value represents the line-of-sight component Doppler shift of the first discrete path. This path exhibits a Rician fading process.When you set

`DirectPathDopplerShift`

to a row vector, the discrete path corresponding to a positive element of the`KFactor`

vector is a Rician fading process. The corresponding element of`DirectPathDopplerShift`

specifies the line-of-sight component for the Doppler shift of that discrete path.

**Data Types: **`double`

`DirectPathInitialPhase`

— Initial phases for line-of-sight components

`0`

(default) | scalar | row vector

Initial phase for the line-of-sight components of a multipath Rician fading channel,
specified as a scalar or row vector. Units are in radians. This property must be the
same size as the `KFactor`

property.

When you set

`DirectPathInitialPhase`

to a scalar, the value represents the line-of-sight component initial phase of the first discrete path. This path exhibits a Rician fading process.When you set

`DirectPathInitialPhase`

to a row vector, the discrete path corresponding to a positive element of the`KFactor`

vector is a Rician fading process. The corresponding element of`DirectPathInitialPhase`

specifies the line-of-sight component initial phase of that discrete path.

**Data Types: **`double`

`MaximumDopplerShift`

— Maximum Doppler shift for all channel paths

`0.001`

(default) | nonnegative scalar

Maximum Doppler shift for all channel paths, specified as a nonnegative scalar. Units are in hertz.

The maximum Doppler shift limit applies to each channel path. When you set this
property to `0`

, the channel remains static for the entire input. You
can use the `reset`

object function to generate a new
channel realization. The `MaximumDopplerShift`

property value must be smaller than `SampleRate`

/10/*f*_{c} for each path.
*f*_{c} is the cutoff frequency factor of the
path. For most Doppler spectrum types, the value of
*f*_{c} is 1. For Gaussian and bi-Gaussian
Doppler spectrum types, the value of *f*_{c} is
dependent on the Doppler spectrum structure fields. For more details about how
*f*_{c} is defined, see the Cutoff Frequency Factor
section.

**Data Types: **`double`

`DopplerSpectrum`

— Doppler spectrum shape for all channel paths

`doppler('Jakes')`

(default) | Doppler spectrum structure | 1-by-*N*_{P} cell array of Doppler spectrum
structures

Doppler spectrum shape for all channel paths, specified as a Doppler spectrum
structure or a 1-by-*N*_{P} cell array of Doppler
spectrum structures. These Doppler spectrum structures must be outputs of the form
returned from the `doppler`

function.
*N*_{P} is the number of discrete delay paths
specified by the `PathDelays`

property. The
`MaximumDopplerShift`

property defines the maximum Doppler shift value that the
`DopplerSpectrum`

property permits when you specify the Doppler spectrum.

When you set

`DopplerSpectrum`

to a single Doppler spectrum structure, all paths have the same specified Doppler spectrum.When you set

`DopplerSpectrum`

to a cell array of Doppler spectrum structures, each path has the Doppler spectrum specified by the corresponding structure in the cell array.

Specify options for the spectrum type by using the `specType`

input to the `doppler`

function. If you set the `FadingTechnique`

property to
`'Sum of sinusoids'`

, you must set
`DopplerSpectrum`

to `doppler('Jakes')`

.

#### Dependencies

To enable this property, set the `MaximumDopplerShift`

property to a positive scalar.

**Data Types: **`struct`

| `cell`

`ChannelFiltering`

— Channel filtering

`true`

or `1`

(default) | `false`

or `0`

Channel filtering, specified as one of these logical values:

`1`

(`true`

) — The channel accepts an input signal and produces a filtered output signal.`0`

(`false`

) — The object does not accept an input signal, produces no filtered output signal, and outputs only channel path gains. You must specify the duration of the fading process by using the`NumSamples`

property.

**Data Types: **`logical`

`PathGainsOutputPort`

— Output channel path gains

`false`

or `0`

(default) | `true`

or `1`

Output channel path gains, specified as a logical `0`

(`false`

) or `1`

(`true`

). Set this
property to `true`

to output the channel path gains of the underlying
fading process.

#### Dependencies

To enable this property, set the `ChannelFiltering`

property to `true`

.

**Data Types: **`logical`

`NumSamples`

— Number of samples

`100`

(default) | nonnegative integer

Number of samples used for the duration of the fading process, specified as a nonnegative integer.

**Tunable: **Yes

#### Dependencies

To enable this property, set the `ChannelFiltering`

property to `false`

.

**Data Types: **`double`

`OutputDataType`

— Path gain output data type

`'double'`

(default) | `'single'`

Path gain output data type, specified as `'double'`

or
`'single'`

.

#### Dependencies

To enable this property, set the `ChannelFiltering`

property to `false`

.

**Data Types: **`char`

| `string`

`FadingTechnique`

— Channel model fading technique

`'Filtered Gaussian noise'`

(default) | `'Sum of sinusoids'`

Channel model fading technique, specified as ```
'Filtered Gaussian
noise'
```

or `'Sum of sinusoids'`

.

**Data Types: **`char`

| `string`

`NumSinusoids`

— Number of sinusoids

`48`

(default) | positive integer

Number of sinusoids used to model the fading process, specified as a positive integer.

#### Dependencies

To enable this property, set the `FadingTechnique`

property
to `'Sum of sinusoids'`

.

**Data Types: **`double`

`InitialTimeSource`

— Source to control start time of fading process

`'Property'`

(default) | `'Input port'`

Source to control the start time of the fading process, specified as
`'Property'`

or `'Input port'`

.

When you set

`InitialTimeSource`

to`'Property'`

, set the initial time offset by using the`InitialTime`

property.When you set

`InitialTimeSource`

to`'Input port'`

, specify the start time of the fading process by using the`inittime`

input argument. The input value can change in consecutive calls to the object.

#### Dependencies

To enable this property, set the `FadingTechnique`

property
to `'Sum of sinusoids'`

.

**Data Types: **`char`

| `string`

`InitialTime`

— Initial time offset

`0`

(default) | nonnegative scalar

Initial time offset for the fading model in seconds, specified as a nonnegative scalar.

When `mod`

(`InitialTime`

/`SampleRate`

) is nonzero, the initial time offset is rounded up to the nearest
sample position.

#### Dependencies

To enable this property, set the `FadingTechnique`

property
to `'Sum of sinusoids'`

and the `InitialTimeSource`

property to `'Property'`

.

**Data Types: **`double`

`RandomStream`

— Source of random number stream

`'Global stream'`

(default) | `'mt19937ar with seed'`

Source of the random number stream, specified as `'Global stream'`

or `'mt19937ar with seed'`

.

When you specify

`'Global stream'`

, the object uses the current global random number stream for random number generation. In this case, the`reset`

object function resets only the filters.When you specify

`'mt19937ar with seed'`

, the object uses the mt19937ar algorithm for random number generation. In this case, the`reset`

object function resets the filters and reinitializes the random number stream to the value of the`Seed`

property.

**Data Types: **`char`

| `string`

`Seed`

— Initial seed of mt19937ar random number stream

`73`

(default) | nonnegative integer

Initial seed of the mt19937ar random number stream generator algorithm, specified as
a nonnegative integer. When you call the `reset`

object function, it
reinitializes the mt19937ar random number stream to the `Seed`

value.

#### Dependencies

To enable this property, set the `RandomStream`

property to
`'mt19937ar with seed'`

.

**Data Types: **`double`

`Visualization`

— Channel visualization

`'Off'`

(default) | `'Impulse response'`

| `'Frequency response'`

| `'Impulse and frequency responses'`

| `'Doppler spectrum'`

Channel visualization, specified as `'Off'`

, ```
'Impulse
response'
```

, `'Frequency response'`

, ```
'Impulse and
frequency responses'
```

, or `'Doppler spectrum'`

. For more
information, see the Channel Visualization topic.

#### Dependencies

To enable this property, set the `FadingTechnique`

property
to `'Filtered Gaussian noise'`

.

**Data Types: **`char`

| `string`

`PathsForDopplerDisplay`

— Path used for displaying Doppler spectrum

`1`

(default) | positive integer

Path used for displaying the Doppler spectrum, specified as a positive integer in
the range [1, *N*_{P}].
*N*_{P} is the number of discrete delay paths
specified by the `PathDelays`

property. Use this
property to select the discrete path used in constructing a Doppler spectrum plot.

#### Dependencies

To enable this property, set the `Visualization`

property to
`'Doppler spectrum'`

.

**Data Types: **`double`

`SamplesToDisplay`

— Percentage of samples to display

`'25%'`

(default) | `'10%'`

| `'50%'`

| `'100%'`

Percentage of samples to display, specified as `'25%'`

,
`'10%'`

, `'50%'`

, or `'100%'`

.
Increasing the percentage improves display accuracy at the expense of simulation
speed.

#### Dependencies

To enable this property, set the `Visualization`

property to
`'Impulse response'`

, `'Frequency response'`

, or
`'Impulse and frequency responses'`

.

**Data Types: **`char`

| `string`

## Usage

### Syntax

### Description

filters input signal `y`

= ricianchan(`x`

)`x`

through a multipath Rician fading channel
and returns the result in `y`

.

To enable this syntax, set the `ChannelFiltering`

property
to `true`

.

specifies a start time for the fading process.`y`

= ricianchan(`x`

,`inittime`

)

To enable this syntax, set the `FadingTechnique`

property to
`'Sum of sinusoids'`

and the `InitialTimeSource`

property to `'Input port'`

.

`[`

also returns the channel path gains of the underlying multipath Rician fading process in
`y`

,`pathgains`

] = ricianchan(___)`pathgains`

using any of the input argument combinations in the
previous syntaxes.

To enable this syntax, set the `PathGainsOutputPort`

property to `true`

.

returns the
channel path gains of the underlying fading process. In this case, the channel requires
no input signal and acts as a source of path gains.`pathgains`

= ricianchan()

To enable this syntax, set the `ChannelFiltering`

property
to `false`

.

returns the channel path gains of the underlying fading process beginning at the
specified initial time. In this case, the channel requires no input signal and acts as a
source of path gains.`pathgains`

= ricianchan(`inittime`

)

To enable this syntax, set the `FadingTechnique`

property to
`'Sum of sinusoids'`

, the `InitialTimeSource`

property to `'Input port'`

, and the `ChannelFiltering`

property
to `false`

.

### Input Arguments

`x`

— Input signal

*N*_{S}-by-1 vector

Input signal, specified as an *N*_{S}-by-1
vector, where *N*_{S} is the number of
samples.

**Data Types: **`single`

| `double`

**Complex Number Support: **Yes

`inittime`

— Initial time offset

`0`

| nonnegative scalar

Initial time offset in seconds, specified as a nonnegative scalar.

When `mod`

(`inittime`

/`SampleRate`

) is nonzero, the initial time offset is rounded up to the nearest
sample position.

**Data Types: **`single`

| `double`

### Output Arguments

`y`

— Output signal

*N*_{S}-by-1 vector

Output signal, returned as an *N*_{S}-by-1
vector of complex values with the same data precision as input signal `x`

.
*N*_{S} is the number of samples.

`pathgains`

— Output path gains

*N*_{S}-by-*N*_{P}
matrix

Output path gains, returned as an
*N*_{S}-by-*N*_{P}
matrix. *N*_{S} is the number of samples.
*N*_{P} is the number of discrete delay paths
specified by the `PathDelays`

property.
`pathgains`

contains complex values.

When you set the `ChannelFiltering`

property to `false`

, the data type of this output has the same
precision as the input signal `x`

. When you
set the `ChannelFiltering`

property to `true`

, the data type of this output is specified by the
`OutputDataType`

property.

## Object Functions

To use an object function, specify the
System object as the first input argument. For
example, to release system resources of a System object named `obj`

, use
this syntax:

release(obj)

## Examples

### Produce Same Rician Channel Outputs Using Two Random Number Generation Methods

Produce the same multipath Rician fading channel response by using two different methods for random number generation. The multipath Rician fading channel System object includes two methods for random number generation. You can use the current global stream or the mt19937ar algorithm with a specified seed. By interacting with the global stream, the System object can produce the same outputs from the two methods.

Create a PSK modulator System object to modulate randomly generated data.

pskModulator = comm.PSKModulator; insig = randi([0,pskModulator.ModulationOrder-1],1024,1); channelInput = pskModulator(insig);

Create a multipath Rician fading channel System object, specifying the random number generation method as the my19937ar algorithm and the random number seed as 73.

ricianchan = comm.RicianChannel( ... 'SampleRate',1e6, ... 'PathDelays',[0.0 0.5 1.2]*1e-6, ... 'AveragePathGains',[0.1 0.5 0.2], ... 'KFactor',2.8, ... 'DirectPathDopplerShift',5.0, ... 'DirectPathInitialPhase',0.5, ... 'MaximumDopplerShift',50, ... 'DopplerSpectrum',doppler('Bell', 8), ... 'RandomStream','mt19937ar with seed', ... 'Seed',73, ... 'PathGainsOutputPort',true);

Filter the modulated data by using the multipath Rician fading channel System object.

[RicianChanOut1,RicianPathGains1] = ricianchan(channelInput);

Set the System object to use the global stream for random number generation.

```
release(ricianchan);
ricianchan.RandomStream = 'Global stream';
```

Set the global stream to have the same seed that you specified when creating the multipath Rician fading channel System object.

rng(73)

Filter the modulated data by using the multipath Rician fading channel System object again.

[RicianChanOut2,RicianPathGains2] = ricianchan(channelInput);

Verify that the channel and path gain outputs are the same for each of the two methods.

isequal(RicianChanOut1,RicianChanOut2)

`ans = `*logical*
1

isequal(RicianPathGains1,RicianPathGains2)

`ans = `*logical*
1

### Display Impulse and Frequency Responses of Multipath Rician Fading Channel

Display the impulse and frequency responses of a frequency-selective multipath Rician fading channel that is configured to disable channel filtering.

Define simulation variables. Specify path delays and gains by using the ITU pedestrian B channel configuration.

fs = 3.84e6; % Sample rate in Hz pathDelays = [0 200 800 1200 2300 3700]*1e-9; % in seconds avgPathGains = [0 -0.9 -4.9 -8 -7.8 -23.9]; % dB kfact = 10; % Rician K-factor fD = 50; % Max Doppler shift in Hz

Create a multipath Rician fading channel System object to visualize the impulse response and frequency response plots.

ricianChan = comm.RicianChannel( ... SampleRate=fs, ... PathDelays=pathDelays, ... AveragePathGains=avgPathGains, ... KFactor=kfact, ... MaximumDopplerShift=fD, ... ChannelFiltering=false, ... Visualization='Impulse and frequency responses');

Visualize the channel response by running the multipath Rician fading channel System object with no input signal. The impulse response plot enables you to identify the individual paths and their corresponding filter coefficients. The frequency response plot shows the frequency-selective nature of the ITU pedestrian B channel.

ricianChan();

### Model Rician Channel Using Sum-of-Sinusoids Technique

Show that the channel state is maintained for discontinuous transmissions by using multipath Rician fading channel System objects configured to use the sum-of-sinusoids fading technique. Observe discontinuous channel response segments overlaid on a continuous channel response.

Set the channel properties.

fs = 1000; % Sample rate in Hz pathDelays = [0 2.5e-3]; % In seconds pathPower = [0 -6]; % In dB fD = 5; % Maximum Doppler shift in Hz ns = 1000; % Number of samples nsdel = 100; % Number of samples for delayed paths

Define a continuous time span and three discontinuous time segments over which to plot and view the channel response. View a 1000-sample continuous channel response that starts at time 0 and three 100-sample channel responses that start at times 0.1, 0.4, and 0.7 seconds, respectively.

to0 = 0.0; to1 = 0.1; to2 = 0.5; to3 = 0.8; t0 = (to0:ns-1)/fs; % Transmission 0 t1 = to1+(0:nsdel-1)/fs; % Transmission 1 t2 = to2+(0:nsdel-1)/fs; % Transmission 2 t3 = to3+(0:nsdel-1)/fs; % Transmission 3

Create a frequency-flat multipath Rician fading System object, specifying a 1000 Hz sampling rate, the sum-of-sinusoids fading technique, disabled channel filtering, and the number of samples to view. Specify a seed value so that results can be repeated. Use the default `InitialTime`

property setting so that the fading channel is simulated from time 0.

ricianchan1 = comm.RicianChannel('SampleRate',fs, ... 'MaximumDopplerShift',fD, ... 'RandomStream','mt19937ar with seed', ... 'Seed',17, ... 'FadingTechnique','Sum of sinusoids', ... 'ChannelFiltering',false, ... 'NumSamples',ns);

Create a clone of the multipath Rician fading channel System object. Set the number of samples for the delayed paths. Set the source for the initial time so that you can specify the fading channel offset time as an input argument when using the System object.

```
ricianchan2 = clone(ricianchan1);
ricianchan2.InitialTimeSource = 'Input port';
ricianchan2.NumSamples = nsdel;
```

Save the path gain output for the continuous channel response by using the `ricianchan1`

object and for the discontinuous delayed channel responses by using the `ricianchan2`

object with the initial time offsets provided as input arguments.

pg0 = ricianchan1(); pg1 = ricianchan2(to1); pg2 = ricianchan2(to2); pg3 = ricianchan2(to3);

Compare the number of samples processed by the two channels by using the `info`

object function. The `ricianchan1`

object processed 1000 samples, while the `ricianhan2`

object processed only 300 samples.

G = info(ricianchan1); H = info(ricianchan2); [G.NumSamplesProcessed H.NumSamplesProcessed]

`ans = `*1×2*
1000 300

Convert the path gains into decibels.

pathGain0 = 20*log10(abs(pg0)); pathGain1 = 20*log10(abs(pg1)); pathGain2 = 20*log10(abs(pg2)); pathGain3 = 20*log10(abs(pg3));

Plot the path gains for the continuous and discontinuous cases. The gains for the three segments match the gain for the continuous case. Because the channel characteristics are maintained even when data is not transmitted, the alignment of the two plots shows that the sum-of-sinusoids technique is suited to the simulation of packetized data.

plot(t0,pathGain0,'r--') hold on plot(t1,pathGain1,'b') plot(t2,pathGain2,'b') plot(t3,pathGain3,'b') grid xlabel('Time (s)') ylabel('Path Gain (dB)') legend('Continuous','Discontinuous','location','nw') title('Continuous and Discontinuous Transmission Path Gains')

### Reproduce Multipath Rican Fading Channel Response

Reproduce the multipath Rician fading channel output by using the `ChannelFilterCoefficients`

property returned by the `info`

object function of the `comm.RicianChannel`

System object.

Create a multipath Rician fading channel System object, defining two paths. Generate data to pass through the channel.

ricianchan = comm.RicianChannel( ... 'SampleRate',1000, ... 'PathDelays',[0 1e-3], ... 'AveragePathGains',[0 -2], ... 'PathGainsOutputPort',true)

ricianchan = comm.RicianChannel with properties: SampleRate: 1000 PathDelays: [0 1.0000e-03] AveragePathGains: [0 -2] NormalizePathGains: true KFactor: 3 DirectPathDopplerShift: 0 DirectPathInitialPhase: 0 MaximumDopplerShift: 1.0000e-03 DopplerSpectrum: [1x1 struct] ChannelFiltering: true PathGainsOutputPort: true Show all properties

data = randi([0 1],600,1);

Pass data through the channel. Assign the `ChannelFilterCoefficients`

property value to the variable `coeff`

.

[chanout1,pg] = ricianchan(data); chaninfo = info(ricianchan)

`chaninfo = `*struct with fields:*
ChannelFilterDelay: 0
ChannelFilterCoefficients: [2x2 double]
NumSamplesProcessed: 600

coeff = chaninfo.ChannelFilterCoefficients;

Calculate the fractional delayed input signal at the path delay locations stored in `coeff`

.

Np = length(ricianchan.PathDelays); fracdelaydata = zeros(size(data,1),Np); for ii = 1:Np fracdelaydata(:,ii) = filter(coeff(ii,:),1,data); end

Apply the path gains and sum the results for all paths.

chanout2 = sum(pg .* fracdelaydata,2);

Compare the output of the multipath Rician fading channel System object to the output reproduced using the path gains and the `ChannelFilterCoefficients`

property of the multipath Rician fading channel System object.

isequal(chanout1,chanout2)

`ans = `*logical*
1

### Compare PDF of Empirical and Theoretical Rician Channel

Compute and plot the empirical and theoretical probability density function (PDF) for a Rician channel with one path.

Initialize parameters and create a Rician channel System object that does not apply channel filtering.

Ns = 1.92e6; Rs = 1.92e6; dopplerShift = 2000; KFactor = -3; % In dB KFactorLin = 10.^(KFactor/10); % Linear units chan = comm.RicianChannel( ... 'SampleRate',Rs, ... 'PathDelays',0, ... 'KFactor',KFactorLin, ... 'AveragePathGains',0, ... 'MaximumDopplerShift',dopplerShift, ... 'ChannelFiltering',false, ... 'NumSamples',Ns, ... 'FadingTechnique','Sum of sinusoids');

Compute and plot the empirical and theoretical PDF for the Rician channel, by using the `fitdist`

(Statistics and Machine Learning Toolbox) and `pdf`

(Statistics and Machine Learning Toolbox) functions.

figure; hold on; % Empirical PDF plot gain = chan(); pd = fitdist(abs(gain),'Kernel','BandWidth',.01); r = 0:.1:3; y = pdf(pd,r); plot(r,y) % Theoretical PDF plot s = sqrt(KFactorLin)/sqrt(KFactorLin+1); sigma = sqrt(1/2)/sqrt(KFactorLin+1); exp_pdf_amplitude = pdf('Rician',r,s,sigma); plot(r,exp_pdf_amplitude') legend('Empirical','Theoretical') title('Empirical and Theoretical PDF Curves')

### Compare CDF of Empirical and Theoretical Rician Channel

Compute and plot the empirical and theoretical cumulative distribution function (CDF) for a Rician channel with one path.

Initialize parameters and create a Rician channel System object that does not perform channel filtering.

Ns = 1.92e6; Rs = 1.92e6; dopplerShift = 2000; KFactor = -3; % In dB KFactorLin = 10.^(KFactor/10); % Linear units chan = comm.RicianChannel( ... 'SampleRate',Rs, ... 'PathDelays',0, ... 'KFactor',KFactorLin, ... 'AveragePathGains',0, ... 'MaximumDopplerShift',dopplerShift, ... 'ChannelFiltering',false, ... 'NumSamples',Ns, ... 'FadingTechnique','Sum of sinusoids');

Compute and plot the empirical and theoretical CDF for the Rician channel by using the `ecdf`

(Statistics and Machine Learning Toolbox) and `cdf`

(Statistics and Machine Learning Toolbox) functions. Compute the empirical CDF by using the path gains.

% Empirical CDF plot g = chan(); ecdf(abs(g)); hold on; % Theoretical CDF plot r = 0:.1:3; s = sqrt(KFactorLin)/sqrt(KFactorLin+1); sigma = sqrt(1/2)/sqrt(KFactorLin+1); exp_cdf_amplitude = cdf('Rician',r,s,sigma); plot(r,exp_cdf_amplitude') legend('Emp','Theor') title('Empirical and Theoretical CDF Curves')

## More About

### Cutoff Frequency Factor

The cutoff frequency factor,
*f*_{c}, is dependent on the type of Doppler spectrum.

For any Doppler spectrum type other than Gaussian and bi-Gaussian,

*f*_{c}equals 1.For a

`doppler`

`('Gaussian')`

spectrum type,*f*_{c}equals`NormalizedStandardDeviation`

$$\text{\hspace{0.17em}}\times \text{\hspace{0.17em}}\sqrt{2\mathrm{log}2}$$.For a

`doppler`

`('BiGaussian')`

spectrum type:If the

`PowerGains`

`(1)`

and`NormalizedCenterFrequencies`

`(2)`

field values are both`0`

, then*f*_{c}equals`NormalizedStandardDeviation`

`(1)`

$$\text{\hspace{0.17em}}\times \text{\hspace{0.17em}}\sqrt{2\mathrm{log}2}$$.If the

`PowerGains`

`(2)`

and`NormalizedCenterFrequencies`

`(1)`

field values are both`0`

, then*f*_{c}equals`NormalizedStandardDeviation`

`(2)`

$$\text{\hspace{0.17em}}\times \text{\hspace{0.17em}}\sqrt{2\mathrm{log}2}$$.If the

`NormalizedCenterFrequencies`

field value is`[0,0]`

and the`NormalizedStandardDeviation`

field has two identical elements, then*f*_{c}equals`NormalizedStandardDeviation`

`(1)`

$$\text{\hspace{0.17em}}\times \text{\hspace{0.17em}}\sqrt{2\mathrm{log}2}$$.In all other cases,

*f*_{c}equals 1.

## References

[1] Oestges, Claude, and Bruno Clerckx. *MIMO Wireless Communications: From Real-World Propagation to Space-Time Code Design*. 1st ed. Boston, MA: Elsevier, 2007.

[2] Correia, Luis M., and European Cooperation in the Field of Scientific and Technical Research (Organization), eds. *Mobile Broadband Multimedia Networks: Techniques, Models and Tools for 4G*. 1st ed. Amsterdam ; Boston: Elsevier/Academic Press, 2006.

[3] Kermoal, J.P., L. Schumacher, K.I. Pedersen, P.E. Mogensen, and F. Frederiksen. “A Stochastic MIMO Radio Channel Model with Experimental Validation.” *IEEE Journal on Selected Areas in Communications* 20, no. 6 (August 2002): 1211–26. https://doi.org/10.1109/JSAC.2002.801223.

[4] Jeruchim, Michel C., Philip Balaban, and K. Sam Shanmugan. *Simulation of Communication Systems*. Second edition. Boston, MA: Springer US, 2000.

[5] Patzold, M., Cheng-Xiang Wang, and B. Hogstad. “Two New Sum-of-Sinusoids-Based Methods for the Efficient Generation of Multiple Uncorrelated Rayleigh Fading Waveforms.” *IEEE Transactions on Wireless Communications* 8, no. 6 (June 2009): 3122–31. https://doi.org/10.1109/TWC.2009.080769.

## Extended Capabilities

### C/C++ Code Generation

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

Usage notes and limitations:

To generate C code, set the

`DopplerSpectrum`

property to a single Doppler spectrum structure.Code generation is available only when you set the

`Visualization`

property to`'Off'`

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

## Version History

**Introduced in R2013b**

### R2022b: Updates to channel visualization display

The channel visualization feature now presents:

Configuration settings in the bottom toolbar on the plot window.

Plots side-by-side in one window when you select the

`Impulse and frequency response`

channel visualization option.

## Open Example

You have a modified version of this example. Do you want to open this example with your edits?

## MATLAB Command

You clicked a link that corresponds to this MATLAB command:

Run the command by entering it in the MATLAB Command Window. Web browsers do not support MATLAB commands.

Select a Web Site

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

You can also select a web site from the following list:

## How to Get Best Site Performance

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

### Americas

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

### Europe

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