Computing intercept for an accelerated object in 2D

Question

I'm making a C program in which I simulate a Patriot missile system. In this simulation my Patriot missile has to catch an incoming enemy target missile. The information about the Patriot missile and the enemy target are stored in a structure like this:

typedef struct _stat {
float32_t x;
float32_t y;
float32_t v;        // speed magnitude
float32_t v_theta;  // speed angle in radians
float32_t a;        // acceleration magnitude
float32_t a_theta;  // acceleration angle in radians
} stat;

And I'm storing the informations in two globals variables like those:

stat t_stat;  // target stats
stat p_stat;  // patriot stats

Now, to simplify the problem the target is moving thanks to an initial speed and is affected only by gravity, so we can consider:

t_stat.x = TARGET_X0;
t_stat.y = TARGET_Y0;
t_stat.v = TARGET_V0;
t_stat.v_theta = TARGET_V_THETA0;
t_stat.a = G;   // gravity acceleration
t_stat.a_theta = -(PI / 2);

Again, to simplify I'm also considering to compute the collision point when the Patriot has reached its top speed, so its own acceleration is only used to balance the gravity acceleration. In particular we have:

p_stat.x = PATRIOT_X0;
p_stat.y = PATRIOT_Y0;
p_stat.v = 1701,45;     // Mach 5 speed in m/s
p_stat.v_theta = ????   // that's what I need to find
p_stat.a = G;           // gravity acceleration
p_stat.a_theta = PI / 2;

In this way we can consider the Patriot as moving at constant speed because the sum of the accelerations by which is affected is equal to 0.

float32_t patr_ax = p_stat.a * cos(p_stat.a_theta);       // = 0
float32_t patr_ay = p_stat.a * sin(p_stat.a_theta) - G;   // = 0

Now, here comes the problem. I want to write a function which computes the right p_stat.v_theta in order to hit the target (if a collision is possible).

For example the function that I need could have a prototype like this:

uint8_t computeIntercept(stat t, stat p, float32_t *theta);

And it can be used in this way:

if(computeIntercept(t_stat, p_stat, &p_stat.v_theta)) {
    printf("Target Hit with an angle of %.2f\n", p_stat.v_theta);
} else {
    printf("Target Missed!\n");
}

For making it even more clear, here is the image which I want

Answer 1

Your target projectile is moving with constant acceleration hence the velocity can be described as

Now integrating this equation gives us the equation of the position.

Now by knowing the initial position and we can determine this constant vector is the initial position

Now the position of the target projectile is finally

This are two equations (for x and y coordinate). The equation for y is quadratic and the equation for x is linear since the acceleration (gravitational) is in the vertical direction.

You have

In general you should do something like this :

You can use https://en.wikipedia.org/wiki/Newton%27s_method in order to solve the last equation for theta that you get.

Answer 2

In order to have a collision you need the coordinates of both objects to be identical at the same instant of time.

You could decompose the problem into two simpler ones, considering each axis, x and y, separately:

You need to calculate the equations of motion for the both objects, once for their horizontal components and once for their vertical components.

Check whether the solutions of both objects contain equal coordinates and if this happens at the same instant of time.

Target coordinates: T (x_t, y_t)

Patriot coordinates: P (x_p, y_p)

You could solve this numerically by varying the time, t, and observing whether: T == P.

In your case, one of the equations should contain a parameter accounting for the angle theta.

Answer 3

Simulate the event and find the time the 2 objects are closest.

---

The missile can only fly so long after launch (negating it going into orbit), let that be tf.

Using struct _stat for each object, write a function that report the x,y for a given t and object.

Simulate, at reasonable intervals (1s?), 0.0 to tf, the square of the distance between the two objects.

From the time t of the closest approach, use it 2 neighbors t-dt and t+dt to do the simulation over again. Could use time from t-dt to t+dt with 10x smaller dt or other methods.

Repeat the above until the distance is close enough or dt is sufficiently small.

If this distance is sufficiently small, evaluate struct _stat for the needed data now that the time is determined.

Note: the details of the complexity of pt2 compute_position(struct _stat st, time t) only need consideration for the the initial dt estimate.