phased.SumDifferenceMonopulseTracker

Sum and difference monopulse for ULA

Description

The SumDifferenceMonopulseTracker System object™ implements a sum and difference monopulse algorithm on a uniform linear array (ULA).

To compute the response for each element in the array for specified directions:

1. Create the phased.SumDifferenceMonopulseTracker 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

tracker = phased.SumDifferenceMonopulseTracker

tracker = phased.SumDifferenceMonopulseTracker(Name=Value)

Description

tracker = phased.SumDifferenceMonopulseTracker creates a tracker System object, tracker. The object uses sum and difference monopulse algorithms on a uniform linear array (ULA).

tracker = phased.SumDifferenceMonopulseTracker(Name=Value) creates a ULA monopulse tracker System object, tracker, with each specified property Name set to the specified Value. You can specify additional name-value pair arguments in any order as (Name1 = Value1, … ,NameN = ValueN).

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.

SensorArray — Sensor array

phased.ULA System object (default)

Sensor array, specified as a phased.ULA System object with property ArrayAxis = "y".

Example: phased.ULA(ArrayAxis="y")

PropagationSpeed — Signal propagation speed (meters/second)

physconst("LightSpeed") (default) | real-valued positive scalar

Signal propagation speed, specified as a real-valued positive scalar. Units are in meters per second. The default propagation speed is the value returned by physconst("LightSpeed").

Example: 3e8

Data Types: single | double

OperatingFrequency — Operating frequency

300e6 (default) | positive scalar

Operating frequency, specified as a positive scalar. Units are in Hz.

Example: 1e9

Data Types: double

NumPhaseShifterBits — Number of phase shifter quantization bits

0 (default) | non-negative scalar

The number of bits used to quantize the phase shift component of beamformer or steering vector weights, specified as a non-negative integer. A value of zero indicates that no quantization is performed.

Example: 5

Data Types: single | double

Usage

Syntax

ESTANG = tracker(X,STANG)

Description

ESTANG = tracker(X,STANG) estimates the incoming direction ESTANG of the input signal, X, based on an initial guess of the direction.

Note

The object performs an initialization the first time the object is executed. This initialization locks nontunable properties and input specifications, such as dimensions, complexity, and data type of the input data. If you change a nontunable property or an input specification, the System object issues an error. To change nontunable properties or inputs, you must first call the release method to unlock the object.

Input Arguments

X — Input signal

length-L row vector of positive values

Input signal, specified as a real-valued length-L row vector, where the number of columns corresponds to number of channels.

The size of the first dimension of the input matrix can vary to simulate a changing signal length. A size change can occur, for example, in the case of a pulse waveform with variable pulse repetition frequency.

Data Types: single | double

STANG — Initial estimate of direction

scalar

Initial estimate of the direction, specified as a scalar that represents the broadside angle in degrees. A typical initial guess is the current steering angle. The value of STANG is between –90° and 90°. The angle is defined in the array's local coordinate system. For details regarding the local coordinate system of the ULA, type phased.ULA.coordinateSystemInfo.

Data Types: single | double

Output Arguments

ESTANG — Estimate incoming direction

positive scalar

Estimate incoming direction, returned as a scalar that represents the broadside angle in degrees. The value is between –90° and 90°. The angle is defined in the array's local coordinate system.

Data Types: single | double

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)

Common to All System Objects

step	Run System object algorithm
release	Release resources and allow changes to System object property values and input characteristics
reset	Reset internal states of System object

Examples

Find Target Direction Using Monopulse Tracker

Determine the direction of a target at a 60.1° broadside angle to a ULA starting with an approximate direction of 60°

array = phased.ULA('NumElements',4);
steervec = phased.SteeringVector('SensorArray',array);
tracker = phased.SumDifferenceMonopulseTracker('SensorArray',array);
x = steervec(tracker.OperatingFrequency,60.1).';
est_dir = tracker(x,60)

est_dir = 
60.1000

Algorithms

Monopulse Algorithm

The sum-and-difference monopulse algorithm is used to the estimate the arrival direction of a narrowband signal impinging upon a uniform linear array (ULA). First, compute the conventional response of an array steered to an arrival direction φ₀. For a ULA, the arrival direction is specified by the broadside angle. To specify that the maximum response axis (MRA) point towards the φ₀ direction, set the weights to be

$$w_s=\left(1,e^{ikd\sin {\varphi }_0},e^{ik2d\sin {\varphi }_0},\dots ,e^{ik(N-1)d\sin {\varphi }_0}\right)$$

where d is the element spacing and k = 2π/λ is the wavenumber. An incoming plane wave, coming from any arbitrary direction φ, is represented by

$$v=\left(1,e^{ikd\sin \varphi },e^{ik2d\sin \varphi },\dots ,e^{ik(N-1)d\sin \varphi }\right)$$

The conventional response of this array to any incoming plane wave is given by $$w_s^{H}v\left(\phi \right)$$ and is shown in the polar plot below as the Sum Pattern. The array is designed to steer towards φ₀ = 30°.

The second pattern, called the Difference Pattern, is obtained by using phased-reversed weights. The weights are determined by phase-reversing the latter half of the conventional steering vector. For an array with an even number of elements, the phase-reversed weights are

$$w_d=-i\left(1,e^{ikd\sin {\varphi }_0},e^{ik2d\sin {\varphi }_0},\dots ,e^{ikN/2d\sin {\varphi }_0},-e^{ik(N/2+1)d\sin {\varphi }_0},\dots ,-e^{ik(N-1)d\sin {\varphi }_0}\right)$$

(For an array with an odd number of elements, the middle weight is set to zero). The multiplicative factor –i is used for convenience. The response of the difference array to the incoming vector is

$$w_d^{H}v\left(\phi \right)$$

This figure shows the sum and difference beam patterns of a four-element uniform linear array (ULA) steered 30° from broadside. The array elements are spaced at one-half wavelength. The sum pattern shows that the array has its maximum response at 30° and the difference pattern has a null at 30°.

The monopulse response curve is obtained by dividing the difference pattern by the sum pattern and taking the real part.

$$R(\phi )=Re\left(\frac{w_d^{H}v(\phi )}{w_s^{H}v(\phi )}\right)$$

To use the monopulse response curve to obtain the arrival angle, φ, of a narrowband signal, x, compute

$$z=Re\left(\frac{w_d^{H}x}{w_s^{H}x}\right)$$

and invert the response curve, φ = R^-1(z), to obtain φ.

The response curve is not generally single valued and can only be inverted when arrival angles lie within the main lobe where it is single valued This figure shows the monopulse response curve within the main lobe of the four-element ULA array.

There are two desirable properties of the monopulse response curve. The first is that it have a steep slope. A steep slope ensures robustness against noise. The second property is that the mainlobe be as wide as possible. A steep slope is ensure by a larger array but leads to a smaller mainlobe. You will need to trade off one property with the other.

For further details, see [1].

Data Precision

This System object supports single and double precision for input data, properties, and arguments. If the input data X is single precision, the output data is single precision. If the input data X is double precision, the output data is double precision. The precision of the output is independent of the precision of the properties and other arguments.

References

[1] Seliktar, Y. Space-Time Adaptive Monopulse Processing. Ph.D. Thesis. Georgia Institute of Technology, Atlanta, 1998.

[2] Rhodes, D. Introduction to Monopulse. Dedham, MA: Artech House, 1980.

Extended Capabilities

C/C++ Code Generation

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

Usage notes and limitations:

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

Version History

Introduced in R2011a