Array Synthesis for Lidar Systems

This example uses:

Open Script

This example shows how to design and optimize a phased array for lidar applications. The example describes the following workflow:

  1. Import an antenna element pattern generated with Lumerical tools into MATLAB®

  2. Design a linear phased array using the Lumerical antenna pattern for each element in the array

  3. Determine the array element spacing and weighting for the array such that the azimuth pattern and elevation pattern (generated from the Lumerical tools) are closely matched between a desired steering range

A related example can be found on Lumerical's website at Lumerical Lidar Antenna Example. The Lumerical's example provides more details on how the antenna element is designed with the FDE solver; how the antenna element design is verified and extracted with 3D FDTD technique; and how the array designed using Phased Array System Toolbox™ is integrated in Lumerical's INTERCONNECT software.

This example requires Optimization Toolbox™.

Introduction

Lidar is used as a perception sensor in autonomous systems. Lidar sensors are capable of ranging millions of points per second due to high angular resolutions and fast steering speeds. Beam steering in lidar architectures can be accomplished with optical phased arrays. This example shows how to design the integrated optical phased array antenna which can be used for both transmitting and receiving functions.

Modeling the Phased Array

First, import the antenna pattern generated using Lumerical tools.

load('Lumerical_antenna_data.mat'); % Load Lumerical antenna pattern

The antenna occupies a large bandwidth. The data set generated with Lumerical tools contains antenna responses for 50 frequencies.

nfreq = numel(freqVector);            % 50 frequency vectors
ant = phased.CustomAntennaElement('FrequencyVector',freqVector,...
    'FrequencyResponse',zeros(1,nfreq),...
    'AzimuthAngles',az,'ElevationAngles',el,...
    'MagnitudePattern',pat_azel,'PhasePattern',zeros(size(pat_azel)));

The array to be designed is a 48-element linear array along azimuth direction. The goal is to

The array to be designed is a 48-element linear array with a hamming taper. The number of elements was chosen in this example to provide a narrow beam. The element spacing is set at 1.2 wavelength corresponding to the center frequency due to physical constrains in building lidar arrays. Since the spacing is larger than half wavelength, grating lobe may occur. However, in this application, the array only scans a limited range around the boresight. Therefore, grating lobes are not a concern.

c = 3e8;
lambda = c/freqVector(25);
N = 48;
antarray = phased.ULA(N,1.2*lambda,'Element',ant,'Taper',hamming(N));
stv = phased.SteeringVector('SensorArray',antarray,'PropagationSpeed',c);

Following figures show the resulting array patterns at boresight for 3 frequency values (frequency bands 1, 25, and 50) to see the resulting 3D beam pattern across the full range. Note how the main beam changes with frequency. In the plots below, the beams are steered at 0 degrees azimuth.

svang = [0;0];    % Steer at 0 degrees in azimuth

n = 1;
fc = freqVector(n);
pattern(antarray,fc,'Type','powerdb','Weights',stv(fc,svang));
title(sprintf('Array Pattern for Frequency Band %d',n));
snapnow;

n = 25;
fc = freqVector(n);
pattern(antarray,fc,'Type','powerdb','Weights',stv(fc,svang));
title(sprintf('Array Pattern for Frequency Band %d',n));
snapnow;

n = 50;
fc = freqVector(n);
pattern(antarray,fc,'Type','powerdb','Weights',stv(fc,svang));
title(sprintf('Array Pattern for Frequency Band %d',n));
snapnow;

Synthesizing Array Pattern

In this example, the array steering in elevation is done using different carrier frequencies. However, the array steering in azimuth is done by weighting the elements in the linear array. Therefore, our goal, through optimization, is to find weights and element spacing such that the shape of the beam in the azimuth cut matches the shape in the elevation cut.

To get the best match across the frequency range, we start with the elevation cut of the middle frequency value (band 25) as the desired shape. Because the application only requires the scanning between $\pm$ 20 degrees in azimuth, we will focus the pattern within the $\pm$ 40 degrees region to ensure there is no grating lobes come into $\pm$ 20 degrees region during scanning. Note that reflectors will be used on the physical array to ensure other transmissions are not sent out at angles outside $\pm$ 20 degrees.

azimuth = -40:40;
n = 25;             % Use center frequency as the basis for optimization
fc = freqVector(n);
Beam_d = pattern(antarray,fc,azimuth,0,'Type','efield','Weights',stv(fc,svang),'Normalize',false).';
antpat = pattern(ant,fc,azimuth,0,'Type','efield','Normalize',false).';

