phased.PartitionedArray

Partition phased array into subarrays

Description

The phased.PartitionedArray System object™ represents a phased array that is partitioned into subarrays. To create a partitioned array and to obtain the response of its subarrays:

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

You can also specify a phased.PartitionedArray System object as the value of the SensorArray or Sensor property of objects that perform beamforming, steering, and other operations.

Creation

Syntax

array = phased.PartitionedArray

array = phased.PartitionedArray(Name=Value)

Description

array = phased.PartitionedArray creates a partitioned array System object. The partitions are called subarrays.

array = phased.PartitionedArray(Name=Value) creates a partitioned array System 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).

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.

Array — Sensor array to partition

phased.ULA('NumElements',4) (default) | Phased Array System Toolbox™ Sensor array

Sensor array to partition, specified as a Phased Array System Toolbox System object of one of these types:

• phased.ULA System object

• phased.URA System object

• phased.UCA System object

  phased.ConformalArray System object

You cannot use the phased.HeterogeneousULA, phased.HeterogeneousURA. phased.HeterogeneousConformalArray, or phased.NRRectangularPanelArray System object.

SubarraySelection — Subarray definition matrix

[1 1 0 0; 0 0 1 1] (default) | M-by-N real-valued matrix

Specify the subarray selection as a M-by-N real-valued matrix. M is the number of subarrays and N is the number of elements in the array. Each row of the matrix corresponds to a subarray and each entry in the row indicates whether or not an element belongs to the subarray. When the entry is zero, the element does not belong to the subarray. A nonzero entry represents a complex-valued weight applied to the corresponding element. Each row must contain at least one nonzero entry.

The phase center of each subarray is at the subarray geometric center. The SubarraySelection and Array properties determine the geometric center.

Data Types: double

SubarraySteering — Subarray steering method

'None' (default) | 'Phase' | 'Time' | 'Custom'

Method of subarray steering, specified as 'None', 'Phase', 'Time', or 'Custom'.

• When you set this property to 'Phase', a phase shifter is used to steer the subarray. Use the STEERANG argument of the object to define the steering direction.

• When you set this property to 'Time', subarrays are steered using time delays. Use the STEERANG argument of the object to define the steering direction.

• When you set this property to 'Custom', subarrays are steered by setting independent weights for all elements in each subarray. Use the WS argument of the object to define the weights for all subarrays.

Example: 'Time'

Data Types: char | string

PhaseShifterFrequency — Subarray phase shifter frequency

300e6 (default) | positive scalar

Subarray phase shifter frequency, specified as positive scalar. Phase shifters perform subarray steering. Units are in Hz.

Example: 1e9

Dependencies

To enable this property, set the SubarraySteering property to 'Phase'.

Data Types: double

NumPhaseShifterBits — Number of phase shifter quantization bits

0 (default) | non-negative integer

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.

Data Types: double

Usage

Syntax

RESP = array(FREQ,ANG,V)

RESP = array(FREQ,ANG,V,STEERANGLE)

RESP = array(FREQ,ANG,V,WS)

Description

RESP = array(FREQ,ANG,V) returns the responses RESP of the subarrays in the array, at operating frequencies specified in FREQ and directions specified in ANG. The phase center of each subarray is at its geometric center. V is the propagation speed. The elements within each subarray are connected to the subarray phase center using an equal-path feed.

RESP = array(FREQ,ANG,V,STEERANGLE) uses STEERANGLE as the steering direction of the subarray. This syntax is available when you set the SubarraySteering property to either 'Phase' or 'Time'.

RESP = array(FREQ,ANG,V,WS) uses WS as the subarray element weights. This syntax is available when you set the SubarraySteering property to 'Custom'.

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 — Operating frequencies of array

real-valued length-L row vector

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

Data Types: double

ANG — Directions

real-valued length-M row vector | real-valued 2-by-M matrix

Direction, specified as a real-valued length-M row vector or real-valued 2-by-M matrix.

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

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 be between –180 and 180 degrees, inclusive. The elevation angle must be between –90 and 90 degrees, inclusive.

Data Types: double

V — Signal propagation speed

positive scalar

Signal propagation speed, specified as a positive scalar. Units are in meters per second.

Data Types: double

STEERANG — Subarray steering angle

real-valued 2-by-1 vector

Subarray steering angle, specified as a length-2 column vector. The vector has the form [azimuthAngle;elevationAngle]. The azimuth angle must be between –180° and 180°, inclusive. The elevation angle must be between –90° and 90°, inclusive. Units are in degrees.

Example: [20;15]

Dependencies

To enable this argument, set the Sensor property to an array that supports subarrays and set the SubarraySteering property of that array to either 'Phase' or 'Time'

Data Types: double

WS — Subarray element weights

complex-valued N_SE-by-N matrix | 1-by-N cell array

