# Array

*An arbitrary antenna array of one or more elements.*

`obj/array/array.m`

#### On This Page

- About
- Video Tutorial
- Creating an Array
- Viewing the Array
- Adding and Removing Elements
- Modifying the Array
- Getting the Array Response
- Weighting the Array
- Array Gain
- Getting the Weighted Array Response
- Viewing the Array Pattern
- List of Properties
- List of Methods
- Methods Documentation

### About

The `array`

object is used to represent an antenna array. Currently, MFM only supports isotropic antenna elements.

An antenna array is largely characterized by the relative geometry of its elements.
MFM’s `array`

object is not restricted to creating uniform linear arrays or uniform planar arrays; the array’s elements * can be placed arbitrarily*, and MFM will automatically compute the array response based on their placement. This means users can easily experiment with abnormal/arbitrary array designs.

### Video Tutorial

### Creating an Array

There are a few different ways to create an `array`

object.

#### Empty Array

To create an empty array object, you can simply call

```
a = array.create()
```

#### Uniform Linear Array

To create an `N`

-element, half-wavelength spaced uniform linear array, use

```
a = array.create(N,ax)
```

where `ax`

is either `'x'`

(default), `'y'`

, or `'z'`

specifying which axis to create the ULA along.

#### Uniform Planar Array

To create a half-wavelength spaced uniform planar array with `N`

rows of `M`

elements, use

```
a = array.create(N,M,plane)
```

where `plane`

is either `'xz'`

(default), `'xy'`

, or `'yz'`

, defining which plane to create the array in.

By default, ULAs and UPAs are centered at the origin when created.

### Viewing the Array

To view the array elements in 2-D space (in the x-z plane by default), use

```
a.show_2d()
```

or

```
a.show_2d([],plane)
```

where `plane`

is either `'xz'`

(default), `'xy'`

, or `'yz'`

specifying which plane to plot the array in.

To view the array elements in 3-D space, use

```
a.show_3d()
```

### Adding and Removing Elements

To add elements to an `array`

object `a`

, use

```
a.add_element(x,y,z)
```

where `x`

, `y`

, and `z`

are vectors of (x,y,z) coordinates of the elements (in wavelengths) to add to the array.

Since antenna arrays are characterized by the elements’ positions relative to the carrier frequency, all Cartesian coordinates associated with an array are in units of carrier wavelengths.

To remove an element from the `array`

object `a`

, use

```
a.remove_element(idx)
```

where `idx`

is the index of the element to remove. If `idx`

is not passed, the last element of the array will be removed.

### Modifying the Array

To shift all elements of an `array`

object `a`

, use

```
a.translate(x,y,z)
```

where `x`

, `y`

, and `z`

are the amounts (in wavelengths) to move all the array elements in the x, y, and z directions.

If `x`

, `y`

, and `z`

are not passed, then the following

```
a.translate()
```

centers the array at the origin.

To rotate the entire `array`

object `a`

about the three axes, use

```
a.rotate(rot_x,rot_y,rot_z)
```

where `rot_x`

, `rot_y`

, and `rot_z`

are rotations to make along the x-, y-, and z-axes, respectively, in radians.

### Geting the Array Response

The relative phase shift experienced by the -th array element located at some from the origin due to a plane wave in the direction is

where is the carrier wavelength and

Instead of referencing the true origin to compute the array response, MFM refers the location of each antenna element to that of the first element in the antenna array. Thus, the array response vector is constructed by collecting the relative phase shift seen by each of the array’s elements as

To obtain the array response—the relative phase shift across elements—at a particular azimuth angle and elevation angle, use

```
v = a.get_array_response(az,el)
```

where `az`

and `el`

are azimuth and elevation angles in radians and `v`

is the consequent array response (a column vector). MFM will compute the array response behind-the-scenes.

### Weighting the Array

To set the array weights, use

```
a.set_weights(w)
```

where `w`

is a vector of complex weights where the `i`

-th array element is weighted by the `i`

-th weight in `w`

.

### Array Gain

The array gain in a particular direction can be described mathematically by stating that the gain of an array with weights $\mathbf{w}$ in the direction is

where denotes the transpose operation (not conjugate transpose).

In MFM, to evaluate the gain of the array (with weights applied) in a particular azimuth and elevation, use

