lutzLMSChannel

Filter input signal through Lutz LMS frequency-flat fading channel

Since R2022b

Description

The lutzLMSChannel System object™ filters a real or complex input signal through a Lutz land mobile-satellite (LMS) frequency-flat fading communication channel, as defined in [1].

To filter an input signal through a Lutz LMS time-varying channel:

1. Create the lutzLMSChannel object and set its properties.

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

Syntax

chan = lutzLMSChannel

chan = lutzLMSChannel(Name=Value)

Description

chan = lutzLMSChannel creates a Lutz LMS frequency-flat fading channel System object. Use this channel to simulate an LMS time-varying channel for a single geostationary satellite operating in the L-band.

The default System object parameters are set to a scenario in which the mobile is moving at a constant speed of 3 km/hr on a highway with a conical spiral antenna operating at a 1.54 GHz carrier frequency and a satellite elevation angle of 34 degrees, as specified in [1].

chan = lutzLMSChannel(Name=Value) sets properties using one or more name-value arguments. For example, SampleRate=20e3 sets the input signal sample rate to 20e3.

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

7.68e6 (default) | positive scalar

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

Data Types: double

InitialState — Initial state of channel

"Good" (default) | "Bad"

Initial state of the channel, specified as "Good" or "Bad".

Tunable: Yes

Data Types: char | string

KFactor — K-factor of Rician fading channel

11.7 (default) | real scalar

K-factor of the Rician fading channel in dB, specified as a real scalar. This property applies only when the channel state is good.

Tunable: Yes

Data Types: double

LogNormalFading — Fading parameters of Rayleigh log-normal fading channel

[-8.8 3.8] (default) | two-element vector

Fading parameters of the Rayleigh log-normal fading channel in dB, specified as a two-element vector. The first element corresponds to the mean power level due to shadowing. Nominally, the mean power level due to shadowing is a negative value. The second element corresponds to the standard deviation of power level due to shadowing.

This property applies only when the channel state is bad.

Tunable: Yes

Data Types: double

StateDurationDistribution — Distribution type used for state duration

"Exponential" (default) | "None"

Distribution type used for state duration, specified as one of these values.

• "Exponential" — The duration of each state follows an exponential distribution. The MeanStateDuration property specifies the mean duration of each state.

• "None" — The MeanStateDuration property directly specifies the duration of each state.

Tunable: Yes

Data Types: char | string

MeanStateDuration — Mean duration of each state

[1800 14.4] (default) | two-element vector

Mean duration of each state in seconds, specified as a two-element vector. The first element corresponds to the mean duration of the good state, and the second element corresponds to the mean duration of the bad state. Both the elements must be nonzero values.

Tunable: Yes

Data Types: double

MaximumDopplerShift — Maximum Doppler shift due to mobile movement

4.2807 (default) | nonnegative scalar

Maximum Doppler shift due to mobile movement in Hz, specified as a nonnegative scalar.

When this property value is 0, the channel is static. The default value of 4.2807 Hz corresponds to a mobile speed of 3 km/hr at a carrier frequency of 1.54 GHz.

Data Types: double

ChannelFiltering — Channel filtering

true or 1 (default) | false or 0

Channel filtering, specified as one of these logical values.

• 1 (true) — The object accepts an input signal and produces a filtered output signal, in addition to the channel path gains, sample times, and state series.

• 0 (false) — The object does not accept an input signal, produces no filtered output signal, and outputs only channel path gains, sample times, and state series. You must specify the duration of the fading process by using the NumSamples property, and the sampling rate by using the SampleRate property.

Data Types: logical

NumSamples — Number of time samples

7680 (default) | nonnegative integer

Number of time samples used to set the duration of the fading process realization, specified as a nonnegative integer.

Tunable: Yes

Dependencies

To enable this property, set ChannelFiltering property to false.

Data Types: double

OutputDataType — Data type of step method outputs

"double" (default) | "single"

Data type of step method outputs, specified as one of these values.

• "double"

• "single"

Dependencies

To enable this property, set 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 used

48 (default) | positive integer

Number of sinusoids used to generate the Doppler fading samples, specified as a positive integer.

Dependencies

To enable this property, set the FadingTechnique property to "Sum of sinusoids".

Data Types: double | uint16

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 uniformly and normally distributed 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 uniformly and normally distributed 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

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

Visualization — Channel visualization

