phased.URA

Uniform rectangular array

Description

To create a Uniform Rectangular Array (URA) System object™:

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

array = phased.URA

array = phased.URA(Name,Value)

array = phased.URA(SZ,D,Name,Value)

Description

array = phased.URA creates a uniform rectangular array (URA) System object that models a URA formed from identical isotropic phased array elements. Array elements are contained in the yz-plane in a rectangular lattice. The array look direction (boresight) points along the positive x-axis.

array = phased.URA(Name,Value) creates an array object 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). All properties needed to fully specify this object can be found in Properties.Response of 2-by-2 URA of Short-Dipole Antennas

array = phased.URA(SZ,D,Name,Value) creates a phased.URA array System object with its Size property set to SZ and its ElementSpacing property set to D. Other specified property Names are set to the specified Values. SZ and D are value-only arguments. When specifying a value-only argument, specify all preceding value-only arguments. You can specify name-value pair arguments in any order.

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.

Element — phased array element

isotropic antenna element System object with default properties (default) | Phased Array System Toolbox™ antenna, microphone, or transducer element System object | Antenna Toolbox™ antenna System object

Phased array element, specified as a Phased Array System Toolbox antenna, microphone, or transducer element or Antenna Toolbox antenna.

Example: phased.CosineAntennaElement

Size — Array size

[2 2] (default) | positive scalar | 1-by-2 vector of positive values

Array size, specified as a 1-by-2 vector of integers or a single integer. containing the size of the array. If Size is a 1-by-2 vector, the vector has the form [NumberOfRows, NumberOfColumns]. If Size is a scalar, the array has the same number of elements in each row and column. For a URA, array elements are indexed from top to bottom along a column and continuing to the next columns from left to right. In this illustration, a Size value of [3,2] array has three rows and two columns.

Example: [3,2]

Data Types: double

ElementSpacing — Element spacing

[0.5 0.5] (default) | positive scalar | 1-by-2 vector of positive values

Element spacing, specified as a positive scalar or 1-by-2 vector of positive values. If ElementSpacing is a 1-by-2 vector, it has the form [SpacingBetweenRows,SpacingBetweenColumns]. See Spacing Between Columns and Spacing Between Rows. If ElementSpacing is a scalar, both row and column spacings are equal. Units are in meters.

Example: [0.3, 0.5]

Data Types: double

Lattice — Lattice type

'Rectangular' (default) | 'Triangular'

Element lattice type, specified as 'Rectangular' or 'Triangular'. When you set the Lattice property to 'Rectangular', all elements of the URA are aligned in both row and column directions. When you set the Lattice property to 'Triangular', elements in even rows are displaced toward the positive row axis direction. The displacement is one-half the element spacing along the row.

Example: 'Triangular'

Data Types: char | string

ArrayNormal — Array normal direction

'x' (default) | 'y' | 'z'

Array normal direction, specified as one of 'x', 'y', or 'z'. URA elements lie in a plane orthogonal to the selected array normal direction. Element boresight directions point along the array normal direction.

ArrayNormal Property Value	Element Positions and Boresight Directions
'x'	Array elements lie on the yz-plane. All element boresight vectors point along the x-axis. This is the default value.
'y'	Array elements lie on the zx-plane. All element boresight vectors point along the y-axis.
'z'	Array elements lie on the xy-plane. All element boresight vectors point along the z-axis.

Taper — Element tapers

1 (default) | complex-valued scalar | complex-valued 1-by-MN row vector

Element tapers, specified as a complex-valued scalar, complex-valued 1-by-MN vector, or complex-valued M-by-N matrix. Tapers are applied to each element in the sensor array. Tapers are often referred to as element weights. M is the number of elements along the z-axis, and N is the number of elements along y-axis. M and N correspond to the values of [NumberofRows,NumberOfColumns] in the SIze property. If Taper is a scalar, the same taper value is applied to all elements. If the value of Taper is a vector or matrix, taper values are applied to the corresponding elements. Tapers are used to modify both the amplitude and phase of the received data.

Example: [0.4 1 0.4]

Data Types: double

Usage

Syntax

RESP = array(FREQ,ANG)

Description

RESP = array(FREQ,ANG) returns the responses of the array elements, RESP, at the operating frequencies specified in FREQ and directions specified in ANG.

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

FREQ — Array operating frequencies

length-L row vector of positive values

