Calculate Projectile flight time based on Gravity

mathematical physicsphysicsprojectile motionvectors

Hey I want to calculate the flight time of a Projectile in 3D Space based on Bullet's speed, Velocity, Acceleration and Gravity or a custom downward force.

I already have a formula that calculates the time it takes a bullet to intercept another moving target depending on the bullet's position, the target's position, the bullet's speed, the target velocity, and the target acceleration which looks like this:

a = Acceleration
v_T = Target Velocity
p_T = Bullet Impact Position - Bullet Start Position
s = Bullet Speed

  t^4 * (a·a/4)
+ t^3 * (a·v_T)
+ t^2 * (a·p_T + v_T·v_T - s^2)
+ t   * (2.0 * v_T·p_T)
+       p_T·p_T
= 0

However, this would give me the time it takes for the Bullet to reach the Target, without the impact of Gravity or any downward force, assuming the Bullet travels in a straight path.

But I want to calculate the time it takes the bullet to reach the target using gravity which lets the Bullet travel in a curve (you shoot above the target to compensate the gravity).

Since my math skills are unfortunately not the best, I hope that someone can help me here. What would the formula look like to be able to calculate the Travel Time if the factors were the following:

Bullet's speed: 150 M/s
Gravity: 10 M/$\text{s}^2$
Bullet Start Position: Vector3D$\space$ (0,0,0)
Targets Position: Vector3D$\space$ (200,0,0)

Target acceleration and target velocity do not matter in this case.

Best Answer

The path traced by a bullet travelling under the influence of the force of gravity is called a parabola. This force acting on a projectile (or bullet) confine its trajectory to a 2D vertical plane, which is shown in the diagram. In general, a bullet fired with a given velocity can hit a given target while either rising (green trajectory) or plummeting (red trajectory). The travel times of the two instances to reach the same target are not equal. Besides, their launch angles are different too.

We denote the speed of the bullet, the angle of its projection, its travel time, and the force of gravity by $v$, $\theta$, $t$, and $g$ respectively. furthermore, the coordinates of the bullet's firing point $B$ and the target $T$ are taken as $\left(x_0, y_0, z_0\right)$ and $\left(x_1, y_1, z_1\right)$ respectively. With that, we can state, $$d=\sqrt{\left(x_1 - x_0\right)^2+\left(y_1 - y_0\right)^2}\quad\text{and}\quad h = z_1-z_0.\tag{1}$$

Using laws of motion under the influence of gravity, we can express $t$ and $h$ in terms of the unknown $\theta$ as shown below.

$$t=\dfrac{d}{v\cos\left(\theta\right)}\tag{2}$$ $$h = v\sin\left(\theta\right)t - \dfrac{1}{2}gt^2\tag{3}$$

Equation (2) shows that the bullet launched with the smaller angle needs shorter travel time to reach the target.

When we eliminate $\theta$ from (3) using (2), we get the following expression for $h$ in terms of $t$. $$h = vt\sqrt{1-\dfrac{d^2}{v^2t^2}} - \dfrac{1}{2}gt^2$$

This can be simplified and rearranged to obtain the following quartic equation in $t$. $$g^2t^4-4\left(v^2-hg\right)t^2+4\left(h^2+d^2\right)=0\tag{4}$$

The travel times $t_1$ and $t_2$ are the two positive real roots of (4). They can be written as, $$t_1=\sqrt{2}\sqrt{a+\sqrt{b}}\quad\text{and}\quad t_2=\sqrt{2}\sqrt{a-\sqrt{b}},$$ $$\text{where}\quad a=\dfrac{v^2}{g^2}-\dfrac{h}{g},\quad\text{and}\quad b=a^2-\dfrac{h^2+d^2}{g^2}.$$

The corresponding angles of firing are given by, $$\theta_1 =\cos^{-1}\left(\dfrac{d}{vt_1}\right)\quad\text{and}\quad \theta_2 =\cos^{-1}\left(\dfrac{d}{vt_2}\right).$$