"Off" (default) | "Impulse response" | "Frequency response" | "Impulse and frequency responses" | "Doppler spectrum"

Channel visualization, specified as one of these options.

• "Off"

• "Impulse response"

• "Frequency response"

• "Impulse and frequency responses"

• "Doppler spectrum"

When you set this property to enable the visualization, selected channel characteristics are animated in separate figures, with each System object call.

For more information, see Channel Visualization.

Data Types: char | string

TimeShare — Time share of channel in good and bad states

[0.9921 0.0079] (default) | two-element vector

This property is read-only.

Time share of the channel in good and bad states, returned as a two-element vector. The first element is the ratio of the good state mean duration to the sum of good and bad state mean durations. The second element is the ratio of the bad state mean duration to the sum of good and bad state mean durations.

Data Types: double

Usage

Syntax

[pathgains,sampletimes,stateseries] = chan()

[y,pathgains,sampletimes,stateseries] = chan(x)

Description

[pathgains,sampletimes,stateseries] = chan() produces path gains, pathgains, sample times, sampletimes, and state series, stateseries for a Lutz LMS frequency-flat fading channel.

In this case, the System object acts as a source of path gains, sample times, and state series.

Specify the duration of the fading process by using the NumSamples property. Specify the data type of pathgains and sampletimes using the OutputDataType property.

Note

This syntax is applicable when you set the ChannelFiltering property to false.

[y,pathgains,sampletimes,stateseries] = chan(x) filters the input signal, x, through a Lutz LMS frequency-flat fading channel, and returns the output channel-impaired signal in y, in addition to the outputs in the previous syntax.

Note

This syntax is applicable when you set the ChannelFiltering property to true.

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 input samples.

Data Types: single | double
Complex Number Support: Yes

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 and length as the input signal x. N_S is the number of input samples.

Data Types: single | double
Complex Number Support: Yes

pathgains — Channel path gains of fading process

N_S-by-1 vector

Channel path gains of fading process, returned as an N_S-by-1 vector of complex values.

• When you set the ChannelFiltering property to true, pathgains is of the same data precision as the input signal x, and N_S is the number of input samples.

• When you set the ChannelFiltering property to false, pathgains is of the same data precision as the OutputDataType property and N_S is equal to the NumSamples property.

Data Types: single | double
Complex Number Support: Yes

sampletimes — Sample times of channel snapshots

N_S-by-1 vector

Sample times of channel snapshots, returned as an N_S-by-1 vector.

• When you set the ChannelFiltering property to true, sampletimes is of the same data precision as the input signal x, and N_S is the number of input samples.

• When you set the ChannelFiltering property to false, sampletimes is of the same data precision as the OutputDataType property and N_S is equal to the NumSamples property.

Data Types: single | double

stateseries — State series of channel

N_S-by-1 vector

State series of the channel, returned as an N_S-by-1 vector. Each value of this vector describes the state in which channel is present for that channel snapshot. A value of 0 represents bad state. A value of 1 represents good state. A value between 0 and 1 represents a state transition.

• When you set the ChannelFiltering property to true, N_S is the number of input samples.

• When you set the ChannelFiltering property to false, N_S is equal to the NumSamples property.

stateseries is of the data type logical.

Data Types: logical

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)

Specific to lutzLMSChannel

info	Characteristic information about object

Common to All System Objects

step	Run System object algorithm
release	Release resources and allow changes to System object property values and input characteristics
clone	Create duplicate System object
isLocked	Determine if System object is in use
reset	Reset internal states of System object

Examples

Create and Configure Lutz LMS Channel

Define the channel configuration using a lutzLMSChannel System object and set the properties to these values.

• Symbol rate: 4800 symbols/sec (Assume sample rate to be equal to symbol rate)

• Product of the maximum Doppler frequency and symbol duration that indicates a normalized measure of channel state time variations (fd*T): 0.01

• Rice factor (K-factor): 20 dB

• Fading parameters of Rayleigh log-normal fading channel in bad state: mean (mu): -20.8 dB and standard deviation (sigma): -0.09 dB

• Fading signal (Doppler Spectrum): Jakes model with sum of sinusoids technique (10 sinusoids)

• Good state time-share parameter (X): 0.9

• Mean duration of shadowing period (Ct): 10 sec

