The *global* coordinate system describes
the arena in which your radar or sonar simulation takes place. Within
this arena, you can place radar or sonar transmitters and receivers,
and targets. These objects can be either stationary and moving. You
specify the location and motion of these objects in global coordinates.

You can model the motion of all objects using the `phased.Platform`

System object™.
This System object computes the position and speed of objects
using constant-velocity or constant-acceleration models.

You can model the signals that propagate between objects in
your scenario. The ray paths that connect transmitters, targets, and
receivers are specified in global coordinates. You can propagate signals
using these System objects: `phased.FreeSpace`

, `WidebandFreeSpace`

, `phased.LOSChannel`

, or `phased.WidebandLOSChannel`

.
If you model two-ray multipath propagation using the `phased.TwoRayChannel`

System object,
the boundary plane is set at *z = 0* in the global
coordinate system.

When signals interact with sensors or targets, the interaction is almost always specified as a function of the sensor or target local coordinates. Local coordinate systems are fixed to the antennas and microphones, phased arrays, and targets. They move and rotate with the object. Local coordinates are commonly adapted to the shape and symmetry of the object.

Because signals propagate in the global coordinate system, you need to be able to convert local coordinates to the global coordinates. You do this by constructing a 3-by-3 orthonormal matrix of coordinate axes. The matrix columns represent the three orthogonal direction vectors of the local coordinates expressed in the global coordinate system. The coordinate axes of a local coordinate system must be orthonormal, but they need not be parallel to the global coordinate axes.

When you need to compute the range and arrival angles of a signal,
you can use the `rangeangle`

function.
When you call this function with the source and receiver position
expressed in global coordinates, the function returns the range and
arrival angles, azimuth and elevation, with respect to the axes of
the global system. However, when you pass the orientation matrix as
an additional argument, the azimuth and elevation are now defined
with respect to the local coordinate system.

You use local coordinates to specify

the location and orientation of antenna or microphone elements of an array. The beam pattern of an antenna array depends upon the angle of arrival or emission of radiation with respect to the array local coordinates.

the reflected energy from a target is a function of the incident and reflection angles with respect to the target local coordinate axes.

Two examples of local coordinate systems are

an airplane may have a local coordinate system with the

*x*-axis aligned along the fusilage axis of the body and the*y*-axis pointing along the port wing. Choose the*z*-axis to form a right-handed coordinate system.a vehicle-mounted planar phased array may have a local coordinate system adapted to the array. The

*x*-axis of the coordinate system may point along the array normal vector

The following figure illustrates the relationship of local and global coordinate systems in a bistatic radar scenario. The thick solid lines represent the coordinate axes of the global coordinate system. There are two phased arrays: a 5-by-5 transmitting uniform rectangular array (URA) and 5-by-5 receiving URA. Each of the phased arrays carries its own local coordinate system. The target, indicated by the red arrow, also carries a local coordinate system.

The next few sections review the local coordinate systems used by arrays.

The positions of the elements of any Phased Array System Toolbox™ array
are always defined in a local coordinate system. When you use any
of the System objects that create uniform arrays, the array element
positions are defined automatically with respect to a predefined local
coordinate system. The arrays for which this property holds are the `phased.ULA`

, `phased.URA`

, `phased.UCA`

, `phased.HeterogeneousULA`

,
and `phased.HeterogeneousURA`

System
objects. For these System objects, the arrays are described using
a few parameters such as element spacing and number of elements. The
positions of the elements are then defined with respect to the array
origin located at *(0,0,0)* which is the geometric
center of the array. The geometric center is a good approximation
to the array *phase center*. The *phase
center* of an array is the point from which the radiating
waves appear to emanate when observed in the far field. For example,
for a ULA with an odd number of elements, the elements are located
at distances (*-2d*,*-d*,*0*,*d*,*2d*)
along the array axis.

There are array System objects for which you must explicitly
specify the element coordinates. You can use these objects for creating
arbitrary array shapes. These objects are the`phased.ConformalArray`

and `phased.HeterogeneousConformalArray`

System
objects. For these arrays, the phase center of the array need not
coincide with the array origin or geometric center.

