@woosh/meep-engine 3.21.0 → 3.23.0

package/src/engine/physics/cloth/solver/constraint/cloth_leash_row.js

@@ -0,0 +1,346 @@
+import {
+    CVA_F_X,
+    CVA_F_Y,
+    CVA_F_Z,
+    CVA_H_XX,
+    CVA_H_XY,
+    CVA_H_XZ,
+    CVA_H_YY,
+    CVA_H_YZ,
+    CVA_H_ZZ,
+    CVA_TRUST
+} from "../cloth_vertex_accumulator.js";
+import { CLOTH_STRETCH_EPSILON } from "./cloth_stretch_row.js";
+
+/**
+ * # Leash — the distance-to-a-point row
+ *
+ *     C(x) = ‖x_i − s‖ − r
+ *     ∂C/∂x_i = (x_i − s)/‖x_i − s‖ = n
+ *
+ * **This is both of §6's leash rows.** The slack row and the tether row have
+ * the same `C`, the same clamp and the same stiffness; they differ only in
+ * where `s` and `r` come from:
+ *
+ * | | `s` | `r` |
+ * |---|---|---|
+ * | slack | the particle's **animated position** | `slack · d_geo,i` |
+ * | tether (LRA) | the **anchor's** position | `d_geo,i` |
+ *
+ * So they are one module, parameterised by mode, exactly as
+ * `physics/constraint/solve_constraints.js` does for its 6-DOF joints at the
+ * velocity level, and exactly as `cloth_stretch_row.js` covers both the fabric
+ * row and its strain limit. A cape wants both, because they ask different
+ * questions: slack asks how loosely the cloth is leashed to the animation, the
+ * tether asks how far the fabric may extend from where it hangs (§6).
+ *
+ * §3.4's pin falls out too, with no third row and no branch: a particle whose
+ * `d_geo` is zero has a slack radius of zero, and `‖x_i − s‖ ≤ 0` under this
+ * clamp *is* a weld.
+ *
+ * ## The row is hard, and one-sided, structurally
+ *
+ * Neither a stiffness nor a pair of clamps is stored, because neither varies.
+ * A leash is `hard` in §6's table — its penalty lives in the measured band and
+ * its multiplier carries the load — and it is a *bound* rather than a spring,
+ * so it may only pull inwards. That is why this is the row that survives a low
+ * iteration budget: it is enforced almost exactly in one iteration, which is
+ * what §7 P2 means by long-range attachments making low iteration counts
+ * viable.
+ *
+ * ## Which way the clamp goes, and why §6's table has it backwards
+ *
+ * The solver applies `f -= fc·g`, so a **positive** `fc` on a distance row
+ * pulls the two ends together — that is what `cloth_stretch_row.js` means when
+ * it adds geometric stiffness for a row "in tension" at `fc > 0`. A row that
+ * bounds a distance from *above* must therefore be allowed positive force and
+ * no negative force: `f_min = 0, f_max = +∞`.
+ *
+ * §6's table gives slack, tether and strain limit `(−∞, 0]` instead, which
+ * under this convention is the force that pushes them apart — it would drive
+ * the particle *away* from its leash centre and the row would never bind.
+ * `cloth_leash_row.spec.js` demonstrates the correct sign directly; the
+ * table's own collision and self-collision rows are consistent with it once
+ * you notice that a collision row writes `C` with the opposite sense. The
+ * precise rule, which the table's "push-only / pull-only" gloss elides, is:
+ * `[0, +∞)` admits only forces that **reduce** `C`, and `(−∞, 0]` only forces
+ * that **increase** it.
+ *
+ * ## Coincident with the target
+ *
+ * `‖x − s‖` is not differentiable at zero. Below {@link CLOTH_STRETCH_EPSILON}
+ * the row is skipped, which is the standard guard and is also exactly when it
+ * has nothing to do — a particle sitting on its own leash centre is where the
+ * row was trying to put it.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * Evaluate one leash row's constraint value and its gradient.
+ *
+ * This is the definition the accumulation loop below inlines, and the one the
+ * finite-difference spec checks — there is no second copy of the arithmetic.
+ *
+ * @param {Float64Array|number[]} gradient out, `∂C/∂x`
+ * @param {number} gradient_offset
+ * @param {ClothState} state
+ * @param {number} row
+ * @returns {number} `C`
+ */
+export function cloth_leash_evaluate(gradient, gradient_offset, state, row) {
+    const self = state.leash_particle[row] * 3;
+    const target = row * 3;
+
+    const position = state.position;
+    const leash_target = state.leash_target;
+
+    const dx = position[self] - leash_target[target];
+    const dy = position[self + 1] - leash_target[target + 1];
+    const dz = position[self + 2] - leash_target[target + 2];
+
+    const length = Math.sqrt(dx * dx + dy * dy + dz * dz);
+
+    if (length < CLOTH_STRETCH_EPSILON) {
+        gradient[gradient_offset] = 0;
+        gradient[gradient_offset + 1] = 0;
+        gradient[gradient_offset + 2] = 0;
+
+        return length - state.leash_radius[row];
+    }
+
+    const inverse = 1 / length;
+
+    gradient[gradient_offset] = dx * inverse;
+    gradient[gradient_offset + 1] = dy * inverse;
+    gradient[gradient_offset + 2] = dz * inverse;
+
+    return length - state.leash_radius[row];
+}
+
+/**
+ * Add every leash row touching `particle` into the vertex accumulator.
+ *
+ * @param {Float64Array} accumulator
+ * @param {ClothState} state
+ * @param {number} particle
+ */
+export function cloth_leash_accumulate(accumulator, state, particle) {
+    const offset = state.leash_adjacency_offset;
+
+    const start = offset[particle];
+    const end = offset[particle + 1];
+
+    if (start === end) {
+        return;
+    }
+
+    const adjacency = state.leash_adjacency;
+    const radius = state.leash_radius;
+    const lambda = state.leash_lambda;
+    const penalty = state.leash_penalty;
+    const leash_target = state.leash_target;
+    const position = state.position;
+
+    const self = particle * 3;
+
+    const x = position[self];
+    const y = position[self + 1];
+    const z = position[self + 2];
+
+    let f_x = accumulator[CVA_F_X];
+    let f_y = accumulator[CVA_F_Y];
+    let f_z = accumulator[CVA_F_Z];
+
+    let h_xx = accumulator[CVA_H_XX];
+    let h_yy = accumulator[CVA_H_YY];
+    let h_zz = accumulator[CVA_H_ZZ];
+    let h_xy = accumulator[CVA_H_XY];
+    let h_xz = accumulator[CVA_H_XZ];
+    let h_yz = accumulator[CVA_H_YZ];
+
+    let trust = accumulator[CVA_TRUST];
+
+    for (let i = start; i < end; i++) {
+        const row = adjacency[i];
+
+        const target = row * 3;
+
+        const dx = x - leash_target[target];
+        const dy = y - leash_target[target + 1];
+        const dz = z - leash_target[target + 2];
+
+        const length_squared = dx * dx + dy * dy + dz * dz;
+
+        if (length_squared < CLOTH_STRETCH_EPSILON * CLOTH_STRETCH_EPSILON) {
+            continue;
+        }
+
+        const k = penalty[row];
+
+        const length = Math.sqrt(length_squared);
+
+        const unclamped = k * (length - radius[row]) + lambda[row];
+
+        if (unclamped <= 0) {
+            // Inside the leash and carrying no accumulated force: the row is
+            // clamped out, contributes neither force nor curvature, and — this
+            // is the part that matters — must not narrow the trust region
+            // either. A particle resting near its own leash centre would
+            // otherwise cap every step at its distance from that centre and
+            // freeze for reasons that have nothing to do with the rows doing
+            // the work.
+            continue;
+        }
+
+        const inverse = 1 / length;
+
+        if (length < trust) {
+            trust = length;
+        }
+
+        const g_x = dx * inverse;
+        const g_y = dy * inverse;
+        const g_z = dz * inverse;
+
+        f_x -= unclamped * g_x;
+        f_y -= unclamped * g_y;
+        f_z -= unclamped * g_z;
+
+        // Geometric stiffness, positive part only. The row is in tension
+        // whenever it is active at all — that is what the clamp above means —
+        // so the `(fc/L)·(I − ggᵀ)` term is positive semidefinite here without
+        // a second test. `MEASUREMENTS.md` §5.1 for what dropping it costs.
+        const s = unclamped * inverse;
+
+        h_xx += s * (1 - g_x * g_x) + k * g_x * g_x;
+        h_yy += s * (1 - g_y * g_y) + k * g_y * g_y;
+        h_zz += s * (1 - g_z * g_z) + k * g_z * g_z;
+        h_xy += (k - s) * g_x * g_y;
+        h_xz += (k - s) * g_x * g_z;
+        h_yz += (k - s) * g_y * g_z;
+    }
+
+    accumulator[CVA_F_X] = f_x;
+    accumulator[CVA_F_Y] = f_y;
+    accumulator[CVA_F_Z] = f_z;
+
+    accumulator[CVA_H_XX] = h_xx;
+    accumulator[CVA_H_YY] = h_yy;
+    accumulator[CVA_H_ZZ] = h_zz;
+    accumulator[CVA_H_XY] = h_xy;
+    accumulator[CVA_H_XZ] = h_xz;
+    accumulator[CVA_H_YZ] = h_yz;
+
+    accumulator[CVA_TRUST] = trust;
+}
+
+/**
+ * Warm start every leash row for a substep: regularise the carried multiplier
+ * and put the penalty in the band. §5.2.
+ *
+ * Every leash row is hard, so — unlike the stretch table — there is no soft
+ * branch here. The row's inertial scale is the particle's own `m/h²`, because
+ * a leash has one end that can move.
+ *
+ * @param {ClothState} state
+ * @param {number} alpha multiplier regularisation, `[0, 1]`
+ * @param {number} gamma dual decay, `[0, 1)`
+ * @param {number} k_min_ratio penalty floor, as a multiple of `m/h²`
+ * @param {number} k_max_ratio penalty ceiling, as a multiple of `m/h²`
+ * @param {number} inverse_h_squared
+ */
+export function cloth_leash_warm_start(state, alpha, gamma, k_min_ratio, k_max_ratio, inverse_h_squared) {
+    const count = state.leash_count;
+
+    const row_particle = state.leash_particle;
+    const mass_inverse = state.mass_inverse;
+    const lambda = state.leash_lambda;
+    const penalty = state.leash_penalty;
+
+    const decay = alpha * gamma;
+
+    for (let row = 0; row < count; row++) {
+        const compliance = mass_inverse[row_particle[row]];
+
+        if (compliance === 0) {
+            // A pinned particle cannot move, so the row has nothing to enforce
+            // and the band it would be clamped into is unbounded. Zeroed rather
+            // than left holding `Infinity` in live state.
+            penalty[row] = 0;
+            lambda[row] = 0;
+
+            continue;
+        }
+
+        const scale = inverse_h_squared / compliance;
+
+        const lo = k_min_ratio * scale;
+        const hi = k_max_ratio * scale;
+
+        lambda[row] *= decay;
+
+        let k = penalty[row] * gamma;
+
+        if (k < lo) {
+            k = lo;
+        } else if (k > hi) {
+            k = hi;
+        }
+
+        penalty[row] = k;
+    }
+}
+
+/**
+ * Dual update for every leash row: absorb this iteration's violation into the
+ * multiplier and ramp the penalty. §5.2.
+ *
+ * @param {ClothState} state
+ * @param {number} beta penalty ramp
+ * @param {number} k_max_ratio
+ * @param {number} inverse_h_squared
+ */
+export function cloth_leash_dual_update(state, beta, k_max_ratio, inverse_h_squared) {
+    const count = state.leash_count;
+
+    const row_particle = state.leash_particle;
+    const mass_inverse = state.mass_inverse;
+    const position = state.position;
+    const leash_target = state.leash_target;
+    const radius = state.leash_radius;
+    const lambda = state.leash_lambda;
+    const penalty = state.leash_penalty;
+
+    for (let row = 0; row < count; row++) {
+        const particle = row_particle[row];
+
+        const compliance = mass_inverse[particle];
+
+        if (compliance === 0) {
+            continue;
+        }
+
+        const k_max = k_max_ratio * inverse_h_squared / compliance;
+
+        const self = particle * 3;
+        const target = row * 3;
+
+        const dx = position[self] - leash_target[target];
+        const dy = position[self + 1] - leash_target[target + 1];
+        const dz = position[self + 2] - leash_target[target + 2];
+
+        const c = Math.sqrt(dx * dx + dy * dy + dz * dz) - radius[row];
+
+        const k = penalty[row];
+
+        const next = k * c + lambda[row];
+
+        lambda[row] = next > 0 ? next : 0;
+
+        const ramped = k + beta * Math.abs(c);
+
+        penalty[row] = ramped < k_max ? ramped : k_max;
+    }
+}