chan = lutzLMSChannel;
chan.SampleRate = 4800;                    % Assuming same as symbol rate
chan.MaximumDopplerShift = 48;             % fd = 0.01/T = 0.01*SymbolRate
chan.KFactor = 20;                         % Rice factor
chan.LogNormalFading = [-20.8 -0.09];      % [mu sigma]
chan.MeanStateDuration = [9 1];            % [X*Ct (1-X)*Ct];
chan.FadingTechnique = "Sum of sinusoids";
chan.NumSinusoids = 10;

Display the channel characteristics.

disp(chan)

  lutzLMSChannel with properties:

                   SampleRate: 4800
                 InitialState: "Good"
                      KFactor: 20
              LogNormalFading: [-20.8000 -0.0900]
    StateDurationDistribution: "Exponential"
            MeanStateDuration: [9 1]
          MaximumDopplerShift: 48
             ChannelFiltering: true

  Use get to show all properties

Model Lutz LMS Channel Using Lutz IEEE Paper Configuration

Model the Lutz LMS channel using the configuration entries from the Lutz IEEE paper (Table II), as defined in the IEEE Transactions on Vehicular Technology article (stated in the References section).

Define the channel configuration using a lutzLMSChannel System object and set the properties to these values.

• Rician K-factor (k): 10.2

• Fading parameters of Rayleigh log-normal fading channel in bad state: mean (mu): -8.9 dB and standard deviation (sig): 5.1 dB

• Mean duration of good state, in meters (Dg): 90

• Mean duration of bad state, in meters (Db): 29

• Assume mobile speed is 10 km/hr at 1.54 GHz carrier frequency

v = 10;                      % Mobile speed in km/hr
v_ms = (v*1000/3600);        % Mobile speed in m/s
fc = 1.54e9;                 % Carrier frequency in Hz
c = physconst("lightspeed"); % Speed of light in m/s
fd = v_ms/c*fc;              % Mobile maximum Doppler frequency in Hz
 
k = 10.2;                    % Rician K-factor in dB
mu = -8.9;                   % Bad state mean
sig = 5.1;                   % Bad state standard deviation
 
% Get the mean state duration in seconds
Dg = 90;                     % Mean duration of good state in m
Db = 29;                     % Mean duration of bad state in m
Dg_sec = Dg/v_ms;            % Mean duration of good state in sec
Db_sec = Db/v_ms;            % Mean duration of bad state in sec
 
chan = lutzLMSChannel;
chan.MaximumDopplerShift = fd;
chan.KFactor = k;
chan.LogNormalFading = [mu sig];
chan.MeanStateDuration = [Dg_sec Db_sec];

Display the channel characteristics.

disp(chan)

  lutzLMSChannel with properties:

                   SampleRate: 7680000
                 InitialState: "Good"
                      KFactor: 10.2000
              LogNormalFading: [-8.9000 5.1000]
    StateDurationDistribution: "Exponential"
            MeanStateDuration: [32.4000 10.4400]
          MaximumDopplerShift: 14.2691
             ChannelFiltering: true

  Use get to show all properties

Plot Space Series and State Series for Lutz LMS Channel

Create and Configure the Channel

Create a Lutz LMS channel using lutzLMSChannel System object.

Consider a scenario in which a mobile is moving with variable velocity and a maximum Doppler shift (fd) of 25 Hz. This is the behavior of the mobile during the scenario:

• First 5 minutes: Good state with a Rice factor of 20 dB

• Next 1 minutes: Good state with a Rice factor of 8 dB

• Next 2 minutes: Bad state with the mean of fading level (mu) at -8 dB and standard deviation of fading level (sigma) at 2 dB

fd = 25;                              % In Hz
TimeDurInMins = [5 1 2];              % In minutes
TimeDurInSec = TimeDurInMins*60;      % In seconds
riceFactor = [20 8 nan];              % In dB
mu = [nan nan -8];                    % In dB
sigma = [nan nan 2];                  % In dB
sampleRate = 1000;                    % In Hz
state = ["Good" "Good" "Bad"];

Create the System object and configure its properties to these values.

• Distribution type used for state duration: None

• Random stream: mt19937ar with seed

• Channel filtering: 0 (Disabled)

% Initialize the channel
chan = lutzLMSChannel;
chan.InitialState = "Good";
chan.StateDurationDistribution = "None";
chan.RandomStream = "mt19937ar with seed";
chan.ChannelFiltering = 0;
chan.SampleRate = sampleRate;
chan.MaximumDopplerShift = fd;

