Modeling Phased Array Systems with MATLAB

Hello, everyone. Thank you for attending Modeling Phased Array Systems with MATLAB. My name is Sam Lehman, and I'm an application engineer at MathWorks supporting our aerospace and defense customers with signal processing, communications, and radar-related workflows.

Prior to working at MathWorks, I worked as a software engineer in the aerospace and defense industry doing signal intelligence contracting. Before that, I studied physics and electrical engineering at the Georgia Institute of Technology. Today, I'll be covering an introduction to phased array system modeling in MATLAB.

Phased array systems are broadly used in many different applications, including multifunction radars where different beams can be used for different tasks, massive MIMO arrays and wireless communications, especially looking forward at systems like 5G and 6G, satellite communications to steer the beam with an array as opposed to a gimbal, and even in a variety of acoustic applications.

Designing phased array systems can present a variety of challenges. These include how do I design my subarrays to generate the beams I need and reduce the complexity of the system. If there's mutual coupling between elements, how can I incorporate that into my model?

After I receive my signal, how do I extract the information that I want? This can include information like direction of arrival detection or information contained in my received signal. How can I mitigate unwanted interference and improve the quality of my received signal? I want to take advantage of my array geometry to do this.

In large arrays, there's often some elements that have failed or, due to manufacturing tolerances, the array parameters aren't quite ideal or what I expect. How can I calibrate this array to work effectively in the presence of such impairments? And finally, how can I design waveforms to be able to detect targets at the same time as sending signals symbols and signals to communicate with other users?

Today, we'd like to present the Phased Array System Toolbox and its capabilities to address these challenges. There will be three broad sections of this talk that will include array design and analysis, beamforming and array signal processing, and waveform design and signal synthesis. Each of these have some examples that we'll go through and we'll discuss further. Let's get started with array design and analysis.

We can generate the array pattern by multiplying the array factor and the element radiation pattern. Array factor is a function of the geometry of the array, so it's important to be able to model different geometries and to manifest different factors. Element pattern is due to the design of the antenna and its radiation pattern. We'll see how you can incorporate this into your analysis.

I mentioned the different geometries there are within our tool. There's a few basic geometries you can get started with, a like a linear array or either these two planar arrays. You can also define a custom three-dimensional geometry to model a conformal array or completely custom array as you wish.

There's also a number of mathematical models of antenna patterns that have parameters to help you define your antenna-- each of your elements. Some of these even support polarization, but you can take this to a higher level of fidelity if you want to within our tools. Higher-fidelity radiation patterns can be generated with full electromagnetic wave solvers.

One of these includes the Antenna Toolbox. These are some antenna models that we support to generate full patterns using a full-wave electromagnetic solver. You can also import radiation patterns from other tools.

Some of these antenna models even incorporate polarization, especially if you're working with antennas that have different polarizations like this cross-dipole here. You have the option of working with the magnitude and phase of different polarizations to bring your element patterns.

So, now let's get started with doing our antenna-- or our array design. First thing I want to talk about is massive MIMO systems. For each antenna, you have a dedicated RF chain. The RF chain is what takes all of the analog signal received by your frontend and translates it to a digital signal.

The complexity of these systems can be huge. How can we alleviate some of this complexity while keeping performance at the same level, or at least they're-- at least come up with an acceptable compromise between complexity and performance? Well, one way is, instead of having an RF chain for each individual element, we can start-- we can group our elements together and have an RF chain per group.

There's a price you pay, but hopefully with analog phase shift, by applying an analog phase shift to the antenna and digital waste to the subarrays, you can get performance similar to your massive MIMO system.

There's a couple of different approaches you can use to model subarrays in MATLAB. The first is to replicate small apertures in different orientations. You see here that we have seven hexagonal arrays that have been arranged on the surface of a sphere. The other option is to start with a larger array aperture and partition it into different sections to design and model subarrays. You can see over here on the right, we have a uniform linear array that's been partitioned into several subarrays.

OK. Let's jump into the tool and see how we can use subarrays to our advantage to reduce the complexity of our system while hopefully maintaining adequate performance to meet our requirements.