Array operating frequencies, specified as a length-L row vector. Typical values are within the range specified by a frequency range property of the array element. That property is called FrequencyRange or FrequencyVector, depending on the type of array element. The element has zero response at frequencies outside that range. Units are in Hz.

Data Types: double

ANG — Array response directions

length-M row vector with real values | 2-by-M matrix with real values

Array response directions, specified as a 2-by-M matrix or length-M row vector.

If ANG is a 2-by-M matrix, each column of the matrix specifies the direction in the form [azimuth; elevation]. The azimuth angle must lie between –180° and 180°, inclusive. The elevation angle must lie between –90° and 90°, inclusive.

If ang is a row vector of length M, each element specifies the azimuth angle of the direction. In this case, the corresponding elevation angle is assumed to be 0°.

Units are in degrees.

Output Arguments

RESP — Voltage responses of phased array elements

N-by-M-by- complex-valued MATLAB^® array | MATLAB struct

Voltage responses of phased array elements. The output depends on whether or not the array supports polarization.

• If the array is not capable of supporting polarization, the voltage response, RESP, has the dimensions N-by-M-by-L. N is the number of elements in the array. The dimension M is the number of angles specified in ANG. L is the number of frequencies specified in FREQ. For any element, the columns of RESP contain the responses of the array elements for the corresponding direction specified in ang. Each of the L pages of RESP contains the responses of the array elements for the corresponding frequency specified in freq.

• If the array is capable of supporting polarization, the voltage response RESP is a MATLAB struct containing two fields, RESP.H and RESP.V. The field, RESP.H, represents the array’s horizontal polarization response, while RESP.V represents the array’s vertical polarization response. Each field has the dimensions N-by-M-by-L. N is the number of elements in the array, and M is the number of angles specified in ANG. L is the number of frequencies specified in FREQ. Each column of RESP contains the responses of the array elements for the corresponding direction specified in ANG. Each of the L pages of ANG contains the responses of the array elements for the corresponding frequency specified in FREQ.

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 phased.URA and other array System objects

beamwidth	Compute and display beamwidth of an array
collectPlaneWave	Simulate received plane waves at array
directivity	Compute array directivity
getElementNormal	Normal vectors for array elements
getElementPosition	Positions of array elements
getNumElements	Number of elements in an array
getTaper	Array element tapers
isPolarizationCapable	Array polarization capability
pattern	Plot array directivity and patterns
patternAzimuth	Plot array directivity or pattern versus azimuth
patternElevation	Plot array directivity or pattern versus elevation
perturbations	Perturbations defined on array
perturbedArray	Apply perturbations to phased array
perturbedPattern	Display pattern of perturbed array
plotGratingLobeDiagram	Plot grating lobe diagram of array
sidelobelevel	Peak and integrated side-lobe levels
thinnedArray	Create thinned array from full array
viewArray	View array geometry

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

Response of 2-by-2 URA of Short-Dipole Antennas

Construct a 2-by-2 rectangular lattice URA of short-dipole antenna elements. Then, find the response of each element at boresight. Assume the operating frequency is 1 GHz.

sSD = phased.ShortDipoleAntennaElement;
sURA = phased.URA('Element',sSD,'Size',[2 2]);
fc = 1e9;
ang = [0;0];
resp = step(sURA,fc,ang);
disp(resp.V)

   -1.2247
   -1.2247
   -1.2247
   -1.2247

Azimuth Response of a 3-by-2 URA at Boresight

Construct a 3-by-2 rectangular lattice URA. By default, the array consists of isotropic antenna elements. Find the response of each element at boresight, 0 degrees azimuth and elevation. Assume the operating frequency is 1 GHz.

array = phased.URA('Size',[3 2]);
fc = 1e9;
ang = [0;0];
resp = array(fc,ang);
disp(resp)

     1
     1
     1
     1
     1
     1

Plot the azimuth pattern of the array.

c = physconst('LightSpeed');
pattern(array,fc,[-180:180],0,'PropagationSpeed',c, ...
    'CoordinateSystem','polar','Type','powerdb','Normalize',true)

Compare Triangular and Rectangular Lattice URAs

This example shows how to find and plot the positions of the elements of a 5-row-by-6-column URA with a triangular lattice and a URA with a rectangular lattice. The element spacing is 0.5 meters for both lattices.

Create the arrays.

h_tri = phased.URA('Size',[5 6],'Lattice','Triangular');
h_rec = phased.URA('Size',[5 6],'Lattice','Rectangular');