Display the channel characteristics.

disp(chan)

  lutzLMSChannel with properties:

                   SampleRate: 1000
                 InitialState: "Good"
                      KFactor: 11.7000
              LogNormalFading: [-8.8000 3.8000]
    StateDurationDistribution: "None"
            MeanStateDuration: [1800 14.4000]
          MaximumDopplerShift: 25
             ChannelFiltering: false
                   NumSamples: 7680
               OutputDataType: "double"

  Use get to show all properties

Generate Lutz LMS Channel

Simulate the channel for all three cases of the scenario.

numChanges = length(TimeDurInSec);
pathGainsT = cell(numChanges,1);
stateSeriesT = cell(numChanges,1);
sampleTimesT = cell(numChanges,1);
 
% Run the channel across different cases
for loopIdx = 1:length(TimeDurInSec)
    chan.InitialState = state(loopIdx);
    if strcmpi(chan.InitialState,"Good")
        chan.MeanStateDuration = [TimeDurInSec(loopIdx) 0];
        chan.KFactor = riceFactor(loopIdx);
    else
        chan.MeanStateDuration = [0 TimeDurInSec(loopIdx)];
        chan.LogNormalFading = [mu(loopIdx) sigma(loopIdx)];
    end
    chan.NumSamples = round(sum(chan.MeanStateDuration)*chan.SampleRate);
    [pathGainsT{loopIdx},sampleTimesT{loopIdx},stateSeriesT{loopIdx}] = chan();
end
 
% Convert cell to matrix
pathGains = cell2mat(pathGainsT);
sampleTimes = cell2mat(sampleTimesT);
stateSeries = cell2mat(stateSeriesT);

Visualize Space Series and State Series

Plot the space series as a function of time.

figure
subplot(211)
plot(sampleTimes,20*log10(abs(pathGains)))
title("Space Series")
xlabel("Time (in s)")
ylabel("Path Gain (in dB)")
grid on

Plot the state series as a function of time.

subplot(212)
plot(sampleTimes,stateSeries)
title("State Series")
xlabel("Time (in s)")
ylabel("State")
grid on

Get Lutz LMS Channel Information

Get channel information from a LutzLMSChannel System object by using the info object function.

Create a Lutz LMS channel System object and specify its properties.

chan = lutzLMSChannel;
chan.SampleRate = 6000;
chan.KFactor = 20;
chan.MeanStateDuration = [8 2];
disp(chan)

  lutzLMSChannel with properties:

                   SampleRate: 6000
                 InitialState: "Good"
                      KFactor: 20
              LogNormalFading: [-8.8000 3.8000]
    StateDurationDistribution: "Exponential"
            MeanStateDuration: [8 2]
          MaximumDopplerShift: 4.2807
             ChannelFiltering: true

  Use get to show all properties

QPSK-modulate a random input signal, and then pass it through the channel.

numSamples = 2e4;
txWaveform = pskmod(randi([0 3],numSamples,1),4);
[rxWaveform,pathGains,sampleTimes,stateSeries] = chan(txWaveform);

Get the characteristic information about the Lutz LMS channel.

info(chan)

ans = struct with fields:
                   PathDelays: 0
           ChannelFilterDelay: 0
    ChannelFilterCoefficients: 1
          NumSamplesProcessed: 20000

Transmit another QPSK-modulated random input signal through the channel

numSamples2 = 3e4;
txWaveform2 = pskmod(randi([0 3],numSamples2,1),4);
[rxWaveform2,pathGains2,sampleTimes2,stateSeries2] = chan(txWaveform2);

Observe the change in number of samples processed.

info(chan)

ans = struct with fields:
                   PathDelays: 0
           ChannelFilterDelay: 0
    ChannelFilterCoefficients: 1
          NumSamplesProcessed: 50000

References

[1] Lutz, E., D. Cygan, M. Dippold, F. Dolainsky, and W. Papke. “The Land Mobile Satellite Communication Channel-Recording, Statistics, and Channel Model.” IEEE Transactions on Vehicular Technology 40, no. 2 (May 1991): 375–86. https://doi.org/10.1109/25.289418.

Extended Capabilities

C/C++ Code Generation

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

Usage notes and limitations:

• Code generation is available only when the Visualization property is "Off".

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

Version History

Introduced in R2022b