Let's get started modeling a phased array using the Sensor Array Analyzer application in MATLAB. Our objective is going to be to design an 8-by-8 uniform rectangular array that operates at a center frequency of 10 gigahertz that we can steer to 10 degrees in azimuth.

Once we achieve that goal, we're then going to try to divide this MIMO array into four different subarrays that are 4x4 each, and then try to achieve similar performance to the previous array we designed while also reducing the complexity of the system by dividing our array into subarrays.

Let's get started. The first thing we'll do is we'll navigate to the Apps tab in my MATLAB toolbar. Once I do that, I'll open this Apps dropdown and navigate down to the Signal Processing and Communications section and open up the Sensor Array Analyzer application.

Once the Sensor Array Analyzer application is open, I can get started designing my array. You'll notice that as we design our array and work through this application, we move from left to right across this toolbar along the top.

The first thing that we're going to do is specify our array geometry. In this case, I mentioned that we're going to design a uniform rectangular array. The next thing we'll do is define what kind of element we have composing this array. You'll notice there's a broad variety of antennas, polarized antennas, microphones, and sonar transducers to choose from, as well as a variety of custom options for each of these element types. Right now, we're just going to stick with the isotropic antenna.

Once I've defined my array geometry and my elements that I want to use, I'm going to start defining some of my array parameters. I can do that using this panel over here on the left. The first thing that I mentioned was that I want to design an 8-by-8 uniform rectangular array, and I can specify that in my array size over here.

The second parameter I need to specify is the signal frequency that I'm hoping to receive. In this case, you'll remember, it was 10 gigahertz.

Now, I've updated my signal frequency for my array, and that means that my element spacing of half a meter is no longer half-wavelength spacing for this array. I could do the myself, but in this case, I'll just set the sensor array analyzer application handle it for me, and I can update these units to be units of wavelength. So now I'm separating each element by half a wavelength.

There's a few other properties I can configure, like the type of lattice, the array normal, and whether I want to specify a built-in or custom taper for the elements in my array.

I'll also select the Back Baffled box. This just means that my pattern will only be generated in one direction instead of symmetrically in both directions from both faces of the array, and then I'll be able to see which direction is forward and which direction is backwards, and it will also save me some computation time.

I'll go ahead and click Apply, and now all of these settings and my array parameters will be applied to this array. Let's generate a 3D pattern and see what the pattern for this array looks like.

Now that we can see the pattern, I can rotate around and I'll see that it is symmetric in the azimuth and elevation directions because of the symmetry of my array.

So, now I've got my array designed and configured here, and now I'm going to start steering it to 10 degrees in the azimuth direction. To do that, I'm going to turn this 3D pattern off to save us a little computation time, and instead, I'm just going to generate a 2D azimuth pattern.

Once I've generated this 2D azimuth pattern, I'll update the coordinate system to be rectangular just so I can see what the activity at a variety of different angles are. I can now see my activity as a function of angle and I can see that my array is currently steered in the 0 degrees azimuth direction. How can I update this to steer in the 10 degrees in azimuth direction?

Well, I'll come up here to the Steering tab in the toolbar along the top of the application and I'll just change the azimuth angle to 10 degrees. You'll notice, I can also specify phase shift quantization bits if I want to add in a little bit of-- more realism to my array design.

So I'll go ahead and apply that steering direction and azimuth, and now we can see that my array has been steered to 10 degrees in azimuth. So I'll zoom in a little bit here. And we can see that I have steered to 10 degrees in azimuth. And we can see my side lobe level is about 12.8 dB below the level of my main lobe.

So now we've achieved everything we wanted to achieve with our initial MIMO array. Let's see how we can go about partitioning this array into four separate subarrays and then see if we can achieve the same performance with those subarrays.

To get started partitioning this array, I'm going to come back to the Analyzer tab and I'll just specify that I'd like to partition my array using this button up here.

This is going to start repartitioning my array by using-- or into two separate arrays, but I can rotate this a little bit, and now I can specify for my third subarray that I would like these 16 elements in the bottom-left corner to consist-- or to comprise my third subarray. And I can add a fourth subarray, and I can specify that I would like these 16 elements to comprise my fourth subarray.

