Main Content

phased.PartitionedArray

Partition phased array into subarrays

expand all in page

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

example

Properties

expand all

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.

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

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

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

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

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

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.

example

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

example

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

expand all

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

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

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

Data Types: double

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

Subarray element weights, specified as a complex-valued NSE-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 NSE-by-N matrix, where NSE 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

expand all

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)

expand all

beamwidthCompute and display beamwidth of a subarray
collectPlaneWaveSimulate received plane waves
directivityDirectivity of partitioned array
getElementPositionPositions of array elements
getNumElementsNumber of elements in array
getNumSubarraysNumber of subarrays in array
getSubarrayPositionPositions of subarrays in array
isPolarizationCapablePolarization capability
patternPlot partitioned array directivity, field, and power patterns
patternAzimuthPlot partitioned array directivity or pattern versus azimuth
patternElevationPlot partitioned array directivity or pattern versus elevation
sidelobelevelPeak and integrated side-lobe levels
viewArrayView array geometry
stepRun System object algorithm
releaseRelease resources and allow changes to System object property values and input characteristics
resetReset internal states of System object

Examples

collapse all

Open Live Script

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)

Figure contains an axes object. The hidden axes object contains 3 objects of type line, text. This object represents 1 GHz .

Open Live Script

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
Open Live Script

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');

Figure contains an axes object. The hidden axes object with xlabel x axis (Az 0 El 0) -->, ylabel y axis--> contains 7 objects of type scatter, line, text.

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

Version History

Introduced in R2012a

See Also

Functions

Objects

Apps

Topics