package/src/engine/physics/cloth/solver/constraint/cloth_self_row.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Rebuild the per-particle Jacobi scratch from the pair list.
+ *
+ * Called once per iteration, before the colour sweep, from the positions the
+ * previous iteration left. Every pair contributes to both of its particles.
+ *
+ * @param {ClothState} state
+ * @param {number} stiffness penalty, N/m — the same for every pair, because
+ *   every pair has the same two free ends and therefore the same inertial scale
+ * @returns {number} how many pairs were in contact
+ */
+export function cloth_self_accumulate_scratch(state: ClothState, stiffness: number): number;
+/**
+ * Add one particle's share of the Jacobi scratch into its vertex accumulator.
+ *
+ * @param {Float64Array} accumulator
+ * @param {ClothState} state
+ * @param {number} particle
+ */
+export function cloth_self_accumulate(accumulator: Float64Array, state: ClothState, particle: number): void;
+/**
+ * # Self-collision — the row that keeps cloth off itself
+ *
+ *     C(x) = ‖x_i − x_j‖ − (r_i + r_j)
+ *     ∂C/∂x_i = (x_i − x_j)/‖x_i − x_j‖ = n
+ *     ∂C/∂x_j = −n
+ *     clamp (−∞, 0]
+ *
+ * **That clamp is right and it is the one place in §6's table where the negative
+ * half is the live one.** The rule is that `[0, +∞)` admits only forces that
+ * *reduce* `C` and `(−∞, 0]` only forces that *increase* it; this row is violated
+ * when the two particles are closer than their radii, which is `C < 0`, so what
+ * it needs is `C` increased. Under the solver's `f -= fc·g`, a negative `fc`
+ * pushes `i` along `+n` and `j` along `−n` — apart. Every distance row above it
+ * in the table bounds a distance from *above* and therefore takes the other
+ * half; this one bounds from below.
+ *
+ * ## It is applied Jacobi-style, and this is where §5.4 was right
+ *
+ * A collider contact is unary and needs none of §5.4's machinery (`MEASUREMENTS.md`
+ * §18). A self-collision row is a **pair**, and pairs are exactly what the
+ * colouring cannot pre-partition: two particles of the same colour can be
+ * neighbours in space and would then both move against each other inside one
+ * sweep, in an order that depends on how the sweep was split. So the pairs are
+ * accumulated once per iteration into a per-particle `(f, H)` scratch, from the
+ * positions at the start of that iteration, and every vertex update adds its own
+ * entry. The result is a step that is the same whatever order the colours were
+ * swept in, which is what §12's bit-parity gate is going to be held to.
+ *
+ * ## The row is soft, which the collision row could not be
+ *
+ * `MEASUREMENTS.md` §18 measured that a collider contact cannot be a soft
+ * penalty: the force it has to produce is an *arrested impact*, 376 N for a
+ * sheet arriving at 8 m/s, against the 4.6 N a soft row inside M0's dissipative
+ * band can deliver at one thickness of penetration.
+ *
+ * A self-collision row carries nothing of the kind. What it holds apart is cloth
+ * against cloth — grams, moving at the speed cloth moves relative to itself — and
+ * a penalty at the top of the band produces newtons per millimetre against a
+ * load of fractions of a newton. So it is a plain penalty with no multiplier, no
+ * warm start and no identity across steps, which is also what makes a pair list
+ * that is rebuilt from scratch every step affordable: there is nothing on a pair
+ * worth carrying. `MEASUREMENTS.md` §33.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/**
+ * Below this a separation is treated as zero and the row is skipped: `‖·‖` is
+ * not differentiable there, and two particles at exactly the same place have no
+ * direction to be pushed apart along.
+ * @type {number}
+ */
+export const CLOTH_SELF_EPSILON: number;
+//# sourceMappingURL=cloth_self_row.d.ts.map