Before attempting to determine the travel time, we need to make sure whether the bullet can reach its target. It reaches the target if and only if, $$h\le \dfrac{1}{2}\left(\dfrac{v^2}{g}-\dfrac{d^2g}{v^2}\right).$$

If both the firing point and the target are located on the same lavel, i.e. $h=0$, travelling time can be calculated using the following set of equations. $$t_1=\sqrt{2}\sqrt{a+\sqrt{b}}\quad\text{and}\quad t_2=\sqrt{2}\sqrt{a-\sqrt{b}},\quad\text{where}\quad a=\dfrac{v^2}{g^2},\quad\text{and}\quad b=a^2-\dfrac{d^2}{g^2}$$

For this special case, the following relationship between $\theta_1$ and $\theta_2$ holds. $$\theta_1+\theta_2 = 90^{o}$$

When the given values $d=200m$, $h=0m$, $v=150\dfrac{m}{s}$, and $g=10\dfrac{m}{s^2}$ are substituted in the above equations, we get, $$t_1 = 1.334654779\qquad\text{and}\qquad\theta_1 = 2.549844457^{o}\quad\text{and}$$ $$t_2 = 29.9702969\qquad\enspace\text{and}\qquad\theta_2 = 87.4501555^{o}.\quad\qquad$$

Related Solutions

[Math] Where to shoot to hit a moving target in 3D space

At time $0$ target is at position $\vec T_0$ and bullet is fired from the origin with speed $\vec s$. If $t$ is the collision time you have the equation $$ \vec s t = \vec T_0 + \vec v t. $$ Squaring both sides one gets $s^2t^2=T_0^2+v^2t^2+2(\vec T_0\cdot\vec v)t$, that is: $$(s^2-v^2)t^2-2(\vec T_0\cdot\vec v)t-T_0^2=0,$$ an equation which can be solved to obtain $t$. Once $t$ is known you can compute $ \vec s=\vec v +\vec T_0/t. $

Calculate the constant acceleration needed for the discrete time trajectory to intersect a given target point

A quick background refresher:

In continuous time, the velocity $v(t)$ and position $x(t)$ with a constant acceleration $a$ are given by $$\left\lbrace\begin{aligned} v(t) &= \int_{0}^{t} a \, d \tau = v_0 + a t \\ x(t) &= \int_{0}^{t} v(\tau) \, d \tau = x_0 + v_0 t + \frac{1}{2} a t^2 \end{aligned}\right.\tag{1}\label{NA1}$$

In discrete time, the velocity and position are given by difference equations. There are three most common definitions:

A. Position updated before velocity: $$\left\lbrace\begin{aligned} x_{i+1} &= x_{i} + v_{i} \\ v_{i+1} &= v_{i} + a \\ \end{aligned}\right. \implies x_N = x_0 + N v_0 + \frac{N (N - 1)}{2} a \tag{2a}\label{NA2a}$$

B. Velocity updated before position: $$\left\lbrace\begin{aligned} v_{i+1} &= v_{i} + a \\ x_{i+1} &= x_{i} + v_{i+1} \\ \end{aligned}\right. \implies x_N = x_0 + N v_0 + \frac{N(N+1)}{2} a \tag{2b}\label{NA2b}$$

C. Velocity updated before and after position: $$\left\lbrace\begin{aligned} v_{i+\frac{1}{2}} &= v_{i} + \frac{1}{2} a \\ x_{i+1} &= x_{i} + v_{i+\frac{1}{2}} \\ v_{i+1} &= v_{i+\frac{1}{2}} + \frac{1}{2} a \\ \end{aligned}\right. \implies x_N = x_0 + N v_0 + \frac{N^2}{2} a \tag{2c}\label{NA2c}$$

In this last case $\eqref{NA2c}$, velocity updates are essentially half a time step out of sync with the position updates, but the position function is most similar to the continuous time one, $\eqref{NA1}$.

(While the formulae above are shown in one dimension, you can use them in 2D or 3D just as well. The time steps ($i$ and $N$) are the same (shared) across all dimensions, but each dimension has their own acceleration $a$. The actual magnitude of the acceleration is then $\sqrt{a_x^2 + a_y^2}$ for 2D, and $\sqrt{a_x^2 + a_y^2 + a_z^2}$ for 3D.)

