rlx-fdm 0.2.17

Force density method (FDM) for RLX — pin-jointed form-finding ported from jax_fdm.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

// RLX — versatile ML compiler + runtime.
// Copyright (C) 2026 Eugene Hauptmann, Nataliya Kosmyna.
// SPDX-License-Identifier: MIT OR Apache-2.0

//! Mesh structures for face tributary loads (jax_fdm `equilibrium.structures.meshes`).

use crate::network::{Network, Vec3};
use crate::structure::Structure;

/// Mesh topology layered on a pin-jointed [`Structure`].
#[derive(Clone, Debug)]
pub struct MeshStructure {
    pub base: Structure,
    /// Face vertex index lists (≥ 3 vertices each).
    pub faces: Vec<Vec<usize>>,
    /// Up to two incident face indices per edge (`None` = boundary).
    pub edges_faces: Vec<[Option<usize>; 2]>,
    /// Row-normalized face–vertex matrix flattened `[num_faces, num_nodes]`.
    pub face_vertex_weights: Vec<f64>,
}

impl MeshStructure {
    pub fn from_network_and_faces(network: &Network, faces: Vec<Vec<usize>>) -> Self {
        let base = Structure::from_network(network);
        let edges_faces = edges_faces_from_mesh(&faces, &network.edges);
        let face_vertex_weights = face_vertex_matrix(&faces, base.num_nodes);
        Self {
            base,
            faces,
            edges_faces,
            face_vertex_weights,
        }
    }

    pub fn num_faces(&self) -> usize {
        self.faces.len()
    }

    /// Face centroids `C_fv @ xyz` (jax_fdm `connectivity_faces_vertices @ xyz`).
    pub fn face_centroids(&self, xyz: &[f64]) -> Vec<Vec3> {
        let n = self.base.num_nodes;
        let nf = self.num_faces();
        let mut out = vec![0.0; nf * 3];
        for f in 0..nf {
            for v in 0..n {
                let w = self.face_vertex_weights[f * n + v];
                if w == 0.0 {
                    continue;
                }
                out[f * 3] += w * xyz[v * 3];
                out[f * 3 + 1] += w * xyz[v * 3 + 1];
                out[f * 3 + 2] += w * xyz[v * 3 + 2];
            }
        }
        (0..nf)
            .map(|f| [out[f * 3], out[f * 3 + 1], out[f * 3 + 2]])
            .collect()
    }
}

fn face_vertex_matrix(faces: &[Vec<usize>], num_nodes: usize) -> Vec<f64> {
    let nf = faces.len();
    let mut f = vec![0.0; nf * num_nodes];
    for (fi, face) in faces.iter().enumerate() {
        let valid: Vec<usize> = face.iter().copied().filter(|&v| v < num_nodes).collect();
        if valid.is_empty() {
            continue;
        }
        let inv = 1.0 / valid.len() as f64;
        for v in valid {
            f[fi * num_nodes + v] = inv;
        }
    }
    f
}

fn edges_faces_from_mesh(
    faces: &[Vec<usize>],
    edges: &[(usize, usize)],
) -> Vec<[Option<usize>; 2]> {
    let mut out = vec![[None, None]; edges.len()];
    for (fi, face) in faces.iter().enumerate() {
        let loopv: Vec<usize> = face
            .iter()
            .copied()
            .filter(|&v| v < usize::MAX / 2)
            .collect();
        if loopv.len() < 3 {
            continue;
        }
        for i in 0..loopv.len() {
            let u = loopv[i];
            let v = loopv[(i + 1) % loopv.len()];
            for (ei, &(a, b)) in edges.iter().enumerate() {
                if (a == u && b == v) || (a == v && b == u) {
                    if out[ei][0].is_none() {
                        out[ei][0] = Some(fi);
                    } else if out[ei][1].is_none() && out[ei][0] != Some(fi) {
                        out[ei][1] = Some(fi);
                    }
                }
            }
        }
    }
    out
}

/// Unique edges from face loops (jax_fdm `Mesh._edges_from_faces`).
pub fn edges_from_faces(faces: &[Vec<usize>]) -> Vec<(usize, usize)> {
    let mut half = Vec::new();
    for face in faces {
        if face.len() < 3 {
            continue;
        }
        for i in 0..face.len() {
            half.push((face[i], face[(i + 1) % face.len()]));
        }
    }
    let mut edges = Vec::new();
    let mut seen = std::collections::HashSet::new();
    for (u, v) in half {
        let key = if u < v { (u, v) } else { (v, u) };
        if seen.insert(key) {
            edges.push(key);
        }
    }
    edges
}