```
g = a.get_array_gain(az,el)
```

where `az`

and `el`

are azimuth and elevation angles in radians and `g`

is the complex gain of the weighted array.

### Geting the Weighted Array Response

The array response vector * with array weights applied* is simply the array response vector multiplied element-wise by the array weights

To retrieve the weighted array response, simply use

```
v = a.get_weighted_array_response(az,el)
```

where `az`

and `el`

are azimuth and elevation angles in radians and `v`

is the consequent weighted array response (a column vector).

By using this, the array weights can be used more broadly than for beamforming—e.g., for capturing phase or gain inconsistencies across array elements.

### Viewing the Array Pattern

The `array`

object has several functions that can be used to view its array pattern—the array response (magnitude and phase) as a function of azimuth angle and elevation angle.

Note that these all plot the * weighted* array pattern, meaning they capture any weights set to the array.

#### Azimuth and Elevation Cuts

To view the magnitude and phase of the array response as a function of azimuth angle and elevation angle, use

```
a.show_array_pattern()
```

or

```
a.show_array_pattern(az,el)
```

where `el`

is the elevation angle (in radians) to use when evaluating the azimuth pattern and `az`

is the azimuth angle (in radians) to use when evaluating the elevation pattern.

#### Azimuth Cut

To view the magnitude of the array response as a function of azimuth angle alone, use

```
a.show_array_pattern_azimuth()
```

or

```
a.show_array_pattern_azimuth([],el)
```

where `el`

is the elevation angle (in radians) to use when evaluating the azimuth pattern.

#### Elevation Cut

To view the magnitude of the array response as a function of elevation angle alone, use

```
a.show_array_pattern_elevation()
```

or

```
a.show_array_pattern_elevation([],az)
```

where `az`

is the azimuth angle (in radians) to use when evaluating the elevation pattern.

#### Azimuth Cut and Elevation Cut in a Polar Plot

To view the array patterns * in a polar plot*, use

```
a.show_polar_array_pattern_azimuth()
a.show_polar_array_pattern_elevation()
```

or

```
a.show_polar_array_pattern_azimuth([],el)
a.show_polar_array_pattern_elevation([],az)
```

which shows the magnitude of the array response as a function of azimuth angle and of elevation angle.

### List of Properties

The `array`

object contains the following properties:

`array.num_antennas`

`array.x`

`array.y`

`array.z`

`array.weights`

`array.marker`

### List of Methods

The `array`

object contains the following methods:

`array.add_element`

Adds an element or group of elements to the array based on their (x,y,z)-coordinates (in wavelengths).`array.array`

Creates an instance of an array object.`array.create`

Creates an antenna array object.`array.get_array_gain`

Returns the array gain in a given direction (azimuth and elevation) with the current array weights applied.`array.get_array_pattern_azimuth`

Returns the weighted array pattern as a function of azimuth angle for some fixed elevation angle.`array.get_array_pattern_elevation`

Returns the weighted array pattern as a function of elevation angle for some fixed azimuth angle.`array.get_array_response`

Returns the array response vector at a given azimuth and elevation. This response is simply the phase shifts experienced by the elements on an incoming plane wave at a given azimuth and elevation, normalized to the first element in the array.`array.get_conjugate_beamformer`

Returns the conjugate beamforming weights for steering in particular azimuth and elevation directions.`array.get_conjugate_beamformer_azimuth_matrix`

Returns a matrix whose columns are phased array beamformers in various directions of azimuth.`array.get_element_pattern_azimuth`

Returns the element pattern as a function of azimuth.`array.get_element_pattern_elevation`

Returns the element pattern as a function of elevation.`array.get_near_field_response`

`array.get_weighted_array_response`

Returns the weighted array response vector at a given azimuth and elevation.`array.get_zero_forcing_beamformer`

Returns the zero-forcing beamformer that accepts energy in one or more desired directions and rejects energy in one or more interfering directions.`array.initialize_ula`

Resets the array and creates a half-wavelength spaced, uniform linear array along a desired axis.`array.initialize_upa`

Resets the array and creates a half-wavelength spaced, uniform planar array in a desired plane.`array.remove_element`

Removes an element from the array.`array.reset`

Removes all array elements from the array.`array.rotate`

Rotates the array in 3-D space along the x-, y-, and z-axes by some specified rotations (in radians).`array.set_element_gain`

