# step

System object: gpuConstantGammaClutter

Simulate clutter using constant gamma model

## Syntax

```Y = step(H) Y = step(H,X) Y = step(H,STEERANGLE) Y = step(H,WS) Y = step(H,PRFIDX) Y = step(H,X,STEERANGLE) ```

## Description

Note

Starting in R2016b, 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.

`Y = step(H)` computes the collected clutter return at each sensor. This syntax is available when you set the `TransmitSignalInputPort` property to `false`.

`Y = step(H,X)` specifies the transmit signal in `X`. Transmit signal refers to the output of the transmitter while it is on during a given pulse. This syntax is available when you set the `TransmitSignalInputPort` property to `true`.

`Y = step(H,STEERANGLE)` uses `STEERANGLE` as the subarray steering angle. This syntax is available when you configure `H` so that `H.Sensor` is an array that contains subarrays and `H.Sensor.SubarraySteering` is either `'Phase'` or `'Time'`.

`Y = step(H,WS)` uses `WS` as weights applied to each element within each subarray. To use this syntax, set the `Sensor` property to an array that supports subarrays and set the `SubarraySteering` property of the array to `'Custom'`.

`Y = step(H,PRFIDX)` uses the index, `PRFIDX`, to select the PRF from a predetermined list of PRFs specified by the `PRF` property. To enable this syntax, set the `PRFSelectionInputPort` to `true`.

`Y = step(H,X,STEERANGLE)` combines all input arguments. This syntax is available when you configure `H` so that `H.TransmitSignalInputPort` is `true`, `H.Sensor` is an array that contains subarrays, and `H.Sensor.SubarraySteering` is either `'Phase'` or `'Time'`.

## Input Arguments

`H`

Constant gamma clutter object.

`X`

Transmit signal, specified as a column vector of data type `double`. The System object handles data transfer between the CPU and GPU.

`STEERANGLE`

Subarray steering angle in degrees. `STEERANGLE` can be a length-2 column vector or a scalar.

If `STEERANGLE` is a length-2 vector, it has the form [azimuth; elevation]. The azimuth angle must be between –180 degrees and 180 degrees, and the elevation angle must be between –90 degrees and 90 degrees.

If `STEERANGLE` is a scalar, it represents the azimuth angle. In this case, the elevation angle is assumed to be 0.

`WS`

Subarray element weights

Subarray element weights, specified as complex-valued NSE-by-N matrix or 1-by-N cell array where N is the number of subarrays. These weights are applied to the individual elements within a subarray.

Subarray Element Weights

Sensor ArraySubarray weights
`phased.ReplicatedSubarray`

All subarrays have the same dimensions and sizes. Then, the subarray weights form an NSE-by-N matrix. NSE is the number of elements in each subarray and N is the number of subarrays. Each column of `WS` specifies the weights for the corresponding subarray.

`phased.PartitionedArray`

When subarrays do not have the same dimensions and sizes, you can specify subarray weights as

• an NSE-by-N matrix, where NSE is now the number of elements in the largest subarray. The first Q entries in each column are the element weights for the subarray where Q is the number of elements in the subarray.

• a 1-by-N cell array. Each cell contains a column vector of weights for the corresponding subarray. The column vectors have lengths equal to the number of elements in the corresponding subarray.

#### Dependencies

To enable this argument, set the `Sensor` property to an array that contains subarrays and set the `SubarraySteering` property of the array to `'Custom'`.

`PRFIDX`

Index of pulse repetition frequency, specified as a positive integer. The index selects one of the entries specified in the `PRF` property as the PRF for the next transmission.

Example: `4`

#### Dependencies

To enable this argument, set the `PRFSelectionInputPort` to `true`.

## Output Arguments

 `Y` Collected clutter return at each sensor. `Y` has dimensions N-by-M matrix. If `H.Sensor` contains subarrays, M is the number of subarrays in the radar system. Otherwise it is the number of sensors. When you set the `OutputFormat` property to `'Samples'`, N is defined by the `NumSamples` property. When you set the `OutputFormat` property to `'Pulses'`, N is the total number of samples in the next L pulses. In this case, L is defined by the `NumPulses` property.

## Examples

expand all

Simulate the clutter return from terrain with a gamma value of 0 dB. The effective transmitted power of the radar system is 5 kW.

Set up the characteristics of the radar system. This system uses a 4-element uniform linear array (ULA). The sample rate is 1 MHz, and the PRF is 10 kHz. The propagation speed is the speed of light, and the operating frequency is 300 MHz. The radar platform is flying 1 km above the ground with a path parallel to the ground along the array axis. The platform speed is 2000 m/s. The mainlobe has a depression angle of 30${}^{\circ }$.