The objective function is set to minimize the distance between the desired pattern and the one that is generated as a result of synthesis. For this optimization, we want to generate a common spacing value between elements and unique real weights for each element to facilitate the implementation phase in the Lumerical Interconnect tool. In addition, to ensure the lidar array can be realized, a starting point of 1.1 wavelength is set.

w_i_re = ones(N,1)./2;                 % initial real values
w_i_im = zeros(N,1);                   % initial imaginary values
lambda_i = 1.1;                        % initial wavelength

objfun = @(x)norm(abs((x(1:N))'*...
    steervec((-(N-1)/2:(N-1)/2)*x(end),azimuth).*antpat)-Beam_d);

x_ini = [w_i_re;lambda_i];

[x_o, fval, ef, output] = ...
    fmincon(objfun,x_ini,[],[],[],[],[(zeros(N,1));1],[ones(N,1);1.2],[],...
    optimoptions(@fmincon,'Display','final-detailed','MaxFunctionEvaluations',1e4));

Optimization completed: The relative first-order optimality measure, 4.376626e-07,
is less than options.OptimalityTolerance = 1.000000e-06, and the relative maximum constraint
violation, 0.000000e+00, is less than options.ConstraintTolerance = 1.000000e-06.

Next plot shows the comparison between the desired pattern and the synthesized pattern.

azplot = -40:40;
Beam_d_plot = pattern(antarray,fc,azplot,0,'Type','efield','Weights',stv(fc,svang),'Normalize',false).';
antpat_plot = pattern(ant,fc,azplot,0,'Type','efield','Normalize',false).';
Beam_syn_plot = abs((x_o(1:N))'*steervec((-(N-1)/2:(N-1)/2)*x_o(end),azplot).*antpat_plot);
plot(azplot,mag2db(Beam_d_plot),'-',azplot,mag2db(Beam_syn_plot),'--');
legend('Desired','Synthesized')
title(sprintf('Frequency band %d with spacing of %5.2f wavelength',n,x_o(end)));
xlabel('Angle (deg)')
ylabel('Array Pattern')

The figure shows a strong match between the desired pattern and the synthesized pattern between $\pm$ 20 degrees. Again, anything outside this angle range will be blocked by a reflector in the actual system.

Verifying Scanning Behavior

To verify the resulting weights and element spacing, we steer the array to 20 degrees azimuth at both frequency bands #1 and #50 and examine if the array performance satisfies the application needs.

n = 50;
fc = freqVector(n);
wmag = x_o(1:N);

svang = [20;0];
azplot = -40:40;

Beam_d_plot = pattern(antarray,fc,azplot,0,'Type','efield','Weights',stv(fc,svang),'Normalize',false).';

antpat_plot = pattern(ant,fc,azplot,0,'Type','efield','Normalize',false).';
weights_o = wmag.*steervec((-(N-1)/2:(N-1)/2)*x_o(end),svang);
Beam_syn_plot = abs(weights_o'*steervec((-(N-1)/2:(N-1)/2)*x_o(end),azplot).*antpat_plot);

plot(azplot,mag2db(Beam_d_plot),'-',azplot,mag2db(Beam_syn_plot),'--');
legend('Desired','Synthesized')
title(sprintf('Frequency band %d with spacing of %5.2f wavelength',n,x_o(end)));
xlabel('Angle (deg)')
ylabel('Array Pattern')
snapnow;

n = 1;
fc = freqVector(n);

Beam_d_plot = pattern(antarray,fc,azplot,0,'Type','efield','Weights',stv(fc,svang),'Normalize',false).';

antpat_plot = pattern(ant,fc,azplot,0,'Type','efield','Normalize',false).';
weights_o = wmag.*steervec((-(N-1)/2:(N-1)/2)*x_o(end),svang);
Beam_syn_plot = abs(weights_o'*steervec((-(N-1)/2:(N-1)/2)*x_o(end),azplot).*antpat_plot);

plot(azplot,mag2db(Beam_d_plot),'-',azplot,mag2db(Beam_syn_plot),'--');
legend('Desired','Synthesized')
title(sprintf('Frequency band %d with spacing of %5.2f wavelength',n,x_o(end)));
xlabel('Angle (deg)')
ylabel('Array Pattern')
snapnow;

Finally, the following figure shows the resulting weights from the optimization.

% plot the results
plot(1:N,wmag);
xlabel('Antenna element number');
ylabel('Normalized weight');
title('Final antenna weights after optimization');

Summary

This example shows how array synthesis techniques can be applied to help design a phased array lidar to achieve a desired beam pattern.