Sets the gain of each element in the array. Does not account for element’s radiation pattern; merely scales the isotropic pattern. Can be used when considering uniform gain over a range of directions (e.g., 3 dB gain from -60 degrees to +60 degrees).`array.set_marker`

Sets the marker used when plotting the array elements.`array.set_weights`

Applies complex weights to each array element. Note that these weights are applied directly and not conjugated beforehand.`array.show_2d`

Plots the array elements in 2-D space.`array.show_3d`

Plots the array elements in 3-D space.`array.show_array_pattern`

Plots the array pattern as a function of azimuth for a fixed elevation and as a function of elevation for a fixed azimuth.`array.show_array_pattern_azimuth`

Plots the magnitude of the array pattern as a function of azimuth angle.`array.show_array_pattern_elevation`

Plots the magnitude of the array pattern as a function of elevation angle.`array.show_beamformer_pattern`

Plots the resulting beam pattern when the array employs a specific set of beamforming weights. The array weights are not overwritten.`array.show_element_pattern`

Plots the element pattern as a function of azimuth and elevation.`array.show_polar_array_pattern_azimuth`

Plots the azimuth array pattern in a polar plot.`array.show_polar_array_pattern_elevation`

Plots the elevation array pattern in a polar plot.`array.show_radiation_pattern`

`array.translate`

Shifts the location of all elements in the array by some change in the x, y, and z directions (in wavelengths). When x, y, and z are not passed, the array will be centered at the origin.

### Methods Documentation

`add_element(x,y,z)`

`add_element(x,y,z)`

Adds an element or group of elements to the array based on their (x,y,z)-coordinates (in wavelengths).

- Usage:
`add_element(x,y,z)`

*Input Arguments*:`x`

— a scalar or vector of scalars of element x-coordinate(s)`y`

— a scalar or vector of scalars of element y-coordinate(s)`z`

— a scalar or vector of scalars of element z-coordinate(s)*Notes*:- If x, y, and z are not of equal length, an error is thrown.

`array(N,M,plane)`

`array(N,M,plane)`

Creates an instance of an array object.

- Usage:
`obj = array()`

`obj = array(N)`

`obj = array(N,M)`

`obj = array(N,[])`

`obj = array(N,M,plane)`

`obj = array(N,[],plane)`

*Input Arguments*:`N`

— (optional) number of elements in the array; or number of rows in a planar array if a second argument is passed`M`

— (optional) number of columns in a planar array`plane`

— (optional) a string specifying the plane to create the planar array in (either ‘xz’, ‘xy’, or ‘yz’); if not passed, ‘xz’ will be used*Return Values*:`obj`

— an array object*Notes*:- obj = ARRAY() Creates an empty array object.
- obj = ARRAY(N) Creates an array object where N array elements are uniformly spaced one-half wavelength apart along the x-axis.
- obj = ARRAY(N,M) Creates an array object representing a uniform planar array comprised of N rows of M elements, uniformly spaced one-half wavelength apart in the x-z plane.

`create(N,M,plane)`

`create(N,M,plane)`

Creates an antenna array object.

- Usage:
`obj = array.create()`

`obj = array.create(N)`

`obj = array.create(N,M)`

`obj = array.create(N,[])`

`obj = array.create(N,M,plane)`

`obj = array.create(N,[],plane)`

*Input Arguments*:`N`

— (optional) number of elements in the array; or number of rows in a planar array if a second argument is passed`M`

— (optional) a string specifying which axis to create the linear array; or number of columns in a planar array`plane`

— (optional) a string specifying the plane to create the planar array in (either ‘xz’, ‘xy’, or ‘yz’); if not passed, ‘xz’ will be used*Return Values*:`obj`

— an array object

`get_array_gain(az,el)`

`get_array_gain(az,el)`

Returns the array gain in a given direction (azimuth and elevation) with the current array weights applied.

- Usage:
`gain = get_array_gain()`

`gain = get_array_gain(az)`

`gain = get_array_gain([],el)`

`gain = get_array_gain(az,el)`

*Input Arguments*:`az`

— (optional) azimuth angle of interest (radians); if not passed, 0 is used`el`

— (optional) elevation angle of interest (radians); if not passed, 0 is used*Return Values*:`g`