So now we have the four subarrays that are 4x4 each that we specified we wanted to divide this array into. Let's start evaluating the performance. So if I navigate back to my antenna pattern, I see that I have remarkably similar, if not almost the same or just about the same, performance for this array now that it's been divided up into four subarrays. My side lobe level is 12.8 dB below the level of the main lobe, and I've steered in the direction of 0 degrees in azimuth just fine.

Let's now go up here to steering and try to update our steering angle to 10 degrees in azimuth as we did before. Ah, so now I've started running into issues. You remember that I mentioned before that when we do this array steering, we're actually steering the four subarrays as opposed to each of the individual elements.

As a result of this, we can see that we've produced large grating lobes, and now our side lobe level is only 3.46 dB below the level of our main lobe. This isn't going to work very well for our application. We need to improve this design somehow.

Well, we're not just going to steer each of the subarrays when we divide-- when we do the hybrid steering or hybrid beamforming here. We'll also want to steer each of the elements in an analog manner.

To do that, I'll just come up to the Subarray Steering panel here in the Steering tab of the toolbar. I can specify what steering method I would like-- in this case, I'll choose Phase. And, because steering in phase depends upon my operating frequency, I'll specify 10 gigahertz for this as well.

The final thing that I have to do to steer my array effectively and steer my subarrays effectively is just specify the azimuth angle that I wish to steer my subarrays to. I specified 10 there just as I did in the azimuth angle for my array-steering, and now we can see, we're doing a much better job steering our array.

The side lobe level is now 10.46 dB below the level of the main lobe. So we don't have those grating lobes affecting the performance of our system as we did before. The other thing that you'll notice you can specify is the phase shift quantization, the number of bits you can use to specify the steering.

In this case, you'll notice we're specifying we have three bits right now, but what if we improve the quality of our system or the quality of our array hardware and we specify that we can use up to seven phase shift quantization bits?

Now you'll notice that my side lobe level has decreased to 12.54 dB below the level of the main lobe, which is very, very close to our initial performance in the MIMO array of 12.8 dB below the main lobe. I know that's a little bit worse, but it seems like we've done a pretty good job meeting the performance of our array-- of our MIMO array with our array that's been partitioned into subarrays, and we've significantly reduced the complexity of our system.

So I'm really happy with this design we've come up with. Now I want to go about starting to use in some fuller workflows. How can I go about doing that?

Well, I'll come back to the Analyzer tab up here in the toolbar, and I can go ahead and export my array, I have a few options for where I can-- for how I can export it, including creating a MATLAB object, saving it to a MAT file for later use so I can import it into other applications or generating a report.

Right now, I'm actually going to generate a MATLAB script, and we'll be able to see all the programmatic commands that would be used to do this kind of analysis. This is the MATLAB code that's been generated by the Sensor Array Analyzer application.

You'll notice, we specify that we have a uniform rectangular array in the element spacing, as well as calculating the array taper, specifying the antenna elements, and specifying how we've partitioned the array, and how we've steered it.

The script will also create all the figures that we saw in the application as well. So this is a great way to extend your analysis programmatically and include this array in fuller workflows as we'll see later. OK. Let's now jump back into the slides and we can take a look at how we can extend this.

The next important effect that we discussed that we should consider is mutual coupling between elements. To think about this, we'll think about the ways an array pattern can be modeled. The first way is to consider modeling each element as an isolated element. The array pattern generated using this method won't consider the effects that nearby elements have on each other's patterns. Alternatively, I can model the array by using an embedded element pattern. What do we mean in this case?

In this case, I'll model an 11-by-11 array and use a full field analysis to find the pattern of the element in the center, or maybe an element on the side, or any other element that I want to. And I'll use that embedded element pattern in my analysis. When I do that, I'm bringing in the effect of mutual coupling through the element radiation pattern.

Let's look at the differences between these methods compared to the ground truth, a full field analysis of my entire array. The yellow pattern you can see here in this plot is the ground truth. It's the pattern is calculated by a full-wave solver for the whole array, not just one element.

