Building a Satellite-Based Missile Tracking Simulation

Lately I've been exploring defense stuff. This involves topics like:

• autonomous vehicles
• target tracking
• modeling stuff in the physical worldphysics and applied math
• mechanical/computer/electrical engineering
• (other interesting topics)

In this project, I'm exploring space-based missile warning and tracking using OPIR.

What is the concept?

This is a well-explored topic that started in 1960 with the launching of MIDAS, (as far as I can find) the earliest US space-based infrared missile-warning programs. Since then, defense companies and research laboratories have spent a lot of time and effort trying to improve these systems. The important outcome is that if someone tries to shoot a missile at you, you can use this technology to detect + track that missile, and maybe stop it before it hurts people.

For this to work, satellites observe Earth with infrared sensors, detect hot moving objects, and produce measurements that can be combined into an estimate of where a target is and where it is going.

My focus for now is entirely on sensor fusion, or "given a bunch of disparate and messy data from satellite sensors, how do I create a reliable missile detection signal?"

What entities are involved?

To map out the entities involved:

Satellites

I think most people know what these are.

Sensors

The instruments on the satellites. They provide the data from which we can create a signal.

Targets

The missiles. Fast-moving objects whose trajectory we want to estimate. They may follow relatively predictable motion or maneuver in ways that make prediction harder.

Measurements

Noisy observations generated when a satellite can see a target.

Tracker Software

The software that takes those measurements and maintains an estimate of the target's state.

What are we trying to do?

Basically we can split this project into two parts: The simulation and the tracker. The tracker is the actual product that accomplishes our ultimate goal of maintaining an accurate track, and the simulation is the testing framework we use to train and validate the functionality and correctness of the tracker. Each half is crucial.

Here are some important key terms first:

A state is just a description of a target. In a simple example, this could be position and velocity in one vector:

$$x = [p_x, p_y, p_z, v_x, v_y, v_z]$$

A motion model is an assumption about how that state changes over time. For example, the simplest possible model might assume that the target keeps moving at around a constant velocity. Something that makes this simplicity unlikely is stuff like atmospheric drag, gravity, or some other natural force. Another complicating factor is that people develop missiles that purposely use complicated and weird trajectories so as to evade missile tracking and interception, and thus make it more likely that they won't be stopped. Sneaky!!

Now that we've got the basic terms let's talk about each component.

Simulation

We start with our simulation, and in order to make a realistic simulation, we need reference data. Unfortunately the best simulation data would be from real missile/satellite occurrences, but pretty much all OPIR missile detection data is classified and not available to me, but we can build it from first principles using some published literature on the subject.

Our simulation must include the movement/orbit of the satellites, targets following physically plausible trajectories, how visible these targets are to the sensors of the satellites, and then from that, synthetic sensor measurements, and appropriate levels of noise. Getting this right is really hard, because each component of this simulation involves its own unique physical attributes and subproblems, and if any part of this system is inaccurate, that screws everything up.

I've been trying to find out-of-the-box simulation software, and the closest things I have found are open source simulation software frameworks like GMAT, Orekit, and Basilisk, along with some other algorithms in various papers. The limitation is that these are primarily spacecraft simulation tools, not complete missile-tracking simulators. They solve important pieces of our problem, but lack a lot of crucial components we need for our overall goal of tracking missiles (mostly related to target dynamics and the detection process).

Tracking

The end-to-end process of tracking is as follows:
1. target appears
2. satellites spot it with its sensors
3. those sensors produce noisy measurements
4. measurements are processed by tracking software
5. tracker estimates position and velocity
6. tracker predicts where the target is going

How is 4, 5 and 6 actually done? From what I've found, there are a few well-established classical methods in this space which include some combination or selection of the following:

Kalman filter = estimate one distribution of states

Given a motion model and noisy sensor data, it keeps updating its best estimate of where the target is, how fast it is moving, and how uncertain that estimate is.

IMM = estimate several kinds of motion simultaneously

Instead of assuming one motion model is correct, an IMM runs several in parallel like "moving normally," "turning left," or "turning right" and continuously changes how much it trusts each one.

Variable structure IMM = change motion models in real time

An IMM usually starts with a fixed menu of possible motion models. A variable-structure tracker can add, remove, or adjust those models as the target's behavior changes.

JPDA = decide which measurements belong to which object

If several targets and several sensor detections are close together, JPDA doesn’t immediately make one hard assignment. it weights the plausible measurement-to-target associations by probability..

Multiple hypotheses = delay committing when the data is ambiguous

Sometimes there are several reasonable explanations for the same sensor data. Instead of picking one immediately, a multiple-hypothesis tracker keeps several possibilities alive until later measurements make one clearly more likely.

Again, these techniques are often combined. Like a lot of them use kalman filters.

The general cycle of tracking is: the tracker starts with those noisy angular measurements and tries to reconstruct the target's hidden state.

Using the same simplified state as before:

$$x = \begin{bmatrix} p_x & p_y & p_z & v_x & v_y & v_z \end{bmatrix}^T$$

although the real model can also include physical parameters related to the target's motion.

We update this state with two steps: predict and correct.

First, predict where the target should move next:

$$\hat{x}_{k|k-1} = f(\hat{x}_{k-1|k-1})$$

Then, when a new sensor observation arrives, correct that prediction using the difference between what the tracker expected to observe and what the sensor actually observed.

Conceptually:

$$\text{new estimate} = \text{prediction} + \text{correction from measurement}$$

What I'm working on now

I have mostly finished the simulation process, and I have also mostly finished implementing and testing a lot of these algorithms. What I am trying to do now is see where AI/ML applications can be most useful. More on that soon!!