Dart Physics

July 9, 2017 at 10 AM

We have a dart board at the office and have a good time lofting darts in nice, looping arcs. A recent project pushed me back into physics and led me to consider just how sensitive the dart-throwing motion is to small imperfections in angle; how precise do we need to be? Calculating those angular perturbations ( in the coordinates I’ll set up next) requires the kinematics of the problem and provides an opportunity to solve the equations numerically with R.


Our office dart board is fixed at a location , and a thrower (darter? player?) stands with their throwing elbow at a location . Here is the player’s forearm length and things are arranged so a “perfect” 90 release starts from a height . Recall that the kinematics derive from Newton’s second law. Assuming a constant gravitational acceleration near the earth’s surface, we want to solve the equations Because there are no forces acting left to right (except for the neglected air drag), the equation has no acceleration term.

With the above equations come initial conditions: and with the release angle – the angle of the player’s forearm at the moment of the throw. The angle is measured conventionally (and unintuitively here) from the forward direction, so a throw vertically upwards would have . Computing is a little trickier but possible with a bit of trigonometry and calculus; the magnitude is just , and one can show that


To find a solution wherein we hit the bullseye, we fix and , with the time to target. These definitions specify the solution after some tedious algebra. First, the equation yields time as a simple function of release angle and angular velocity (or linear velocity ): Intuitively, the time of flight is the ratio of the distance traveled in the direction to . The equation generates a more complicated expression for the angular velocity: This one’s harder to interpret, but it has the correct units (s) and exhibits interesting divergences: as , , , etc. Note, too, that the divergence differs from its counterpart in that different parts of the denominator go to zero ( vs. the term in square brackets).

With the solution in hand we can also find the maximum height of the dart during its flight. The path is a function of and , and the maximum height is an extremum of : . A check of the second derivative confirms this is, in fact, a maximum, and The maximum depends on the starting height and also varies with the distance to be crossed by the dart.

Finally, we can work out an answer to my original question: how sensitive is the solution to perturbations in angle, ? The answer comes from the accurate solution by computing the derivative at fixed – the angular frequency of the accurate solution. The derivative is and this quantity can be interpreted as the vertical distance by which the dart would miss for a small (e.g., degree) imperfection in the release angle. We could go on to ask similar questions about imperfections in velocity.


Now that we have the general solutions, let’s take a look at the results numerically. Start by making a few assignments:

G_EARTH <- 9.8

L <- 10*12 * 2.54/100  # 10 feet
r <- 14    * 2.54/100  # 14 inch forearm
C <- 6*12  * 2.54/100  # 6 more feet

The constant measures the ceiling height relative to the bullseye, is the forearm length, and is the horizontal distance between the player and the board. Here I’ve estimated feet, inches, and feet of clearance. The gravitational constant is, as always, 9.8 meters per squared second. With the constants fixed, I’ve implemented the kinematic equations as functions in R and computed them on a radian grid spanning :2

calc <- tibble(
  theta     = seq(pi, 0, -pi*1e-4),
  theta_deg = theta * 180/pi,
  omega     = omega(L = L, r = r, theta = theta),
  vel       = r*omega,
  vel_mph   = vel * 3600 * 100 / 2.54 / 12 / 5280,
  time      = tt(L = L, r = r, theta = theta),
  y0        = r*(sin(theta - 1)),
  ymax      = ymax(L = L, r = r, theta = theta),
  yratio    = ymax/y0,
  ymax_ft   = ymax * 100 / 2.54 / 12,
  hit_ceil  = ymax >= C,
  dy_dtheta = dydtheta(L = L, r = r, theta = theta)

The results can be simply divided into two main categories: “standard” vs. “extreme” solutions.

Standard Solutions

I’ve defined standard solutions as those for which (i) the dart doesn’t hit the ceiling and (ii) to separate out the slightly crazier results.

We find, intuitively, that the throw velocity must increase as the release angle approaches 90 degrees. The maximum height and air travel time always decrease as the trajectory flattens, but interestingly the required throw velocity has a minimum value. (In the figures I’m plotting vs. ; corresponds to a vertical upwards throw and to a vertical downwards throw.)

For we have to throw the dart harder because much of its velocity is “wasted” traveling vertically. On the other hand, for we need more velocity to make it to the target before gravity can pull the dart too far. We could take a derivative to find , but since we’re already here we can just find the minimum numerically:

opt_value <- optimize(function(.x) omega(L, r, .x)^2, c(pi/2, pi))
180 - opt_value$minimum * 180/pi
## [1] 46.30904

The minimum is not , but slightly larger (a flatter trajectory).

Crazier Solutions

The first set of results not yet considered covers solutions approaching a perfectly horizontal throw. The travel time and maximum height again decrease (the maximum height decreases roughly linearly), but the throw velocity diverges: as the dart needs to hit the bullseye before gravity pulls it off line.

Finally, there’s a slice of the solution for which we need a more vertical headroom:

Once again we get crazy behavior with velocity, but now the time and maximum height are both extremely large – these plots are on a logarithmic scale. These solutions basically correspond to throwing a dart upwards and still managing to hit the bullseye. For some of these solutions our constant- approximation would be in big trouble!

Margin of Error in Release Angle

Finally, what is our margin of error on dart throws? We can check by plotting and letting .

This plot suggests two things:

  1. There is an angle near 46 degrees where throws are less affected by errors in angle.
  2. The dart can miss by quite a bit for angles far from : on the order of meters (this seems like quite a lot).


For the set up we considered, it turns out that there is an angle near for which the required velocity is a minimum. The dart throw is also most forgiving near that angle. There are also an interesting class of solutions that require fast dart throws, some of which would put the dart into orbit!

This was a fun exercise – I was able to work the problem and do the computation in an evening.

  1. To simply the mental model, I’ve actually mirrored our setup; we actually throw from right to left. ↩︎

  2. I highly recommend the tidyverse suite of R packages to simplify creating and working with data frames. ↩︎

Related Posts