— complex gain of the weighted array in the azimuth and elevation of interest

`get_array_pattern_azimuth(el,N,full)`

`get_array_pattern_azimuth(el,N,full)`

Returns the weighted array pattern as a function of azimuth angle for some fixed elevation angle.

- Usage:
`[x,az] = get_array_pattern_azimuth()`

`[x,az] = get_array_pattern_azimuth(el)`

`[x,az] = get_array_pattern_azimuth(el,N)`

`[x,az] = get_array_pattern_azimuth(el,N,full)`

*Input Arguments*:`el`

— (optional) elevation angle to use when evaluating the azimuth array pattern (radians); if not passed, 0 is used`N`

— (optional) number of azimuth points used to evaluate array pattern; if not passed, 1024 is used`full`

— (optional) a boolean specifying if the full azimuth sweep should be executed (true) or half (false); default is false; a full azimuth sweep is from [-pi,+pi); a half azimuth sweep is from [-pi/2,+pi/2)*Return Values*:`x`

— weighted array pattern as a function of azimuth angle`az`

— azimuth angles (radians) used to assess the array pattern

`get_array_pattern_elevation(az,N,full)`

`get_array_pattern_elevation(az,N,full)`

Returns the weighted array pattern as a function of elevation angle for some fixed azimuth angle.

- Usage:
`[x,el] = get_array_pattern_elevation()`

`[x,el] = get_array_pattern_elevation(az)`

`[x,el] = get_array_pattern_elevation(az,N)`

`[x,el] = get_array_pattern_elevation(az,N,full)`

*Input Arguments*:`az`

— (optional) azimuth angle to use when evaluating the elevation array pattern (radians); if not passed, 0 is used`N`

— (optional) number of elevation points used to evaluate array pattern; if not passed, 1024 is used`full`

— (optional) a boolean specifying if the full elevation sweep should be executed (true) or half (false); default is false; a full elevation sweep is from [-pi,+pi); a half elevation sweep is from [-pi/2,+pi/2)*Return Values*:`x`

— weighted array pattern as a function of elevation angle`el`

— elevation angles (radians) used to assess the array pattern

`get_array_response(az,el)`

`get_array_response(az,el)`

Returns the array response vector at a given azimuth and elevation. This response is simply the phase shifts experienced by the elements on an incoming plane wave at a given azimuth and elevation, normalized to the first element in the array.

- Usage:
`a = get_array_response()`

`a = get_array_response(az)`

`a = get_array_response([],el)`

`a = get_array_response(az,el)`

*Input Arguments*:`az`

— (optional) azimuth angle of interest (radians); if not passed, 0 is used`el`

— (optional) elevation angle of interest (radians); if not passed, 0 is used*Return Values*:`a`

— the array response vector at the azimuth and elevation of interest

`get_conjugate_beamformer(az,el)`

`get_conjugate_beamformer(az,el)`

Returns the conjugate beamforming weights for steering in particular azimuth and elevation directions.

- Usage:
`w = get_conjugate_beamformer()`

`w = get_conjugate_beamformer(az)`

`w = get_conjugate_beamformer([],el)`

`w = get_conjugate_beamformer(az,el)`

*Input Arguments*:`az`

— (optional) azimuth angle of interest (radians); if not passed, 0 is used`el`

— (optional) elevation angle of interest (radians); if not passed, 0 is used*Return Values*:`w`

— array weights corresponding to the conjugate beamformer that steers toward the azimuth and elevation of interest

`get_conjugate_beamformer_azimuth_matrix(N,el)`

`get_conjugate_beamformer_azimuth_matrix(N,el)`

Returns a matrix whose columns are phased array beamformers in various directions of azimuth.

- Usage:
`[A,th] = GET_PHASED_ARRAY_BEAMFORMER_AZIMUTH_MATRIX()`

`[A,th] = GET_PHASED_ARRAY_BEAMFORMER_AZIMUTH_MATRIX(N)`

`[A,th] = GET_PHASED_ARRAY_BEAMFORMER_AZIMUTH_MATRIX(N,el)`

*Input Arguments*:`N`

— number of beamformers to return in matrix (number of columns in A)`el`

— elevation angle used when giving the azimuth conjugate beamformer (optional, default of 0 radians)*Return Values*:`A`