The blue pattern is the array pattern when using the isolated element pattern as the pattern for each element. This doesn't consider mutual coupling. We can see wide azimuth angles. This doesn't match the full-wave analysis of the entire array very well.

Alternatively, the red pattern uses the embedded element radiation pattern instead of the isolated pattern and creates a pattern that is far better at approximating the full-wave analysis of the entire array. So now we've seen that finite array analysis is much closer to the full-wave solver solution than isolated element pattern analysis, but it can be really expensive, so how can we go about speeding this up?

We can use infinite array analysis with periodic boundary conditions to estimate element patterns. In this case, let's consider the pattern of a 21-by-21-element array and compare the finite array analysis that we just did with infinite array analysis and with the ground truth, a full-wave solution for the entire array.

So again here, the yellow pattern is the full-wave solution and will be considered our ground truth. The red pattern that matches it pretty well is the finite array analysis like we just did. The blue pattern is the infinite array analysis. And up to about plus/minus 40 degrees in azimuth and elevation-- in this plot, you can see here, it's just elevation, there is good consistency between each of those three metrics.

So, we can see that we can save a lot of time for a narrow range of azimuth and elevation angles by using infinite array analysis, which is super, super helpful.

Now I want to move on to the next consideration that we want to make in our array-- our array modeling. In this case, we want to be able to perturb the parameters of our array model. This will account for manufacturing impairments and failed elements that we may have to deal with. Being able to perturb the array and see the effect on the array performance is really important.

Let's jump into a demo that will demonstrate how we can use MATLAB to model the effects of perturbations on our array and then to calibrate our array so that we can still perform in the presence of different kinds of impairments.

OK. So let's jump into the tool. The first thing we're going to do is create an array, much like we did before, this time, just programmatically. You'll recognize the same commands that we generated code for from the Sensor Array Analyzer application.

I'll go ahead and create my array-- in this case, a 4x4-element array, and we'll be able to visualize it here in my MATLAB live script. We'll see this looks familiar. It looks very similar to what we created initially in the sensor array analyzer application.

Let's now go ahead and perturb the array. What I mean by perturbing the array is we are going to offset the taper magnitude a little bit using a normally distributed random variable, offset the taper phase a little bit using a normally distributed random variable, and then also perturb the element position, so our array is going to look a little bit wobbly now after we've added these real-world impairments to our array.

So I'll go ahead and add the impairments using the Perturbations function here. It's super easy to do. All you need to do is specify your array as your input and specify exactly how you want the perturbations to be applied. In this case, a normally distributed random variable with a mean of 0 and a standard deviation of 0.01.

OK. Let's visualize what these perturbations look like in our new array. OK. These first two plots are the array magnitude, the array taper magnitude, and the array taper phase and how they've been offset from their design.

You'll notice, we designed our magnitude to be one for each of the elements in the array. Here, you can see there's 16 elements laid out in a line. These just correspond to the element number in our rectangular array.

You can imagine just taking them and having the first four elements on top, the next four elements below, and so on. We've just done this for ease of visualizing the offset and the taper magnitude.

The actual implemented taper magnitude is represented by these red X's. These are our perturbed array, the perturbations that we've added to the array using that Perturbations function. You can see that our phase was initially intended to be 0 as well, and we've now got offsets from what our intended phase is.

Finally, let's take a look at our array element positions. Again, the blue circles are going to be our intended or designed positions and the red X's are the offsets that we've added using the Perturbations function. Looks like we've been offset by a pretty significant amount, so we're definitely going to have to make some accommodations to fix these impairments and do some calibration for this array.

Here's a little bit clearer image that you can see. Looks just like the array again that we had in the Sensor Array Analyzer application, but now, all the elements have wobbled back and forth and are a little bit offset from where their designed position should have been.

So now let's take a look at the effect of array perturbation. Let's compare the beam pattern between an ideal array and the perturbed array. We're going to use Linearly-Constrained Minimum Variance beamforming, the LCMV Weights function, to generate a pattern for our array.