Get the element y,z positions for each array. All the x coordinates are zero.

pos_tri = getElementPosition(h_tri);
pos_rec = getElementPosition(h_rec);
pos_yz_tri = pos_tri(2:3,:);
pos_yz_rec = pos_rec(2:3,:);

Plot the element positions in the yz-plane.

figure;
gcf.Position = [100 100 300 400];
subplot(2,1,1);
plot(pos_yz_tri(1,:), pos_yz_tri(2,:), '.')
axis([-1.5 1.5 -2 2])
xlabel('y'); ylabel('z')
title('Triangular Lattice')
subplot(2,1,2);
plot(pos_yz_rec(1,:), pos_yz_rec(2,:), '.')
axis([-1.5 1.5 -2 2])
xlabel('y'); ylabel('z')
title('Rectangular Lattice')

Adding Tapers to an Array

Construct a 5-by-2 element URA with a Taylor window taper along each column. The tapers form a 5-by-2 matrix.

taper = taylorwin(5);
ha = phased.URA([5,2],'Taper',[taper,taper]);
w = getTaper(ha)

w = 10×1

    0.5181
    1.2029
    1.5581
    1.2029
    0.5181
    0.5181
    1.2029
    1.5581
    1.2029
    0.5181

Simulate Received Signal at URA

Simulate two received random signals at a 6-element URA. The array has a rectangular lattice with two elements in the row direction and three elements in the column direction. The signals arrive from 10° and 30° azimuth. Both signals have an elevation angle of 0°. Assume the propagation speed is the speed of light and the carrier frequency of the signal is 100 MHz.

array = phased.URA([2 3]);
fc = 100e6;
y = collectPlaneWave(array,randn(4,2),[10 30],fc,physconst('LightSpeed'));

Directivity of Uniform Rectangular Array

Compute the directivity of two uniform rectangular arrays (URA). The first array consists of isotropic antenna elements. The second array consists of cosine antenna elements. In addition, compute the directivity of the first array steered to a specific direction.

Array of isotropic antenna elements

First, create a 10-by-10-element URA of isotropic antenna elements spaced one-quarter wavelength apart. Set the signal frequency to 800 MHz.

c = physconst('LightSpeed');
fc = 3e8;
lambda = c/fc;
myAntIso = phased.IsotropicAntennaElement;
myArray1 = phased.URA;
myArray1.Element = myAntIso;
myArray1.Size = [10,10];
myArray1.ElementSpacing = [lambda*0.25,lambda*0.25];
ang = [0;0];
d = directivity(myArray1,fc,ang,'PropagationSpeed',c)

d = 
15.7753

Array of cosine antenna elements

Next, create a 10-by-10-element URA of cosine antenna elements also spaced one-quarter wavelength apart.

myAntCos = phased.CosineAntennaElement('CosinePower',[1.8,1.8]);
myArray2 = phased.URA;
myArray2.Element = myAntCos;
myArray2.Size = [10,10];
myArray2.ElementSpacing = [lambda*0.25,lambda*0.25];
ang = [0;0];
d = directivity(myArray2,fc,ang,'PropagationSpeed',c)

d = 
19.7295

The directivity is increased due to the directivity of the cosine antenna elements.

Steered array of isotropic antenna elements

Finally, steer the isotropic antenna array to 30 degrees in azimuth and examine the directivity at the steered angle.

ang = [30;0];
w = steervec(getElementPosition(myArray1)/lambda,ang);
d = directivity(myArray1,fc,ang,'PropagationSpeed',c,...
    'Weights',w)

d = 
15.3309

The directivity is maximum in the steered direction and equals the directivity of the unsteered array at boresight.

URA Element Normals

Construct three 2-by-2 URA's with element normals along the x-, y-, and z-axes. Obtain the element positions and normal directions.

First, choose the array normal along the x-axis.

sURA1 = phased.URA('Size',[2,2],'ArrayNormal','x');
pos = getElementPosition(sURA1)

pos = 3×4

         0         0         0         0
   -0.2500   -0.2500    0.2500    0.2500
    0.2500   -0.2500    0.2500   -0.2500

normvec = getElementNormal(sURA1)

normvec = 2×4

     0     0     0     0
     0     0     0     0

All elements lie in the yz-plane and the element normal vectors point along the x-axis (0°,0°).

Next, choose the array normal along the y-axis.