The problem at hand is to find the smallest $0 \le N \in \mathbb{N}$ and $a_x$ and $a_y$, when $x_0$, $y_0$, $v_{x0}$, $v_{y0}$ are known, but acceleration is limited, $a_x^2 + a_y^2 \le A_{max}^2$.

If we solve $\eqref{NA2a}$ for $a$ for both dimensions, we get $$\left\lbrace\begin{aligned} a_x &= \frac{2 (x_N - x_0 - N v_{x0})}{N (N - 1)} \\ a_y &= \frac{2 (y_N - y_0 - N v_{y0})}{N (N - 1)} \\ \end{aligned}\right . \tag{3a}\label{NA3a}$$ Solving $\eqref{NA2b}$ similarly yields $$\left\lbrace\begin{aligned} a_x &= \frac{2 (x_N - x_0 - N v_{x0})}{N (N + 1)} \\ a_y &= \frac{2 (y_N - y_0 - N v_{y0})}{N (N + 1)} \\ \end{aligned}\right . \tag{3b}\label{NA3b}$$ and $\eqref{NA2c}$ yields $$\left\lbrace\begin{aligned} a_x &= \frac{2 (x_N - x_0 - N v_{x0})}{N^2} \\ a_y &= \frac{2 (y_N - y_0 - N v_{y0})}{N^2} \\ \end{aligned}\right . \tag{3c}\label{NA3c}$$ To find out the approximate number of steps (which we need to round upwards to not exceed the specified acceleration $A_{max}$), we could try and solve $$a_x^2 + a_y^2 \le A_{max}^2 \tag{4}\label{NA4}$$ for $N \in \mathbb{R}$ (so the actual number of time steps needed would be rounded up, $\left\lceil N \right\rceil$).

Unfortunately, while there is an algebraic solution (it is a form of a fourth-degree function that does have algebraic solutions), it is too complicated to be useful.

Fortunately, we can use the bisection method (or binary search) to very efficiently find the smallest $N$, and therefore also the largest acceleration $(a_x , a_y)$ not exceeding $A_{max}$ in magnitude, that reaches the target coordinates in minimum number of time steps.

Note that in practice, square root and division operations take much more time than addition or multiplication. Because the bisection method/binary search will have to evaluate the same expression potentially dozens of times, it is a good idea to "optimize" $\eqref{NA4}$ first.

If we use $\Delta_x = x_N - x_0$ and $\Delta_y = y_N - y_0$, then $\eqref{NA4}$ optimizes to: $$(\Delta_x - N v_{x0})^2 + (\Delta_y - N v_{y0})^2 - N^2 (N-1)^2 \frac{A_{max}^2}{4} \le 0 \tag{5a}\label{NA5a}$$ $$(\Delta_x - N v_{x0})^2 + (\Delta_y - N v_{y0})^2 - N^2 (N+1)^2 \frac{A_{max}^2}{4} \le 0 \tag{5b}\label{NA5b}$$ $$(\Delta_x - N v_{x0})^2 + (\Delta_y - N v_{y0})^2 - N^4 \frac{A_{max}^2}{4} \le 0 \tag{5c}\label{NA5c}$$ depending on how the velocity is updated with respect to position updates, respectively. (This means each iteration when finding $N$ takes only something like 8 multiplications and 5 additions or subtractions. Since the number of iterations needed is roughly $2 \log_2 N$, this is actually pretty efficient. Even if we find $N \approx 10,000$, we only end up doing a couple of hundred multiplications and a hundred and thirty additions or subtractions. The algebraic solution has more terms than that!)

Furthermore, the optimized form is defined even for $N = 0$ and $N = 1$, so there is no risk of accidental divide-by-zero error. This makes the bisection search easier to write, too.

If we use EQ5(N) for $\eqref{NA5a}$/$\eqref{NA5b}$/$\eqref{NA5c}$, the pseudocode to find $N$ is something like