We have two signals that we want to remove in the directions of minus 10 and 60 degrees in azimuth, and we have a signal of interest where we want a main lobe coming incident upon our array from 25 degrees in azimuth. Let's take a look here and see if we effectively achieve that pattern and can receive our signal of interest and remove our interfering signals from our pattern here.

So in fact, because our array taper and our array element-- or our element positions in our array are different than what we expected, and there are some impairments in the design-- or rather, the implementation of the array versus what our expected design of the array was.

We've now got a pattern that's very unexpected, and instead of pointing a beam in the direction of the signal of interest, we are now nulling the signal of interest instead. So, how can we go about remedying this and pointing a beam in the direction of the signal of interest? Well, we'll generate some pilot calibration signals to use in MATLAB.

You'll notice here, we have four signals defined for our pilot angle calibrations. The four azimuth and elevation pairs are minus 60, minus 10; minus 5, 0; 5, 0; and 40, 30, all in degrees. We can specify those using this matrix here. The next thing we'll do is generate calibration signals using the Sensor Signal function. This just generates signals for our perturbed array and the perturbed-- with the perturbed positions and the perturbed taper that we can use for calibrations.

Next, we'll just use the pilotcalib function with those calibration signals that we just generated from each of the elements in our array to estimate our actual array positions-- or our element positions and our actual array taper. We can then generate some corrected weights using our linearly-constrained minimum variance beamformer and apply those and see if we now have a lobe in the direction of our signal of interest and nulls in the direction of our interfering signals. Let's take a look and see what we get.

Awesome. So we've done much better this time. We can see that now we are knowing those two interfering signals that we don't want in the minus 10 degrees and 60-degree directions, and we have a main lobe in the 25-degree direction where we're hoping to receive a signal of interest.

Excellent. So now we've calibrated our array, we've accounted for some impairments, and let's jump back into the presentation and see where we go from here in our phased array modeling.

OK. We've completed our array design and analysis, and next, we're going to use that array to perform beamforming an array signal processing. There's a few conventional techniques that we can use to synthesize array beam patterns.

We can use nulling to suppress unwanted interference, windowing for reducing and controlling the side lobe levels and our beam width, and thinning to control side lobe levels and to avoid wasting power delivered to each antenna element. There are examples of each of these conventional techniques in the toolbox.

Next, I wanted to jump into a demonstration of using optimization for pattern synthesis. In this case, we're going to look at minimum variance optimization, and we're going to hope to null interference from four separate directions, control our side lobe levels, and steer our main beam by using optimization to determine our array weights.

OK. Let's take a look at how we can perform pattern synthesis with minimum variance optimization in MATLAB. First thing we're going to do is define our array again. Again, this code can be generated from the Sensor Array Analyzer application if you want to. Alternatively, you can define a programmatically as we have here.

You'll notice in this case, we're just setting up a uniform linear array with 55 elements. Let's run this code and see what our array looks like. Great. So now we have our array defined and we can go about defining our desired pattern. There's three key components we'll need. The first is the direction of our main lobe beam.

Secondly, we're going to define four directions where we want to null interfering signals that we don't want to affect our signal quality. Finally, we'll define a side lobe level mask after that. You'll notice that we're defining side lobe levels for from minus 55 DB to minus 18 dB for the side lobes that are left and right of our main lobe direction.

Let's get a better idea of what this looks like. I'll just go ahead and plot it and it'll be a little bit easier to see. OK. So here is our mask that we wish to use to define our desired beam pattern.

Again, this is the direction where we want a main lobe that is above the level of our mask there, these are the side lobe levels that we're hoping to define to the left and right of that main lobe, and there's four nulls that we wish to include here as well in the minus 35, minus 45, negative 40-- or, sorry, positive 40, and 60-degree direction.

So that'll be something like-- whoops, what'd I say? Minus 35, minus 45. So minus 45, minus 35, positive 40, and positive 60-degree direction. So we'll have four nulls that are present in each of those directions in our final beam pattern.