— matrix of size Na-by-N whose columns are the array response vectors for the azimuth angles of interest at the fixed elevation angle`th`

— correpsonding azimuth angles which A is used for estimation

`get_element_pattern_azimuth()`

`get_element_pattern_azimuth()`

Returns the element pattern as a function of azimuth.

- Usage:
`[xx,th] = get_element_pattern_azimuth()`

*Return Values*:`xx`

— the element pattern as a function of azimuth angle`th`

— azimuth angles corresponding to the values in xx (radians)

`get_element_pattern_elevation()`

`get_element_pattern_elevation()`

Returns the element pattern as a function of elevation.

- Usage:
`[xx,ph] = get_element_pattern_elevation()`

*Return Values*:`xx`

— the element pattern as a function of elevation angle`ph`

— elevation angles corresponding to the values in xx (radians)

`get_near_field_response()`

`get_near_field_response()`

`get_weighted_array_response(az,el)`

`get_weighted_array_response(az,el)`

Returns the weighted array response vector at a given azimuth and elevation.

- Usage:
`a = get_weighted_array_response()`

`a = get_weighted_array_response(az)`

`a = get_weighted_array_response([],el)`

`a = get_weighted_array_response(az,el)`

*Input Arguments*:`az`

— (optional) azimuth angle of interest (radians); if not passed, 0 is used`el`

— (optional) elevation angle of interest (radians); if not passed, 0 is used*Return Values*:`a`

— the array response vector at the azimuth and elevation of interest, incorporating array weights

`get_zero_forcing_beamformer(az_des,el_des,az_int,el_int)`

`get_zero_forcing_beamformer(az_des,el_des,az_int,el_int)`

Returns the zero-forcing beamformer that accepts energy in one or more desired directions and rejects energy in one or more interfering directions.

- Usage:
`w = get_zero_forcing_beamformer(az_des,el_des,az_int,el_int)`

*Input Arguments*:`az_des`

— desired azimuth angle(s) in radians`el_des`

— desired elevation angles(s) in radians`az_int`

— interfering azimuth angle(s) in radians`el_int`

— interfering elevation angle(s) in radians*Return Values*:`w`

— a beamformer that attempts to accept energy in the desired directions while rejecting energy in the interfering directions

`initialize_ula(N,ax)`

`initialize_ula(N,ax)`

Resets the array and creates a half-wavelength spaced, uniform linear array along a desired axis.

- Usage:
`initialize_ula(N)`

`initialize_ula(N,ax)`

*Input Arguments*:`N`

— the number of array elements in the array`ax`

— (optional) a string specifying which axis to create the ULA along (either ‘x’, ‘y’, or ‘z’); if not passed, ‘x’ will be used

`initialize_upa(nrows,ncols,plane)`

`initialize_upa(nrows,ncols,plane)`

Resets the array and creates a half-wavelength spaced, uniform planar array in a desired plane.

- Usage:
`initialize_upa(nrows)`

`initialize_upa(nrows,ncols)`

`initialize_upa(nrows,[],plane)`

`initialize_upa(nrows,ncols,plane)`

*Input Arguments*:`nrows`

— number of rows (second axis) in the planar array`ncols`

— (optional) number of columns (first axis) in the planar array; if not passed, the number of rows (nrows) will be used`plane`

— (optional) a string specifying which plane to create the UPA in (either ‘xy’, ‘xz’, or ‘yz’); if not passed, ‘xz’ will be used

`remove_element(idx)`

`remove_element(idx)`

Removes an element from the array.

- Usage:
`remove_element()`

`remove_element(idx)`

*Input Arguments*:`idx`

— (optional) index of the element to remove from the array; if not passed, the last element will be removed

`reset()`

`reset()`

Removes all array elements from the array.

- Usage:
`reset()`

`rotate(rot_x,rot_y,rot_z,inplace)`

`rotate(rot_x,rot_y,rot_z,inplace)`

Rotates the array in 3-D space along the x-, y-, and z-axes by some specified rotations (in radians).

- Usage:
`rotate(rot_x)`

`rotate(rot_x,rot_y)`

`rotate(rot_x,rot_y,rot_z)`

`rotate(rot_x,rot_y,rot_z,inplace)`

*Input Arguments*:`rot_x`

— rotation around x-axis (radians)`rot_y`