**Element Boresight Directions. **In addition to element positions, you need to specify the element
orientations, that is, the directions in which the elements point.
Some elements are highly directional — most of their radiated
energy flows in one direction, called the main response axis (MRA).
Others are omnidirectional. Element orientation is the pointing direction
of the MRA. You specify element orientation using azimuth and elevation
in the array local coordinate system. The direction that an antenna
or microphone MRA faces when transmitting or receiving a signal is
also called the *boresight* or *look* direction.
For the uniform arrays, all boresight directions of all elements are
determined by array parameters. For conformal arrays, you specify
the boresight direction of each element independently.

**Array Origin and Phase Center. **A uniform linear array (ULA) is an array of antenna or microphone
elements that are equidistantly spaced along a straight line. In the Phased Array System Toolbox,
the `phased.ULA`

System object creates
a ULA array. The geometry of the ULA orientation of its elements are
determined by three parameters: the number of elements, the distance
between elements, and the `ArrayAxis`

property.
For the ULA, the local coordinate system is adapted to the array —
the elements are automatically assigned positions in the local coordinate
system.

The positions of elements in the array are determined by the `ArrayAxis`

property
which can take the values `'x'`

, `'y'`

or `'z'`

.
The array axis property determines the axis on which all elements
are defined. For example, when the `ArrayAxis`

property
is set to `'x'`

, the array elements lie along the *x*-axis.
The elements are position symmetrically with respect to the origin.
Therefore, the geometric center of the array lies at the origin of
the coordinate system.

This figure shows a four-element ULA with directional elements
in a local right-handed coordinate system. The elements lie on the *y*-axis
with their boresight axes pointing in the *x*-direction.
In this case, the `ArrayAxis`

property is set to `'y`

.

**ULA Element Boresight Direction. **In a ULA, the boresight directions of every element point in
the same direction. The direction is orthogonal to the array axis.
This direction depends upon the choice of `ArrayAxis`

property.

ArrayAxis Property Value | Element Positions and Boresight Directions |
---|---|

`'x'` | Array elements lie on the x-axis. Element
boresight vectors point along the y-axis. |

`'y'` | Array elements lie on the y-axis. Element
boresight vectors point along the x-axis. |

`'z'` | Array elements lie on the z-axis. Element
boresight vectors point along the x-axis. |

**Local Coordinates Adapted to Uniform Linear Array **

Construct two examples of a uniform linear array and display the coordinates of the elements with respect to the local coordinate systems defined by the arrays.

First, construct a 4-element ULA with one-half meter element spacing.

sULA = phased.ULA('NumElements',4,'ElementSpacing',0.5); ElementLocs = getElementPosition(sULA) viewArray(sULA)

ElementLocs = 0 0 0 0 -0.7500 -0.2500 0.2500 0.7500 0 0 0 0

The origin of the array-centric local coordinate system is set to the phase center of the array. The phase center is the average value of the array element positions.