OK. So now let's go ahead and compute our optimized weights. This is super easy to do in MATLAB. All we need is the geometry of our array and to use the minvarweights function. This performs all of the optimization for us.

Of course, you can look at the algorithm in the documentation if you want to, but all you really need to specify are your array element positions, the angles in which you want your main beam to point, the null angles where you want to null interfering signals, and then your side lobe levels, at which angles you want those side lobe levels. And so that's just what's specified here.

So we'll go ahead and compute those optimized weights it shouldn't take too, too long, hopefully. And now we can go ahead and visualize the mask plotted on top of the generated array pattern. So now we can see our desired mask. Just as we specified before, we have those nice side lobe levels that we specified, our main lobe in the 25-degree direction, and the side lobe levels going down to the right, as well as nulls in the direction of those four angles that we didn't want.

I'll pop this out so we can see a little bit clearer exactly what's going on here. So again, you can see the orange line so-- four deep nulls in the actual generated beam pattern in the four directions of our interfering signals. And then you'll notice the side lobe levels are below our mask level for the entire pattern outside of the main lobe as well. And then we have a nice high main lobe in the direction of our signal of interest.

So now you saw in the animation in the slide previously that we wanted to maybe steer this in a whole bunch of different directions. We can just update this script to now generate a pattern with an updated main lobe direction, and then we can run all those together to make this dynamic and to make this beam steering for our array dynamic.

Excellent. So now that we have learned how to use optimization to generate a beam pattern, let's go and see how we can extend this using some more advanced techniques.

Another advanced technique we can use to extend optimization is artificial intelligence. Let's take a look at how we can do this. So in this case, we're going to look at an example where we have a circular planar array aperture. Our three objectives are going to be to maximize the activity of our aperture in the main lobe direction of 0 degrees azimuth and 0 degrees elevation. We want to suppress all interferences by about 30 dB, and we want to keep our side lobe levels about 17 dB below our main lobe level.

So, first thing we're going to do is derive our beam pattern using optimization, as we just did in the last example. We can see here that the activity we achieve is 22.8 dBi, and we've suppressed our interference to right about 30 dB-- by right about 30 dB. We also have 0% of our side lobes over our required minus 17 dB level. So we've done a pretty good job designing our beam pattern here to meet each of our three requirements using optimization.

So what if we take this and we use this to inform a deep learning algorithm? The way we're going to do this is we're going to use optimization to synthesize our beam patterns and output weights for that beam pattern. We're then going to take that beam pattern image and input that to a deep learning algorithm to be able to train it to spit out the weights that we'll need to form that beam pattern.

When we do this and then we generate beam patterns using deep learning, we see that our activity in the main lobe direction is about 22 dBi again. Our interference suppression isn't quite at the same level. It's about 20 dB-- it'll be suppressed by about 20 dB, but our side lobe requirement is met again.

Now we can improve this a little bit by maybe training a little bit longer or increasing the quality of our training data or the amount of our training data. This was run just on a laptop and is in an example that I would encourage you to check out in the MATLAB documentation.

The real kicker here is the synthesis time for each of these two beam patterns. For the optimization technique here to synthesize the beam pattern, it takes about 22 seconds on a laptop to synthesize.

Now that may seem good enough in some cases, but in other cases where you have rapidly-changing interference or you want to be able to point your beam in maybe different directions rather quickly, 22 seconds or almost half a minute is really not going to do the job very well. That's where the deep learning comes in.

To synthesize a similar pattern with similar performance, it only took seven seconds, or about a third of the time. This is a huge improvement over the optimization and will only grow as our array gets bigger and as we have hardware that can execute deep learning tasks faster.

There's other kinds of array signal processing that we might be interested in performing. This can include detection, and we have built-in functions for things like CFAR, or Constant False Alarm Rate detection, match filtering, and stretch processing. You can form range response maps using FFT and match filtering, Doppler response maps, range angle responses, range Doppler responses, and even do synthetic aperture radar image formation.

Another benefit of arrays is that you can estimate the direction of arrival of incoming signals. If resolution is not a concern and you just want to get an idea of the direction of arrival, you can use the beamscan method.