— (optional) rotation around y-axis (radians); if not passed, 0 is used`rot_z`

— (optional) rotation around z-axis (radians); if not passed, 0 is used`inplace`

— (optional) a boolean indicating if the rotation should made about the true origin (0,0,0) (false) or the array’s center (true); if not passed, false is used

`set_element_gain(power_gain_dB)`

`set_element_gain(power_gain_dB)`

Sets the gain of each element in the array. Does not account for element’s radiation pattern; merely scales the isotropic pattern. Can be used when considering uniform gain over a range of directions (e.g., 3 dB gain from -60 degrees to +60 degrees).

- Usage:
`set_element_gain(power_gain_dB)`

*Input Arguments*:`power_gain_dB`

— the element’s power gain in dB

`set_marker(marker)`

`set_marker(marker)`

Sets the marker used when plotting the array elements.

- Usage:
`set_marker()`

`set_marker(marker)`

*Input Arguments*:`marker`

— (optional) a string specifying the plot marker to use; in addition to MATLAB’s plot markers (e.g., ‘kx’), ‘transmit’ or ‘receive’ are also valid; if not passed, ‘kx’ is used

`set_weights(w)`

`set_weights(w)`

Applies complex weights to each array element. Note that these weights are applied directly and not conjugated beforehand.

- Usage:
`set_weights()`

`set_weights(w)`

*Input Arguments*:`w`

— (optional) a weight vector where the i-th array element is weighted by the i-th element in w; if not passed, a vector of ones is used

`show_2d(ax,plane)`

`show_2d(ax,plane)`

Plots the array elements in 2-D space.

- Usage:
`[fig,ax] = SHOW2D()`

`[fig,ax] = SHOW2D(ax)`

`[fig,ax] = SHOW2D(ax,plane)`

`[fig,ax] = SHOW2D([],plane)`

*Input Arguments*:`ax`

— (optional) an axes handle to plot on`plane`

— (optional) a string specifying which plane to show (either ‘xy’, ‘xz’, or ‘yz’); if not passed, ‘xz’ is used.*Return Values*:`fig`

— a figure handle`ax`

— an axes handle

`show_3d(ax)`

`show_3d(ax)`

Plots the array elements in 3-D space.

- Usage:
`[fig,ax] = SHOW3D()`

`[fig,ax] = SHOW3D(ax)`

*Input Arguments*:`ax`

— (optional) existing axes to plot on*Return Values*:`fig`

— a figure handle`ax`

— an axes handle

`show_array_pattern(az,el,N,full)`

`show_array_pattern(az,el,N,full)`

Plots the array pattern as a function of azimuth for a fixed elevation and as a function of elevation for a fixed azimuth.

- Usage:
`show_array_pattern()`

`show_array_pattern(az)`

`show_array_pattern(az,el)`

`show_array_pattern(az,el,N)`

`show_array_pattern(az,el,N,full)`

*Input Arguments*:`az`

— (optional) the azimuth angle (in radians) to use when evaluating the array elevation pattern; if not passed, the default is used`el`

— (optional) the elevation angle (in radians) to use when evaluating the array azimuth pattern; if not passed, the default is used`N`

— (optional) number of points to take when evaluating the array pattern; if not passed, the default is used`full`

— (optional) a boolean specifying if the full sweep should be executed (true) or half (false); default is false; a full sweep is from [-pi,+pi); a half sweep is from [-pi/2,+pi/2)

`show_array_pattern_azimuth(ax,el,N,full)`

`show_array_pattern_azimuth(ax,el,N,full)`

Plots the magnitude of the array pattern as a function of azimuth angle.

- Usage:
`show_array_pattern_azimuth()`

`show_array_pattern_azimuth(ax)`

`show_array_pattern_azimuth(ax,el)`

`show_array_pattern_azimuth(ax,el,N)`

`show_array_pattern_azimuth(ax,el,N,full)`

*Input Arguments*:`ax`

— (optional) an axes handle; if not passed, a new one will be created`el`

— (optional) the elevation angle (in radians) to use when evaluating the array azimuth pattern; if not passed, the default is used`N`

— (optional) number of points to take when evaluating the array pattern; if not passed, the default is used`full`

— (optional) a boolean specifying if the full azimuth sweep should be executed (true) or half (false); default is false; a full azimuth sweep is from [-pi,+pi); a half azimuth sweep is from [-pi/2,+pi/2)