Subarray element weights, specified as a complex-valued N_SE-by-N matrix or 1-by-N cell array where N is the number of subarrays.

Subarrays may have different dimensions and sizes. In this case, you can specify subarray weights as

• an N_SE-by-N matrix, where N_SE is 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 SubarraySteering property to 'Custom'.

Data Types: double

Output Arguments

RESP — Voltage responses of the subarrays

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

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

• If the array is not capable of supporting polarization, the voltage response, RESP, has the dimensions N-by-M-by-L. The size N represents the number of subarrays in the phased array, M represents the number of angles specified in ANG, and L represents the number of frequencies specified in FREQ. For a particular subarray, each column of RESP contains the responses of the subarray for the corresponding direction specified in ANG. Each of the L pages of RESP contains the responses of the subarrays 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. The size N represents the number of subarrays in the phased array, M represents the number of angles specified in ANG, and L represents the number of frequencies specified in FREQ. For a particular subarray, each column of RESP contains the responses of the subarray for the corresponding direction specified in ANG. Each of the L pages of RESP contains the responses of the subarrays 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.PartitionedArray and phased array System objects

beamwidth	Compute and display beamwidth of a subarray
collectPlaneWave	Simulate received plane waves
directivity	Directivity of partitioned array
getElementPosition	Positions of array elements
getNumElements	Number of elements in array
getNumSubarrays	Number of subarrays in array
getSubarrayPosition	Positions of subarrays in array
isPolarizationCapable	Polarization capability
pattern	Plot partitioned array directivity, field, and power patterns
patternAzimuth	Plot partitioned array directivity or pattern versus azimuth
patternElevation	Plot partitioned array directivity or pattern versus elevation
sidelobelevel	Peak and integrated side-lobe levels
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

Azimuth Response of Partitioned ULA

Plot the azimuth response of a 4-element ULA partitioned into two 2-element ULA's. The element spacing is one-half wavelength.

Create the ULA, and partition it into two 2-element ULA's.

sULA = phased.ULA('NumElements',4,'ElementSpacing',0.5);
sPA = phased.PartitionedArray('Array',sULA,...
    'SubarraySelection',[1 1 0 0;0 0 1 1]);

Plot the azimuth response of the array. Assume the operating frequency is 1 GHz and the propagation speed is the speed of light.

fc = 1e9;
pattern(sPA,fc,[-180:180],0,'Type','powerdb',...
    'CoordinateSystem','polar',...
    'Normalize',true)

Response of Subarrays in Partitioned ULA

Calculate the response at boresight of a 4-element ULA partitioned into two 2-element ULAs.

Set up the partitioned array.

hula = phased.ULA('NumElements',4,'ElementSpacing',0.5);
partitionedarray = phased.PartitionedArray('Array',hula,...
   'SubarraySelection',[1 1 0 0;0 0 1 1]);

Calculate the response of the subarrays at boresight. Assume the operating frequency is 1 GHz and the propagation speed is the speed of light.

resp = partitionedarray(1.0e9,[0;0],physconst('Lightspeed'))

resp = 2×1

     2
     2

Subarray Element Weights for Partitioned Array

Create a partitioned URA array with three subarrays of different sizes. The subarrays have 8, 16, and 32 elements. Use different sets of subarray element weights for each subarray.

Create a 4-by-56 element URA.

antenna = phased.IsotropicAntennaElement;
fc = 300e6;
c = physconst('LightSpeed');
lambda = c/fc;
n1 = 2^3;
n2 = 2^4;
n3 = 2^5;
nrows = 4;
ncols = n1 + n2 + n3;
array = phased.URA('Element',antenna,'Size',[nrows,ncols]);

Select the three subarrays by setting the selection matrix.

sel1 = zeros(nrows,ncols);
sel2 = sel1;
sel3 = sel1;
sel = zeros(3,nrows*ncols);
for r = 1:nrows
    sel1(r,1:n1) = 1;
    sel2(r,(n1+1):(n1+n2)) = 1;
    sel3(r,((n1+n2)+1):ncols) = 1;
end
sel(1,:) = sel1(:);
sel(2,:) = sel2(:);
sel(3,:) = sel3(:);

Create the partitioned array.

partarray = phased.PartitionedArray('Array',array, ...
    'SubarraySelection',sel,'SubarraySteering','Custom');
viewArray(partarray,'ShowSubarray','All');

Set weights for each subarray and get the response of each subarray. Put the weights in a cell array.

wts1 = ones(nrows*n1,1);
wts2 = 1.5*ones(nrows*n2,1);
wts3 = 3*ones(nrows*n3,1);
resp = partarray(fc,[30;0],c,{wts1,wts2,wts3})

resp = 3×1 complex

   0.0246 + 0.0000i
   0.0738 - 0.0000i
   0.2951 - 0.0000i

References

[1] Van Trees, H.L. 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:

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

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

Version History

Introduced in R2012a