There are many cases, however, where a high resolution algorithm is desirable to get an accurate, high-resolution direction of arrival estimate, and in those cases, you can use techniques like minimum variance distortionless response and multiple signal classification direction of arrival estimation.

Depending on the geometry of the array and the bandwidth of the signal, you can use different methods for direction of arrival estimation. Here are some built-in algorithms for a variety of array geometries and signal bandwidths. You see, there's a whole bunch of different options out of the box, and this is some information to help you choose what's right for your workflow and for your array and signal of interest.

One of the big benefits of arrays is that they enable you to perform signal processing not only in time, but also in space. Performing space-time adaptive processing will enable the mitigation of clutter and interference at the same time. In the case we can see here, we have a scene with clutter and an interferer that is incident upon the radar from a specific angle. There is also a target present in the scene that is moving relative to the clutter.

So you can see here, our target-- or our radar is moving along the direction or the axis of the uniform linear array we're moving. The clutter that is in front of us is moving towards us, and that's why we get the diagonal line here, and the clutter that is behind us is moving away from us, hence the diagonal line for the clutter.

Our target of interest is going to be located right here. You can see that it's got a slightly offset speed from the clutter that we see in our signal. There's also a jammer that's going to be incident-- a jammer that is incident upon our radar from a specific azimuth angle.

We're going to hope to use space-time adaptive processing to mitigate the interference here-- the interference in the clutter. To deal with clutter, we can use a method like displaced phase center antenna, which means that the distance the radars moved is equivalent to the distance between two adjacent elements in the array between pulses. The data from each of these for many of these antennas should be the same in subsequent pulses, so the clutter can be removed by comparing subsequent pulses.

This method doesn't work for getting rid of interference. In that case, an adaptive method is needed, like sample matrix inversion. It can be expensive and time-consuming, so adaptive PCA might be preferable. All these methods are available for use within the tools. Let's take a look at how we can use these to mitigate the effect of clutter in a jammer.

So here in this plot, we can see that we have our target is expected to be at right around 1,800 meters in range. See, we can't actually get a good detection and range estimate for our target because of the clutter and the jammer that are affecting our radar.

So here, you can see what the Doppler angle map looks like. So again, you can see the clutter along this diagonal and the jammer along this line coming in from about 65 degrees in azimuth. Again, our target is right here. So offset slightly in speed from our clutter, and also coming in incident from a slightly different angle than our jammer.

Now after we use space-time adaptive processing-- adaptive space-time-- adaptive PCA, rather, processing to remove the effect of the clutter in the jammer, we see we get a much better estimate for the range of our target and we actually get a good detection here. Again, at right about 1,800 kilometers away.

And we see that when we pull up the Doppler angle map again, we now have a deep null along the diagonal where our clutter is located and in the direction of our jammer, or interfere.

So let's take this one step further. We've just done a simulation that allows us to remove the effects of clutter and jamming or other interference from our radar system. You can now go ahead and start deploying these kinds of algorithms using HDL Coder which is a tool you can use to generate HDL code for implementation on an FPGA from your model and simulation code.

Here are some built-in algorithms and examples that you can use to get started with generating code. This is a great way to compare the performance between your algorithm deployed on hardware and your algorithm and simulation to verify that they both behave the same way.

OK. So we just saw how we can do some array design and analysis initially, and then use that array for beamforming and array signal processing. Now let's take a look at how we can use waveform design in signal synthesis to help us operate in the presence of radar systems and communication systems. This can be in the form of cooperative operation between radar communication systems and can also be non-cooperative coexistence of radar and communication systems.

The Phased Array System Toolbox enables you to model many different types of waveforms, including rectangular, linear FM, stepped FM, Barker code, and nonlinear FM modulations. In the nonlinear FM case, the nonlinearity can be defined and configured by user input. Additional waveforms include FMCW and custom waveforms. This can also be combined with other MATLAB tools to model communications waveforms and wireless standards.

Now, how much you decide which modulation to use for your application? In this case, examining radar specifically. One tool that people might use is the ambiguity function of the waveforms. There's a built-in function within the tool that enables you to visualize the ambiguity functions of your waveform very easily. Now how is this useful in practice?