Function StepsNeeded(x0,y0, xN,yN, vx,vy, Amax):
    Let  dx = xN - x0
    Let  dy = yN - y0
    Let  Nmin = 0
    Let  Nmax = 2

    # Find the Nmin,Nmax range spanning the solution
    While EQ5(Nmax) > 0:
        Let  Nmin = Nmax
        Let  Nmax = Nmax * 2
    End While

    Let  N = Nmax
    While Nmax > Nmin:
        Let  N = Nmax - floor((Nmax - Nmin)/2)
        Let  C = EQ5(N)
        If C > 0:
            Let  Nmin = N
        Else If C < 0:
            If Nmax > N:
                Let  Nmax = N
            Else:
                Break While
            End If
        Else:
            Break loop
        End If
    End While

    Return N
End Function

When we do have $N$, it is just a matter of plugging it back to $\eqref{NA3a}$/$\eqref{NA3b}$/$\eqref{NA3c}$ to obtain the acceleration vector $(a_x , a_y)$.

The first While loop finds the smallest range containing a root, so that Nmax is a sufficient number of steps (yields an acceleration that does not exceed the given limit), and Nmin is an insufficient number of steps (yields an acceleration that exceeds the given limit). For each iteration $1 \le i \in \mathbb{N}$, Nmin= $2^{i-1}$ (except Nmin=0 for $i = 1$, and Nmin=2 for $i = 2$) and Nmax=$2^i$, so only a few iterations are ever needed.

The second While loop uses the bisection method (or binary search) to find the root within that range. As it halves the range on each iteration, it does at most as many iterations as the first loop did.

Because we want an $N$ that yields $a_x^2 + a_y^2 \le A_{max}^2$, we exclude the minimum (Nmin) and include the maximum (Nmax) in the search. This is why we use N = Nmax - floor((Nmax - Nmin)/2), too: it never yields Nmin. This is also why we start with Nmin = 0: the smallest N returned is 1.

Here is an example Python (works in both Python 2 and Python 3) program, that solves the number of steps and the acceleration, when given the starting x and y coordinates, target x and y coordinates, initial velocity x and y components, and the maximum acceleration allowed:

from math import sqrt
from sys import stderr, argv, exit

# This file is in public domain. No guarantees, no warranties.
# Written by Nominal Animal <[email protected]>.

def solveacceleration(start, finish, velocity, maxaccel):
    dx = finish[0] - start[0]
    dy = finish[1] - start[1]
    vx = velocity[0]
    vy = velocity[1]
    ac = 0.25 * maxaccel * maxaccel

    if maxaccel <= 0.0:
        return 0, (0.0, 0.0)

    nmin = 0
    nmax = 2
    while True:
        cx = dx - nmax*vx
        cy = dy - nmax*vy

        # A) cc = cx**2 + cy**2 - ac * nmax**2 * (nmax-1)**2
        # B) cc = cx**2 + cy**2 - ac * nmax**2 * (nmax+1)**2
        # C) cc = cx**2 + cy**2 - ac * nmax**4

        cc = cx**2 + cy**2 - ac * nmax**2 * (nmax-1)**2
        # stderr.write("nmin=%u, nmax=%u, cc=%.6f\n" % (nmin, nmax, cc))
        if cc > 0:
            nmin = nmax
            nmax = nmax * 2
        else:
            break

    n = nmax
    while nmax > nmin:
        n = nmax - int((nmax - nmin) / 2)
        cx = dx - n*vx
        cy = dy - n*vy

        # A) cc = cx**2 + cy**2 - ac * n**2 * (n-1)**2
        # B) cc = cx**2 + cy**2 - ac * n**2 * (n+1)**2
        # C) cc = cx**2 + cy**2 - ac * n**4
        cc = cx**2 + cy**2 - ac * n**2 * (n-1)**2

        # stderr.write("nmin=%u, nmax=%u, n=%u, cc=%.6f\n" % (nmin, nmax, n, cc))
        if cc > 0:
            nmin = n
        elif cc < 0:
            if nmax == n:
                break
            else:
                nmax = n
        else:
            break

    # A) a_ = 2*(d_ - n*v_) / (n * (n - 1))
    # B) a_ = 2*(d_ - n*v_) / (n * (n + 1))
    # C) a_ = 2*(d_ - n*v_) / (n**2)
    ax = 2*(dx - n*vx) / (n * (n - 1))
    ay = 2*(dy - n*vy) / (n * (n - 1))
    return n, (ax, ay)