sURA2 = phased.URA('Size',[2,2],'ArrayNormal','y');
pos = getElementPosition(sURA2)

pos = 3×4

    0.2500    0.2500   -0.2500   -0.2500
         0         0         0         0
    0.2500   -0.2500    0.2500   -0.2500

normvec = getElementNormal(sURA2)

normvec = 2×4

    90    90    90    90
     0     0     0     0

All elements lie in the zx-plane and the element normal vectors point along the y-axis (90°,0°).

Finally, set the array normal along the z-axis. Obtain the normal vectors of the odd-numbered elements.

sURA3 = phased.URA('Size',[2,2],'ArrayNormal','z');
pos = getElementPosition(sURA3)

pos = 3×4

   -0.2500   -0.2500    0.2500    0.2500
    0.2500   -0.2500    0.2500   -0.2500
         0         0         0         0

normvec = getElementNormal(sURA3,[1,3])

normvec = 2×2

     0     0
    90    90

All elements lie in the xy-plane and the element normal vectors point along the z-axis (0°,90°).

Obtain URA Element Positions

Construct a default URA with a rectangular lattice, and obtain the element positions.

array = phased.URA;
pos = getElementPosition(array)

pos = 3×4

         0         0         0         0
   -0.2500   -0.2500    0.2500    0.2500
    0.2500   -0.2500    0.2500   -0.2500

Obtain Number of URA Elements

Construct a default URA, and obtain the number of elements.

array = phased.URA;
N = getNumElements(array)

N = 
4

Create Tapered URA

Construct a 5-by-2 element URA with a Taylor window taper along each column. Then, draw the array showing the element taper shading.

taper = taylorwin(5);
array = phased.URA([5,2],'Taper',[taper,taper]);
w = getTaper(array)

w = 10×1

    0.5181
    1.2029
    1.5581
    1.2029
    0.5181
    0.5181
    1.2029
    1.5581
    1.2029
    0.5181

viewArray(array,'ShowTaper',true)

Short-Dipole URA Supports Polarization

Show that a URA array of phased.ShortDipoleAntennaElement short-dipole antenna elements supports polarization.

antenna = phased.ShortDipoleAntennaElement('FrequencyRange',[1e9 10e9]);
array = phased.URA([3,2],'Element',antenna);
isPolarizationCapable(array)

ans = logical
   1

The returned value 1 shows that this array supports polarization.

Pattern of 5x7-Element URA Antenna Array

Create a 5x7-element URA operating at 1 GHz. Assume the elements are spaced one-half wavelength apart. Show the 3-D array patterns.

Create the array

sSD = phased.ShortDipoleAntennaElement(...
    'FrequencyRange',[50e6,1000e6],...
    'AxisDirection','Z');
fc = 500e6;
c = physconst('LightSpeed');
lam = c/fc;
sURA = phased.URA('Element',sSD,...
    'Size',[5,7],...
    'ElementSpacing',0.5*lam);

Call the step method

Evaluate the fields of the first five elements at 45 degrees azimuth and 0 degrees elevation.

ang = [45;0];
resp = step(sURA,fc,ang);
disp(resp.V(1:5))

   -1.2247
   -1.2247
   -1.2247
   -1.2247
   -1.2247

Display the 3-D directivity pattern at 500 MHz in polar coordinates

pattern(sURA,fc,[-180:180],[-90:90],...
    'CoordinateSystem','polar',...
    'Type','directivity','PropagationSpeed',c)

Display the 3-D directivity pattern at 500 MHz in UV coordinates

pattern(sURA,fc,[-1.0:.01:1.0],[-1.0:.01:1.0],...
    'CoordinateSystem','uv',...
    'Type','directivity','PropagationSpeed',c)

Azimuth Pattern of 5x7-Element URA Antenna Array

Create a 5x7-element URA of short-dipole antenna elements operating at 1 GHz. Assume the elements are spaced one-half wavelength apart. Plot the array azimuth directivity patterns for two different elevation angles, 0 and 15 degrees. The patternAzimuth method always plots the array pattern in polar coordinates.

Create the array

sSD = phased.ShortDipoleAntennaElement(...
    'FrequencyRange',[50e6,1000e6],...
    'AxisDirection','Z');
fc = 1e9;
c = physconst('LightSpeed');
lam = c/fc;
sURA = phased.URA('Element',sSD,...
    'Size',[5,7],...
    'ElementSpacing',0.5*lam);

