calcrack — A Fit-Checker Presented as a Solver

Jordan Henshaw's calcrack (github.com/jordanhenshaw/calcrack, @jordanhenshawhq) is a Blender add-on for gunshot crack-thump analysis. Unlike Bray's work, the physics it implements is correctly derived — this is not a case of broken math. The problem is structural: the tool can't produce a shooter position without you assuming most of the answer first, it reports no uncertainty, and its headline "more accurate" feature does nothing in the current code.

It would be easy to wave this off as another broken script. It isn't. The closed-form crack-thump calculation in algorithm/math.py is derived correctly:

def calculate(x, r, R_mag, v, c):
    t_thump = R_mag / c
    if v <= c:
        return 0.0
    cot_theta = math.sqrt(v*v - c*c) / c
    tan_theta = c / math.sqrt(v*v - c*c)
    if x < r * tan_theta:
        return 0.0
    t_crack = (x + r * cot_theta) / v
    return t_thump - t_crack

With Mach angle μ where sin μ = c/v, the first-arrival shock at a mic at along-path distance x and perpendicular miss r is t_crack = (x + r · cot μ) / v, and the muzzle blast is t_thump = R/c. The code's cot_theta is exactly cot μ, and the x < r·tan θ gate correctly rejects mics the shock cone can't reach. The speed-of-sound model (c = 331.3·√(T/273.15)) is the standard relation.

A crack-thump delay is one number per mic. To predict it, the model needs a trajectory, a velocity, and a clean read of the waveform. The question that matters is which of those you can actually pin down — and which you're forced to assume.

Because the user supplies the candidate, the entire output is a measure of how well that candidate fits. algorithm/compare.py computes, per mic, error = abs(predicted - observed), then sums and averages them into two numbers: aggregated error and mean error, in seconds.

• ✗ No confidence intervals, no uncertainty propagation, no Monte Carlo over input noise — nothing that tells you whether a small error is significant or coincidental
• ✗ An error_margin setting rounds any per-mic error at or below the threshold down to 0.00 (default 0, so honest out of the box — but available)
• ✗ The UI invites a per-mic confidence rating (1–3) — which the code gathers and then never uses; it has zero effect on the result

A low residual from a position you chose yourself, reported with no error bars, is not a location estimate. It only says your inputs were mutually consistent.

The constant-velocity limitation above would be excusable if the tool's own answer to it worked. It exposes a "Consider Air Drag" toggle — described as a "more accurate and resource-intensive simulation" — and switches to an advanced code path when it's on. Here is that path's drag module in full:

BALLISTIC_COEFF = 0.45
BULLET_MASS_GRAINS = 150.0
BULLET_DIAMETER_INCH = 0.308
AIR_DENSITY_KG_M3 = 1.225
...
def distance_at_time(t_seconds, muzzle_velocity_mps):
    return muzzle_velocity_mps * t_seconds

distance_at_time is pure v · t — there is no drag. The ballistic coefficient, bullet mass, diameter, and air density are defined but never referenced anywhere in the module. The drag model is unbuilt scaffolding.