`show_array_pattern_elevation(ax,az,N,full)`

`show_array_pattern_elevation(ax,az,N,full)`

Plots the magnitude of the array pattern as a function of elevation angle.

- Usage:
`show_array_pattern_elevation()`

`show_array_pattern_elevation(ax)`

`show_array_pattern_elevation(ax,az)`

`show_array_pattern_elevation(ax,az,N)`

`show_array_pattern_elevation(ax,az,N,full)`

*Input Arguments*:`ax`

— (optional) an existing axes handle; if not passed, a new one will be created`az`

— (optional) the azimuth angle (in radians) to use when evaluating the array elevation pattern; if not passed, the default is used`N`

— (optional) number of points to take when evaluating the array pattern; if not passed, the default is used`full`

— (optional) a boolean specifying if the full elevation sweep should be executed (true) or half (false); default is false; a full elevation sweep is from [-pi,+pi); a half elevation sweep is from [-pi/2,+pi/2)

`show_beamformer_pattern(w)`

`show_beamformer_pattern(w)`

Plots the resulting beam pattern when the array employs a specific set of beamforming weights. The array weights are not overwritten.

- Usage:
`show_beamformer_pattern(w)`

*Input Arguments*:`w`

— a vector of complex beamforming weights

`show_element_pattern()`

`show_element_pattern()`

Plots the element pattern as a function of azimuth and elevation.

- Usage:
`show_element_pattern()`

`show_polar_array_pattern_azimuth(ax,el,N,full)`

`show_polar_array_pattern_azimuth(ax,el,N,full)`

Plots the azimuth array pattern in a polar plot.

- Usage:
`show_polar_array_pattern_azimuth()`

`show_polar_array_pattern_azimuth(ax)`

`show_polar_array_pattern_azimuth(ax,el)`

`show_polar_array_pattern_azimuth(ax,el,N)`

`show_polar_array_pattern_azimuth(ax,el,N,full)`

*Input Arguments*:`ax`

— (optional) axes handle to plot on; if not provided, will create a new figure and axes to plot on`el`

— (optional) the elevation angle (radians) to use when evaluating the azimuth pattern`N`

— (optional) number of points to take when evaluating the array pattern; if not passed, the default is used`full`

— (optional) a boolean specifying if the full sweep should be executed (true) or half (false); default is false; a full sweep is from [-pi,+pi); a half sweep is from [-pi/2,+pi/2)

`show_polar_array_pattern_elevation(ax,az,N,full)`

`show_polar_array_pattern_elevation(ax,az,N,full)`

Plots the elevation array pattern in a polar plot.

- Usage:
`show_polar_array_pattern_elevation()`

`Usage:`

`show_polar_array_pattern_elevation()`

`show_polar_array_pattern_elevation(ax)`

`show_polar_array_pattern_elevation(ax,az)`

`show_polar_array_pattern_elevation(ax,az,N)`

`show_polar_array_pattern_elevation(ax,az,N,full)`

*Input Arguments*:`ax`

— (optional) axes handle to plot on; if not provided, will create a new figure and axis to plot on`az`

— (optional) the azimuth angle (radians) to use when evaluating the elevation pattern`N`

— (optional) number of points to take when evaluating the array pattern; if not passed, the default is used`full`

— (optional) a boolean specifying if the full sweep should be executed (true) or half (false); default is false; a full sweep is from [-pi,+pi); a half sweep is from [-pi/2,+pi/2)

`show_radiation_pattern()`

`show_radiation_pattern()`

`translate(x,y,z)`

`translate(x,y,z)`

Shifts the location of all elements in the array by some change in the x, y, and z directions (in wavelengths). When x, y, and z are not passed, the array will be centered at the origin.

- Usage:
`translate()`

`translate(x)`

`translate(x,y)`

`translate(x,y,z)`

*Input Arguments*:`x`

— (optional) wavelengths to move in the x direction; if not passed, the negative mean x coordinate is used which will center the array in the x direction`y`

— (optional) wavelengths to move in the y direction; if not passed, the negative mean y coordinate is used which will center the array in the y direction`z`

— (optional) wavelengths to move in the z direction; if not passed, the negative mean z coordinate is used which will center the array in the z direction