Right now, the radar spectrum and communication spectrum are colliding. This is not in two forms. One is-- or this is in two forms, rather. One is non-cooperative, the other is cooperative. Take a 5G station near an airport. There could be interference issues and a need to adapt to each other's spectrums.

From the same spectrum and aperture, people also might want to do communications and radar. How do we design for that? How do we design waveforms to match the performance of the radar and the communication system that we want to use? This is the cooperative case.

So first, I want to jump into the non-cooperative case here. So here, you can see that we have a wideband radar signal-- it's that red dashed line that's our full radar waveform spectrum. And we also have a communication signal with two peaks present at about minus 20mhz and 20mhz in our baseband spectrum.

Now if we evaluate the performance of our radar response without the communication signal, we can see that we can resolve six independent targets in our range Doppler map or range velocity map here. And you can see that you can tell the difference between them relatively clearly, but if we take a look at the radar response in the presence of our communication signal, we can't resolve those targets very well.

It looks like there's a couple that maybe we could see a little bit, but nothing that's going to be very effective for the use of our radar system. So how are we going to design our radar system to operate in the presence of this communication signal?

Well, one option is to generate a notched waveform for our radar that avoids the bands where our communication signal is operating. So you can see here, this yellow signal is the notched radar waveform with notches where the communication signal is present, so we can avoid the communication signal when we extract our received pulse.

So again, let's take a look at our radar response without the communication signal, and now we'll see the radar response with the communication signal. The performance of our radar system without the communication signal present might be degraded just a little bit because of the modified waveform, the notched waveform that we've now implemented.

However, the radar response with the communication signal present is far superior to what it was, and we can see, we can now resolve our six individual targets again. So, we've done a good job mitigating the effect of our communication signal in this non-cooperative environment.

On the other hand, you may want a radar and communication system to be able to work cooperatively. In this case, we have a radar system in which our tracking system tells us we want to be able to track targets in these three directions. Our goal will be to design a set of diverse waveforms that gives us something approximating our desired beam pattern.

For our comm system, we assume we have four users at four different locations, and the goal of our system is to transmit a communication of 30 symbols to each of the downlink users. Unlike traditional phased array radar that transmits scaled versions of the same waveform, this cooperative radar will transmit several different waveforms that combine to form a transmit beam pattern.

By adjusting the transmitted waveforms, a MIMO radar can dynamically adjust its transmit beam pattern. We'll use optimization to determine the ideal waveforms for a dual-function system.

In the plot you see here, the red is the ideal beam pattern defined in the beginning of our optimization that we'll use to find the ideal set of diverse waveforms to achieve our task. Hopefully the set of waveforms designed will produce something close to this. When we synthesize the set of waveforms to create this beam pattern, we get the yellow beam pattern. This is the result of our first optimization. And it's a good match for our ideal case, that red beam pattern you saw.

Finally, when we add in that we have to constrain our waveforms to something that will be useful in transmitting our communication signal, we get the purple waveform out-- or purple beam pattern out, rather. This is our ideal radar and communication system waveform to perform both of our desired tasks.

Now, how do we know that this is where we want to land for designing our radar and communications waveforms to work together cooperatively? Our questions are really going to be, how can we detect three targets in this scenario, and how can we evaluate the performance of our comms system?

Well, for the comms system, we want to evaluate the bit error rate of the transmission that we send. So here, we can see that we have, in fact, detected three targets at three different angles. You can see them they're pretty well, and those are the angles that we specified we wanted to look in.

How can we evaluate comms availability? When we've minimized the beam pattern mismatch with the ideal radar beam pattern. We'll see in these plots over here to the right-- so if we've minimized our beam pattern mismatch, we have a really, really high symbol error rate for our comms waveform here, and that's not really going to be acceptable for the performance of the system.

Alternatively, when we minimize the symbol error rates over here on the right side of this plot, you'll see we have a massive beam pattern mismatch with what our ideally-- with what our ideal radar beam patterns would be.