package/src/engine/physics/cloth/solver/constraint/cloth_self_row.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloth_self_row.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/physics/cloth/solver/constraint/cloth_self_row.js"],"names":[],"mappings":"AAoEA;;;;;;;;;;GAUG;AACH,4EAJW,MAAM,GAEJ,MAAM,CA4FlB;AAED;;;;;;GAMG;AACH,mDAJW,YAAY,+BAEZ,MAAM,QAyBhB;AA7LD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH;;;;;GAKG;AACH,iCAFU,MAAM,CAEuB"}

package/src/engine/physics/cloth/solver/constraint/cloth_self_row.js

@@ -0,0 +1,202 @@
+import {
+    CVA_F_X,
+    CVA_F_Y,
+    CVA_F_Z,
+    CVA_H_XX,
+    CVA_H_XY,
+    CVA_H_XZ,
+    CVA_H_YY,
+    CVA_H_YZ,
+    CVA_H_ZZ
+} from "../cloth_vertex_accumulator.js";
+
+/**
+ * # Self-collision — the row that keeps cloth off itself
+ *
+ *     C(x) = ‖x_i − x_j‖ − (r_i + r_j)
+ *     ∂C/∂x_i = (x_i − x_j)/‖x_i − x_j‖ = n
+ *     ∂C/∂x_j = −n
+ *     clamp (−∞, 0]
+ *
+ * **That clamp is right and it is the one place in §6's table where the negative
+ * half is the live one.** The rule is that `[0, +∞)` admits only forces that
+ * *reduce* `C` and `(−∞, 0]` only forces that *increase* it; this row is violated
+ * when the two particles are closer than their radii, which is `C < 0`, so what
+ * it needs is `C` increased. Under the solver's `f -= fc·g`, a negative `fc`
+ * pushes `i` along `+n` and `j` along `−n` — apart. Every distance row above it
+ * in the table bounds a distance from *above* and therefore takes the other
+ * half; this one bounds from below.
+ *
+ * ## It is applied Jacobi-style, and this is where §5.4 was right
+ *
+ * A collider contact is unary and needs none of §5.4's machinery (`MEASUREMENTS.md`
+ * §18). A self-collision row is a **pair**, and pairs are exactly what the
+ * colouring cannot pre-partition: two particles of the same colour can be
+ * neighbours in space and would then both move against each other inside one
+ * sweep, in an order that depends on how the sweep was split. So the pairs are
+ * accumulated once per iteration into a per-particle `(f, H)` scratch, from the
+ * positions at the start of that iteration, and every vertex update adds its own
+ * entry. The result is a step that is the same whatever order the colours were
+ * swept in, which is what §12's bit-parity gate is going to be held to.
+ *
+ * ## The row is soft, which the collision row could not be
+ *
+ * `MEASUREMENTS.md` §18 measured that a collider contact cannot be a soft
+ * penalty: the force it has to produce is an *arrested impact*, 376 N for a
+ * sheet arriving at 8 m/s, against the 4.6 N a soft row inside M0's dissipative
+ * band can deliver at one thickness of penetration.
+ *
+ * A self-collision row carries nothing of the kind. What it holds apart is cloth
+ * against cloth — grams, moving at the speed cloth moves relative to itself — and
+ * a penalty at the top of the band produces newtons per millimetre against a
+ * load of fractions of a newton. So it is a plain penalty with no multiplier, no
+ * warm start and no identity across steps, which is also what makes a pair list
+ * that is rebuilt from scratch every step affordable: there is nothing on a pair
+ * worth carrying. `MEASUREMENTS.md` §33.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * Below this a separation is treated as zero and the row is skipped: `‖·‖` is
+ * not differentiable there, and two particles at exactly the same place have no
+ * direction to be pushed apart along.
+ * @type {number}
+ */
+export const CLOTH_SELF_EPSILON = 1e-9;
+
+/**
+ * Rebuild the per-particle Jacobi scratch from the pair list.
+ *
+ * Called once per iteration, before the colour sweep, from the positions the
+ * previous iteration left. Every pair contributes to both of its particles.
+ *
+ * @param {ClothState} state
+ * @param {number} stiffness penalty, N/m — the same for every pair, because
+ *   every pair has the same two free ends and therefore the same inertial scale
+ * @returns {number} how many pairs were in contact
+ */
+export function cloth_self_accumulate_scratch(state, stiffness) {
+    const force = state.self_force;
+    const hessian = state.self_hessian;
+
+    force.fill(0);
+    hessian.fill(0);
+
+    const count = state.self_count;
+
+    if (count === 0) {
+        return 0;
+    }
+
+    const pair = state.self_pair;
+    const position = state.position;
+
+    const radius = state.self_radius * 2;
+
+    let active = 0;
+
+    for (let p = 0; p < count; p++) {
+        const i = pair[p * 2];
+        const j = pair[p * 2 + 1];
+
+        const a = i * 3;
+        const b = j * 3;
+
+        const dx = position[a] - position[b];
+        const dy = position[a + 1] - position[b + 1];
+        const dz = position[a + 2] - position[b + 2];
+
+        const length_squared = dx * dx + dy * dy + dz * dz;
+
+        if (length_squared >= radius * radius || length_squared < CLOTH_SELF_EPSILON * CLOTH_SELF_EPSILON) {
+            continue;
+        }
+
+        active++;
+
+        const length = Math.sqrt(length_squared);
+
+        const inverse = 1 / length;
+
+        const nx = dx * inverse;
+        const ny = dy * inverse;
+        const nz = dz * inverse;
+
+        // `C < 0` and the clamp admits only negative force, so `fc = k·C` needs
+        // no clamping at all — it is already on the admitted side, which is what
+        // a one-sided row with no multiplier reduces to.
+        const magnitude = stiffness * (radius - length);
+
+        force[a] += magnitude * nx;
+        force[a + 1] += magnitude * ny;
+        force[a + 2] += magnitude * nz;
+
+        force[b] -= magnitude * nx;
+        force[b + 1] -= magnitude * ny;
+        force[b + 2] -= magnitude * nz;
+
+        // `k·n nᵀ`, the penalty curvature, into both particles' blocks. The
+        // geometric term `(fc/L)·(I − n nᵀ)` is dropped: `fc` is negative here —
+        // the row is in *compression*, pushing apart — so that term is negative
+        // semidefinite, and §5.3 keeps only the positive half.
+        const hxx = stiffness * nx * nx;
+        const hyy = stiffness * ny * ny;
+        const hzz = stiffness * nz * nz;
+        const hxy = stiffness * nx * ny;
+        const hxz = stiffness * nx * nz;
+        const hyz = stiffness * ny * nz;
+
+        const ha = i * 6;
+        const hb = j * 6;
+
+        hessian[ha] += hxx;
+        hessian[ha + 1] += hyy;
+        hessian[ha + 2] += hzz;
+        hessian[ha + 3] += hxy;
+        hessian[ha + 4] += hxz;
+        hessian[ha + 5] += hyz;
+
+        hessian[hb] += hxx;
+        hessian[hb + 1] += hyy;
+        hessian[hb + 2] += hzz;
+        hessian[hb + 3] += hxy;
+        hessian[hb + 4] += hxz;
+        hessian[hb + 5] += hyz;
+    }
+
+    return active;
+}
+
+/**
+ * Add one particle's share of the Jacobi scratch into its vertex accumulator.
+ *
+ * @param {Float64Array} accumulator
+ * @param {ClothState} state
+ * @param {number} particle
+ */
+export function cloth_self_accumulate(accumulator, state, particle) {
+    const hessian = state.self_hessian;
+
+    const h = particle * 6;
+
+    if (hessian[h] === 0 && hessian[h + 1] === 0 && hessian[h + 2] === 0) {
+        return;
+    }
+
+    const force = state.self_force;
+
+    const f = particle * 3;
+
+    accumulator[CVA_F_X] += force[f];
+    accumulator[CVA_F_Y] += force[f + 1];
+    accumulator[CVA_F_Z] += force[f + 2];
+
+    accumulator[CVA_H_XX] += hessian[h];
+    accumulator[CVA_H_YY] += hessian[h + 1];
+    accumulator[CVA_H_ZZ] += hessian[h + 2];
+    accumulator[CVA_H_XY] += hessian[h + 3];
+    accumulator[CVA_H_XZ] += hessian[h + 4];
+    accumulator[CVA_H_YZ] += hessian[h + 5];
+}