Display the pattern

Display the azimuth directivity pattern at 1 GHz in polar coordinates

patternAzimuth(sURA,fc,[0 15],...
    'PropagationSpeed',c,...
    'Type','directivity')

Display a subset of angles

You can plot a smaller range of azimuth angles by setting the Azimuth parameter.

patternAzimuth(sURA,fc,[0 15],...
    'PropagationSpeed',c,...
    'Type','directivity',...
    'Azimuth',[-45:45])

Elevation Pattern of 7x7-Element Acoustic URA

Create a 7x7-element URA of backbaffled omnidirectional transducer elements operating at 1 kHz. Assume the speed of sound in water is 1500 m/s. The elements are spaced less than one-half wavelength apart. Plot the array elevation directivity patterns for three different azimuth angles, -20, 0, and 15 degrees. The patternElevation method always plots the array pattern in polar coordinates.

Create the array

element = phased.OmnidirectionalMicrophoneElement(...
    'FrequencyRange',[20,3000],...
    'BackBaffled',true);
fc = 1000;
c = 1500;
lam = c/fc;
array = phased.URA('Element',element,...
    'Size',[7,7],...
    'ElementSpacing',0.45*lam);

Display the pattern

Display the azimuth directivity pattern at 1 GHz in polar coordinates.

patternElevation(array,fc,[-20, 0, 15],...
    'PropagationSpeed',c,...
    'Type','directivity')

Display a subset of elevation angles

You can plot a smaller range of elevation angles by setting the Elevation parameter.

patternElevation(array,fc,[-20, 0, 15],...
    'PropagationSpeed',c,...
    'Type','directivity',...
    'Elevation',[-45:45])

Grating Lobe Diagram for Microphone URA

Plot the grating lobe diagram for an 11-by-9-element uniform rectangular array having element spacing equal to one-half wavelength.

Assume the operating frequency of the array is 10 kHz. All elements are omnidirectional microphone elements. Steer the array in the direction 20 degrees in azimuth and 30 degrees in elevation. The speed of sound in air is 344.21 m/s at 21 deg C.

cair = 344.21;
f = 10.0e3;
lambda = cair/f;
microphone = phased.OmnidirectionalMicrophoneElement(...
    'FrequencyRange',[20 20000]);
array = phased.URA('Element',microphone,'Size',[11,9],...
    'ElementSpacing',0.5*lambda*[1,1]);
plotGratingLobeDiagram(array,f,[20;30],cair);

Plot the grating lobes. The main lobe of the array is indicated by a filled black circle. The grating lobes in visible and nonvisible regions are indicated by unfilled black circles. The visible region is the region in u-v coordinates for which ${\mathit{u}}^2+{\mathit{v}}^2\le 1$. The visible region is shown as a unit circle centered at the origin. Because the array spacing is less than one-half wavelength, there are no grating lobes in the visible region of space. There are an infinite number of grating lobes in the nonvisible regions, but only those in the range [-3,3] are shown.

The grating-lobe free region, shown in green, is the range of directions of the main lobe for which there are no grating lobes in the visible region. In this case, it coincides with the visible region.

The white areas of the diagram indicate a region where no grating lobes are possible.

Geometry, Normal Directions, and Indices of URA Elements

This example shows how to display the element positions, normal directions, and indices for all elements of a 4-by-4 square URA.

ha = phased.URA(4);
viewArray(ha,'ShowNormals',true,'ShowIndex','All');

More About

Spacing Between Columns

The spacing between columns is the distance between adjacent elements in the same row.

Spacing Between Rows

The spacing between rows is the distance along the column axis direction between adjacent rows.

References

[1] Brookner, E., ed. Radar Technology. Lexington, MA: LexBook, 1996.

[2] Brookner, E., ed. Practical Phased Array Antenna Systems. Boston: Artech House, 1991.

[3] Mailloux, R. J. “Phased Array Theory and Technology,” Proceedings of the IEEE, Vol., 70, Number 3s, pp. 246–291.

[4] Mott, H. Antennas for Radar and Communications, A Polarimetric Approach. New York: John Wiley & Sons, 1992.

[5] Van Trees, H. Optimum Array Processing. New York: Wiley-Interscience, 2002.

Extended Capabilities

C/C++ Code Generation

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

Usage notes and limitations:

• pattern, patternAzimuth, patternElevation, and viewArray object functions are not supported.

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

Version History

Introduced in R2011a