```Nele = 4; c = physconst('Lightspeed'); fc = 300e6; lambda = c/fc; array = phased.ULA('NumElements',Nele,'ElementSpacing',lambda/2); fs = 1e6; prf = 10e3; height = 1000.0; direction = [90;0]; speed = 2.0e3; depang = 30.0; mountingAng = [0,30,0];```

Create the GPU clutter simulation object. The configuration assumes the earth is flat. The maximum clutter range of interest is 5 km, and the maximum azimuth coverage is $±6{0}^{\circ }$.

```Rmax = 5000; Azcov = 120; tergamma = 0; tpower = 5000; clutter = gpuConstantGammaClutter('Sensor',array, ... 'PropagationSpeed',c,'OperatingFrequency',fc,'PRF',prf, ... 'SampleRate',fs,'Gamma',tergamma,'EarthModel','Flat' ,... 'TransmitERP',tpower,'PlatformHeight',height, ... 'PlatformSpeed',speed,'PlatformDirection',direction, ... 'MountingAngles',mountingAng,'ClutterMaxRange',Rmax, ... 'ClutterAzimuthSpan',Azcov,'SeedSource','Property', ... 'Seed',40547);```

Simulate the clutter return for 10 pulses.

```Nsamp = fs/prf; Npulse = 10; clsig = zeros(Nsamp,Nele,Npulse); for m = 1:Npulse clsig(:,:,m) = clutter(); end```

Plot the angle-Doppler response of the clutter at the 20th range bin.

```response = phased.AngleDopplerResponse('SensorArray',array, ... 'OperatingFrequency',fc,'PropagationSpeed',c,'PRF',prf); plotResponse(response,shiftdim(clsig(20,:,:)),'NormalizeDoppler',true);```

The results are not identical to the results obtained by using `constantGammaClutter` because of differences between CPU and GPU computations.

Simulate the clutter return from terrain with a gamma value of 0 dB. You input the transmit signal of the radar system when creating clutter. In this case, you do not specify the effective transmitted power of the signal in a property.

Set up the characteristics of the radar system. This system has a 4-element uniform linear array (ULA). The sample rate is 1 MHz, and the PRF is 10 kHz. The propagation speed is the speed of light, and the operating frequency is 300 MHz. The radar platform is flying 1 km above the ground with a path parallel to the ground along the array axis. The platform speed is 2000 m/s. The mainlobe has a depression angle of 30°.

```Nele = 4; c = physconst('LightSpeed'); fc = 300e6; lambda = c/fc; ha = phased.ULA('NumElements',Nele,'ElementSpacing',lambda/2); fs = 1e6; prf = 10e3; height = 1000; direction = [90;0]; speed = 2000; mountingAng = [0,30,0]; ```

Create the GPU clutter simulation object and configure it to take a transmitted signal as an input argument. The configuration assumes the earth is flat. The maximum clutter range of interest is 5 km, and the maximum azimuth coverage is ±60°.

```Rmax = 5000; Azcov = 120; tergamma = 0; clutter = gpuConstantGammaClutter('Sensor',ha,... 'PropagationSpeed',c,'OperatingFrequency',fc,'PRF',prf,... 'SampleRate',fs,'Gamma',tergamma,'EarthModel','Flat',... 'TransmitSignalInputPort',true,'PlatformHeight',height,... 'PlatformSpeed',speed,'PlatformDirection',direction,... 'MountingAngles',mountingAng,'ClutterMaxRange',Rmax,... 'ClutterAzimuthSpan',Azcov,'SeedSource','Property','Seed',40547); ```

Simulate the clutter return for 10 pulses. At each object call, pass the transmit signal as an input argument. The software automatically computes the effective transmitted power of the signal. The transmit signal is a rectangular waveform with a pulse width of 2 μs.

```tpower = 5000; pw = 2e-6; X = tpower*ones(floor(pw*fs),1); Nsamp = fs/prf; Npulse = 10; clsig = zeros(Nsamp,Nele,Npulse); for m = 1:Npulse clsig(:,:,m) = clutter(X); end ```

Plot the angle-Doppler response of the clutter at the 20th range bin.

```response = phased.AngleDopplerResponse('SensorArray',ha,... 'OperatingFrequency',fc,'PropagationSpeed',c,'PRF',prf); plotResponse(response,shiftdim(clsig(20,:,:)),... 'NormalizeDoppler',true); ```

The results are not identical to the results obtained by using `constantGammaClutter` because of differences between CPU and GPU computations.

## Tips

The clutter simulation that `constantGammaClutter` provides is based on these assumptions:

• The radar system is monostatic.

• The propagation is in free space.

• The terrain is homogeneous.

• The clutter patch is stationary during the coherence time. Coherence time indicates how frequently the software changes the set of random numbers in the clutter simulation.

• Because the signal is narrowband, the spatial response and Doppler shift can be approximated by phase shifts.

• The radar system maintains a constant height during simulation.

• The radar system maintains a constant speed during simulation.

Get trial now