if __name__ == '__main__':

    if len(argv) != 8:
        stderr.write("\n")
        stderr.write("Usage: python %s x0 y0 x1 y1 xv yv amax\n" % argv[0])
        stderr.write("\n")
        exit(0)

    p0 = ( float(argv[1]), float(argv[2]) )
    p1 = ( float(argv[3]), float(argv[4]) )
    v0 = ( float(argv[5]), float(argv[6]) )
    amax = float(argv[7])

    n, a = solveacceleration(p0, p1, v0, amax)

    print("#  From: %9.3f %9.3f" % p0)
    print("#    To: %9.3f %9.3f" % p1)
    print("#    v0: %+9.3f %+9.3f" % v0)
    print("# Steps: %9d" % n)
    print("#     a: %+9.3f %+9.3f  (%.3f of maximum %.3f)" %
          (a[0], a[1], sqrt(a[0]*a[0]+a[1]*a[1]), amax))

    p = p0
    v = v0
    print("# step    x         y          vx        vy")
    print("")
    for i in range(0, n+1):
        # A) print("%-5d %9.3f %9.3f   %+9.3f %+9.3f" % (i, p[0], p[1], v[0], v[1]))
        #    p = (p[0]+v[0], p[1]+v[1])
        #    v = (v[0]+a[0], v[1]+a[1])

        # B) v = (v[0]+a[0], v[1]+a[1])
        #    print("%-5d %9.3f %9.3f   %+9.3f %+9.3f" % (i, p[0], p[1], v[0], v[1]))
        #    p = (p[0]+v[0], p[1]+v[1])

        # C) v = (v[0]+0.5*a[0], v[1]+0.5*a[1])
        #    print("%-5d %9.3f %9.3f   %+9.3f %+9.3f" % (i, p[0], p[1], v[0], v[1]))
        #    p = (p[0]+v[0], p[1]+v[1])
        #    v = (v[0]+0.5*a[0], v[1]+0.5*a[1])

        print("%-5d %9.3f %9.3f   %+9.3f %+9.3f" % (i, p[0], p[1], v[0], v[1]))
        p = (p[0]+v[0], p[1]+v[1])
        v = (v[0]+a[0], v[1]+a[1])

The solveacceleration() function takes the starting point, target or finish point, and the velocity as two-component tuples. If you include the commented out stderr.write() lines, the function will output a line per iteration when looking for the answer; you'll see that it does very few iterations even for the most complex cases. It returns the number of steps, plus the acceleration as a two-component tuple.

The program itself outputs the parameters and the solution, including the location and velocity at each step, in a format suitable for e.g. gnuplot. If you save the output as e.g out.txt, you can use

plot "out.txt" u 2:3 notitle w lines lc -1, \
     "out.txt" u 2:3:1 notitle w labels \
               hypertext point pt 6

in gnuplot to draw the trajectory, with small circles around each time step; hovering over each circle shows you the time step as a tooltip. To include the velocity in the tooltip, use

plot "out.txt" u 2:3 notitle w lines lc -1, \
     "out.txt" u 2:3:(sprintf("%s: (%s,%s)", stringcolumn(1), stringcolumn(4), stringcolumn(5))) \
               notitle w labels hypertext point pt 6

As it is written above, the example uses the $\eqref{NA2a}$ ("A") logic, position updated before velocity. I've commented the sections where you need to modify the code for the other two ("B" or "C").

Best Answer

Related Solutions

[Math] Where to shoot to hit a moving target in 3D space

Calculate the constant acceleration needed for the discrete time trajectory to intersect a given target point

Related Question