disp(mean(ElementLocs'))

0 0 0

Because the array has an even number of elements, no element of the array actually lies at the phase center *(0,0,0)*.

Next construct a 5-element ULA with thirty-centimeter element spacing.

sULA1 = phased.ULA('NumElements',5,'ElementSpacing',0.3); ElementLocs = getElementPosition(sULA1) viewArray(sULA1)

ElementLocs = 0 0 0 0 0 -0.6000 -0.3000 0 0.3000 0.6000 0 0 0 0 0

Because the array has an odd number of elements in each row and column, the center element of the array lies at the phase center.

**Array Origin and Phase Center. **A uniform rectangular array (URA) is an array of antenna or
microphone elements placed on a regular two-dimensional grid. The
geometry of a URA and the location and orientation of its elements
are determined by several parameters: the dimensions of the array,
the distance between elements, and the `ArrayNormal`

property.
For the URA, the local coordinate system is adapted to the array —
the elements are automatically assigned positions in the local coordinate
system. The origin of the local coordinate system is the geometric
center of the array. The *phase center* of the
array coincides with the geometric center. The elements are automatically
assigned positions in this local coordinate system. The positions
are determined by the `ArrayNormal`

property which
can take the values `'x'`

, `'y'`

or `'z'`

.
All elements lie in a plane passing through the origin and orthogonal
to the axis specified in this property. For example, when the `ArrayNormal`

property
is set to `'x'`

, the array elements lie in the *yz*-plane
as shown in the figure. The figure shows a 2-by-4 element URA with
elements spaced *d* meters apart in both the *y* and *z* directions.

**Element Boresight Direction. **In a URA, like the ULA, THE boresight directions of every element
point in the same direction. You control this direction using the `ArrayNormal`

property.
For the URA shown in the preceding figure, the `ArrayNormal`

property
is set to `'x'`

. Then, element boresights point along
the *x*-axis.

ArrayNormal Property Value | Element Positions and Boresight Directions |
---|---|

`'x'` | Array elements lie on the yz-plane. Element
boresight vectors point along the x-axis. |

`'y'` | Array elements lie on the zx-plane. Element
boresight vectors point along the y-axis. |

`'z'` | Array elements lie on the xy-plane. Element
boresight vectors point along the z-axis. |

**Local Coordinates Adapted to Uniform Rectangular Array **

Construct two examples of uniform rectangular arrays and display the coordinates of the elements with respect to the local coordinate systems defined by the arrays.

First, construct a 2-by-4 URA with one-half meter element spacing.

sURA = phased.URA('Size',[2 4],'ElementSpacing',[0.5 0.5]); ElementLocs = getElementPosition(sURA) viewArray(sURA)

ElementLocs = Columns 1 through 7 0 0 0 0 0 0 0 -0.7500 -0.7500 -0.2500 -0.2500 0.2500 0.2500 0.7500 0.2500 -0.2500 0.2500 -0.2500 0.2500 -0.2500 0.2500 Column 8 0 0.7500 -0.2500

The phase center of the array is the mean value of the array element positions. The origin of the array local coordinate system is set to the phase center of the array.

disp(mean(ElementLocs'))

0 0 0

Because the array has an even number of elements in each row and column, no element of the array actually lies at the phase center *(0,0,0)*.

Next construct a 5-by-3 URA with thirty-centimeter element spacing.

```
sURA1 = phased.URA([5 3],'ElementSpacing',[0.3 0.3]);
ElementLocs = getElementPosition(sURA1)
viewArray(sURA1)
```

ElementLocs = Columns 1 through 7 0 0 0 0 0 0 0 -0.3000 -0.3000 -0.3000 -0.3000 -0.3000 0 0 0.6000 0.3000 0 -0.3000 -0.6000 0.6000 0.3000 Columns 8 through 14 0 0 0 0 0 0 0 0 0 0 0.3000 0.3000 0.3000 0.3000 0 -0.3000 -0.6000 0.6000 0.3000 0 -0.3000 Column 15 0 0.3000 -0.6000

Because the array has an odd number of elements in each row and column, the center element of the array lies at the phase center.

A signal arrives at the array from a point 1000 meters from along the *+x*-axis of the global coordinate system. The local URA array is rotated 30 degrees clockwise around the y-axis. Compute the angle of arrival of the signal in the local array axes.

laxes = roty(30); [rng,ang] = rangeangle([1000,0,0]',[0,0,0]',laxes)

rng = 1000 ang = 0 30.0000

**Array Origin and Phase Center. **A uniform circular array (UCA) is an array of antenna or microphone
elements spaced at equal angles around a circle. The `phased.UCA`

System object creates
a special case of a UCA. In this case, element boresight directions
point away from the array origin like spokes of a wheel. The origin
of the local coordinate system is the geometric center of the array.
The geometry of the UCA and the location and orientation of its elements
is determined by three parameters: the radius of the array, the number
of elements, and the `ArrayNormal`

property. The
elements are automatically assigned positions in the local coordinate
system. The positions are determined by the `ArrayNormal`

property
which can take the values `'x'`

, `'y'`

or `'z'`

.
All elements lie in a plane passing through the origin and orthogonal
to the axis specified in this property. The *phase center* of
the array coincides with the geometric center. For example, when the `ArrayNormal`

property
is set to `'x'`

, the array elements lie in the *yz*-plane
as shown in the figure. you can create a more general UCA with arbitrary
boresight directions using the `phased.ConformalArray`

System
object.)

This figure shows an 8-element UCA with elements lying in the *yz* plane.

**Element Boresight Directions. **In a UCA defined by a `phased.UCA`

System object, element boresight directions
point radially outward from the array origin. In the UCA shown in
the preceding figure, because the `ArrayNormal`

property
is set to `'x'`

, the element boresight directions
point radially outward in the *yz*-plane.

ArrayNormal Property Value | Element Positions and Boresight Directions |
---|---|

`'x'` | Array elements lie on the yz-plane. All
element boresight vectors lie in the yz-plane and
point radially-outward from the origin. |

`'y'` | Array elements lie on the zx-plane. All
element boresight vectors lie in the zx-plane and
point radially-outward from the origin. |

`'z'` | Array elements lie on the xy-plane. All
element boresight vectors lie in the xy-plane and
point radially-outward from the origin. |

**Array Origin and Phase Center. **You can use `phased.ConformalArray`

to create arrays
of arbitrary shape. Unlike the case of uniform arrays, you must specify
the element positions explicitly. An *N*-element
array requires the specification of *N* 3-D coordinates
in the array local coordinate system. The origin of a conformal array
can be located at any arbitrary point. The boresight directions of
the elements of a conformal array need not be parallel. The azimuth
and elevation angles defining the boresight directions are with respect
to the local coordinate system. The phase center of the array does
not need to coincide with the geometric center. The same properties
apply to the `phased.HeterogeneousConformalArray`

array.

This illustration shows the positions and orientations of a 4-element conformal array.

**4-Element Conformal Array **

Construct a 4-element array using the ConformalArray System object. Assume the operating frequency is 900 MHz. Display the array geometry and normal vectors.

fc = 900e6; c = physconst('LightSpeed'); lam = c/fc; x = [1.0,-.5,0,.8]*lam/2; y = [-.4,-1,.5,1.5]*lam/2; z = [-.3,.3,0.4,0]*lam/2; sIso = phased.CosineAntennaElement(... 'FrequencyRange',[0,1e9]); nv = [-140,-140,90,90;80,80,80,80]; sConformArray = phased.ConformalArray('Element',sIso,... 'ElementPosition',[x;y;z],... 'ElementNormal',nv); pos = getElementPosition(sConformArray) normvec = getElementNormal(sConformArray) viewArray(sConformArray,'ShowIndex','All','ShowNormal',true)

pos = 0.1666 -0.0833 0 0.1332 -0.0666 -0.1666 0.0833 0.2498 -0.0500 0.0500 0.0666 0 normvec = -140 -140 90 90 80 80 80 80

In many array processing applications, it is necessary to convert
between global and local coordinates. Two utility functions, `global2localcoord`

and `local2globalcoord`

, enable you to do this
conversion.

**Convert Local Spherical Coordinates to Global Rectangular Coordinates**

Assume a stationary target 1000 meters from a URA at an azimuth angle of 30 degrees and elevation angle of 45 degrees. The phase center of the URA is located at the rectangular coordinates [1000 500 100] in the global coordinate system. The local coordinate axes of the URA are parallel to the global coordinate axes. Determine the position of the target in rectangular coordinates in the global coordinate system.

In this example, the target's location is specified in
local spherical coordinates. The target is 1000 meters from the array,
which means that *R*=1000. The azimuth angle of 30
degrees and elevation angle of 45 degrees give the direction of the
target from the array. The spherical coordinates of the target in
the local coordinate system are (30,45,1000). To convert to global
rectangular coordinates, you must know the position of the array in
global coordinates. The phase center of the array is located at [1000
500 100]. To convert from local spherical coordinates to global rectangular
coordinates, use the `'sr'`

option.

gCoord = local2globalcoord([30; 45; 1000],'sr',... [1000; 500; 100]);

**Convert Global Rectangular Coordinates to Local Spherical Coordinates**

Assume a stationary target with global rectangular coordinates *(5000,3000
,50)*. The phase center of a URA has global rectangular coordinates *(1000,500,10)*.
The local coordinate axes of the URA are *(0,1,0)*, *(1,0,0)*,
and *(0,0,–1)*. Determine the position of
the target in local spherical coordinates.

lCoord = global2localcoord([5000; 3000; 50],'rs',... [1000; 500; 10],[0 1 0;1 0 0;0 0 -1]);

The output `lCoord`

takes the form (*az*,*el*,*R*).
The target in local coordinates has an azimuth of approximately 58
degrees, an elevation of 0.5 degrees, and a range of 4717.16 m.

Was this topic helpful?