From f89545a66a8c29d871d811b067b8dda86b97a7c6 Mon Sep 17 00:00:00 2001 From: jyviko <2501648+jyviko@users.noreply.github.com> Date: Wed, 14 Oct 2026 20:03:07 -0400 Subject: [PATCH] Engine: model.boundary_condition.symmetry on a datum plane A symmetry condition (zero normal displacement, zero rotation about the in-plane axes) on a datum plane normal to X, Y or Z, with its set given or made of the open design's faces on the plane (a partition's cut faces), so half a symmetric part is solved as a half. Half a 40 mm bar cut at its mid-width, with the condition and half the load, bends as the whole bar to 2e-12 with half the reaction. Inclined planes are refused as not supported yet. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01UhhZMBTviDQxZvwnyP89fo --- ROADMAP.md | 2 +- crates/engine/src/catalogue.rs | 2 +- crates/engine/src/cmd/forms.rs | 7 ++ crates/engine/src/cmd/mod.rs | 2 + crates/engine/src/cmd/symmetry.rs | 166 ++++++++++++++++++++++++++++++ docs/features.md | 2 +- 6 files changed, 178 insertions(+), 3 deletions(-) create mode 100644 crates/engine/src/cmd/symmetry.rs diff --git a/ROADMAP.md b/ROADMAP.md index 25309ce..44619b5 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -31,7 +31,7 @@ pressure) is a degree of freedom of the existing DOF framework, not a separate s | M2 Tet meshing and size field | Size field (global, per face and edge seeds, curvature and proximity; the `fieldcraft_mesh::size::SizeField` trait and edge-division helpers are in); Bowyer–Watson Delaunay (exact, symbolic perturbation, verified; `fieldcraft-mesh::delaunay`, done); robust CDT boundary recovery (Diazzi et al. 2023: implicit LNC Steiner points on segments, gift-wrapping facet recovery, inside/outside labelling, B-rep face tags on boundary tet faces, flip repair of rounding (§5.1) checked by the validity gate; `fieldcraft-mesh::cdt` and `mesh.tet.generate`, done: all 20 valid corpus parts); quality stage (done: `fieldcraft-mesh::tet` — curvature-graded size field, edge-collapse coarsening, constrained Delaunay refinement with boundary points on the B-rep faces and curves, ODT smoothing, Klingner–Shewchuk improvement, tet4 and tet10 with mid-side nodes on the B-rep, quality report; one validity criterion shared by the gate and both solvers; the filleted-bracket fillet stress converges, tests/oracle); mesh verify per set | in progress | | M3 First deck | Sets and surfaces bound to SolidCraft face, edge, vertex and body names, resolved after meshing; materials (isotropic and orthotropic elastic, density) with a unit-system label and consistency check; sections (solid, shell, beam profiles) assigned by set; element formulation per region mapped to each solver; BCs (fixed, displacement, symmetry); loads (force and moment on reference points, pressure, gravity); reference points with kinematic and distributing coupling; steps (linear static, frequency) with explicit per-step load and BC tables and output presets; `model.check` naming every missing or bad item; `model.*` and `mesh.tag` commands (model definition: done); writers for Abaqus input (done: `deck.write`), Nastran SOL 101/103 (done: `deck.write`) and LS-DYNA implicit (done); the `.fieldcraft` file (text definition, binary mesh, geometry references reopened on load, journal; atomic saves, autosave and recovery; undo/redo on the journal: done) | in progress | | M4 Own solver and first results | Element library per docs/elements.md (1D and 2D first); Linear static and modal solver (tet4/10, wedge6, hex8, hex20; sparse direct, Lanczos), verified against analytic solutions (solver: done — `fieldcraft-fem` kernels, `fieldcraft-solver` with nested dissection, sparse Cholesky and block Lanczos, `solve.static`/`solve.frequency`/`solve.probe`, patch, cantilever, Lamé, Kirsch and beam-frequency tests; reference points with kinematic and distributing couplings and moments by master–slave constraint elimination, verified by rigid motion, clamping, Saint-Venant tension, bending and tube torsion; 1D elements I: rod2/rod3 trusses, point masses, rotary inertia, springs and dashpots in both solvers and all three decks, verified by the method of joints, the three-bar truss, spring–mass, two-mass chain and torsional pendulum frequencies, and damped decay; 2D elements: plane stress, plane strain and axisymmetric tri3, tri6, quad4 (incompatible modes QM6), quad8 with two degrees of freedom per node, centrifugal loads, `mesh.planar` 2D meshes of polygons and planar faces, verified by patch tests, Kirsch, Lamé (plane strain and axisymmetric), rotating discs and cylinders, and a plane stress cantilever; deck mapping to Abaqus CPS/CPE/CAX, Nastran membranes, LS-DYNA ELFORM 12/13); shells and beams (done: quad4 MITC4 and tri3 MITC3 flat shells with a Hughes–Brezzi drilling rotation, two-node Timoshenko beams with profile properties and orientations, six degrees of freedom at shell and beam nodes shared with solids and trusses, section forces and surface stresses, verified by shell patch tests, Navier's plate, cantilever and portal-frame beams, and the Scordelis–Lo and pinched-cylinder benchmarks); results display (done: `results.*` commands, deformed shape to scale, banded contours of displacement, von Mises, principal and component stresses with a legend, mode shapes with their frequencies and animation, probing a node by clicking it, reaction force and moment sums per set, stale results marked after an edit; explicit steps: field frames by slider or animation with contours per frame, energy histories plotted) | started | -| M5 Structured hex | 2D quad meshing of faces (`fieldcraft-mesh::quad`: transfinite mapped meshes, free all-quad meshes of polygons with holes on prescribed boundary nodes, exact planar quad validity, shared `SizeField` and even edge divisions; done for planar faces); mapped hex of six-sided regions (trivariate TFI, curved faces) and sweep meshing (multi-level extrusions with imprinted cross-sections, revolutions, one-to-one sweeps through linking faces; interval assignment, hex8/hex20 on the geometry, B-rep face tags, `mesh.hex.generate`/`sweep`/`mapped`: done, 16 of 21 corpus parts all-hex); conforming interfaces between cells (done: `mesh.hex.blocks` meshes a part split with SolidCraft's Split Body into mapped blocks as one conforming mesh — composite faces for seams and tangent faces, interval assignment over all cells, shared faces meshed once, grading off holes and fillets, free-internal-face check; the filleted bracket in 30 cells, hex20 within 0.1 % of a fine tet10 tip deflection); partitions inside FieldCraft (done: datum planes and axes, `geometry.partition` cuts the open design by a datum plane, kept in the model and replayed when the design opens, the two faces of each cut paired by name); cells meshed each with its own method into one mesh (done: `mesh.cells` — hex where a method fits, else tet; matching interfaces merged node for node, others, such as hex next to tet, tied by dual mortar, verified by a tied hex–tet bar in tension to 1e-6); meshing half a symmetric part and mirroring it (done: `mesh.mirror` reflects hex8/hex20/tet4/tet10/wedge6 across a datum plane, right-handed, nodes on the plane merged, tags carried to the image half; a mirrored half bar equals the whole bar's mesh and bending deflection to 1e-12); pyramid transitions; automatic decomposition into sweepable and mappable regions, proposed as SolidCraft splits | started | +| M5 Structured hex | 2D quad meshing of faces (`fieldcraft-mesh::quad`: transfinite mapped meshes, free all-quad meshes of polygons with holes on prescribed boundary nodes, exact planar quad validity, shared `SizeField` and even edge divisions; done for planar faces); mapped hex of six-sided regions (trivariate TFI, curved faces) and sweep meshing (multi-level extrusions with imprinted cross-sections, revolutions, one-to-one sweeps through linking faces; interval assignment, hex8/hex20 on the geometry, B-rep face tags, `mesh.hex.generate`/`sweep`/`mapped`: done, 16 of 21 corpus parts all-hex); conforming interfaces between cells (done: `mesh.hex.blocks` meshes a part split with SolidCraft's Split Body into mapped blocks as one conforming mesh — composite faces for seams and tangent faces, interval assignment over all cells, shared faces meshed once, grading off holes and fillets, free-internal-face check; the filleted bracket in 30 cells, hex20 within 0.1 % of a fine tet10 tip deflection); partitions inside FieldCraft (done: datum planes and axes, `geometry.partition` cuts the open design by a datum plane, kept in the model and replayed when the design opens, the two faces of each cut paired by name); cells meshed each with its own method into one mesh (done: `mesh.cells` — hex where a method fits, else tet; matching interfaces merged node for node, others, such as hex next to tet, tied by dual mortar, verified by a tied hex–tet bar in tension to 1e-6); meshing half a symmetric part and mirroring it (done: `mesh.mirror` reflects hex8/hex20/tet4/tet10/wedge6 across a datum plane, right-handed, nodes on the plane merged, tags carried to the image half; a mirrored half bar equals the whole bar's mesh and bending deflection to 1e-12; or solving the half: `model.boundary_condition.symmetry` on a datum plane, a half bar with half the load bends as the whole to 1e-11); pyramid transitions; automatic decomposition into sweepable and mappable regions, proposed as SolidCraft splits | started | | M6 Automatic hex | Octree/grid all-hex for any part (first version: done — `fieldcraft-mesh::octree`, `mesh.hex.octree`: 3-refinement grid with conforming templates refined by curvature, thickness and narrow faces, a core cleared to a manifold boundary, feature map onto it, padding and a pillow per patch capturing every sharp curve, foldover-free fitting, certified validity, B-rep face tags; the corpus hex column and the filleted-bracket oracle case; next: transitions for concave refined regions so thin and curved parts stop over-refining); hex-dominant by tet recombination; polycube for blocky parts; layers through thin walls; mesh editing and orphan-mesh import | started | | M7 Assemblies, contact and friction | Needs M15. Part instances from SolidCraft occurrences; tie between non-matching meshes (mortar: done — `interaction.tie`, dual mortar constraints in the implicit analyses, Abaqus `*TIE` and LS-DYNA tied contact, the tie patch test); implicit contact: surface-to-surface mortar and node-to-surface, penalty and augmented Lagrange, self-contact, automatic pair detection (mortar contact pairs with Coulomb friction in nonlinear static steps: done — segment-to-segment mortar with the consistent tangent by automatic differentiation of the segmentation, augmented Lagrangian with Uzawa updates to a gap tolerance, semismooth active set with a chattering cutback, small sliding without nonlinear geometry and finite sliding with it, overclosure adjusted or refused, Coulomb friction (stick/slip return map, static and kinetic coefficients, symmetrised tangent), pressure, gap, status, shear and slip output; verified by the contact patch test, Hertz cylinder and sphere, Newton's quadratic rate and sliding blocks; the linear analyses refuse contact by name); friction: Coulomb with stick–slip, static/kinetic, anisotropic, pressure-, rate- and temperature-dependent coefficients; contact output (pressure, slip, status); thermal contact conductance and frictional heating; wear (Archard); bolt pretension, connectors with behaviour (elastic, damped, stops, locks); amplitudes, multiple steps, restart; nonlinear steps in all three decks. Verified by Hertz (sphere and cylinder), the Cattaneo–Mindlin partial-slip problem, the sliding block, NAFEMS contact benchmarks | started | | M8 Materials, explicit, shells, composites | Plasticity, hyperelasticity, damage data per solver; explicit dynamics decks (Abaqus/Explicit, LS-DYNA); midsurface shells; composite layups and material orientations, continuum shells on swept hex; hybrid (mixed u–p) hex8/hex20/tet10 for nearly incompressible materials (done); heat transfer (solids done: steady and θ-method transient conduction with flux, convection and sources, thermal strain in static steps (solids and 2D) and explicit dynamics (with plasticity), coupled temperature–displacement, `solve.heat`; deck output, 2D/shell/beam conduction planned) | started | diff --git a/crates/engine/src/catalogue.rs b/crates/engine/src/catalogue.rs index b24c817..4cf34f2 100644 --- a/crates/engine/src/catalogue.rs +++ b/crates/engine/src/catalogue.rs @@ -387,7 +387,7 @@ pub static CATALOGUE: &[Capability] = &[ Loads, "Boundary Conditions", "Fixed, displacement or symmetry condition on a set or reference point", - &["model.boundary_condition.edit", "model.boundary_condition.delete"], + &["model.boundary_condition.edit", "model.boundary_condition.delete", "model.boundary_condition.symmetry"], ), ready_more( "model.load.create", diff --git a/crates/engine/src/cmd/forms.rs b/crates/engine/src/cmd/forms.rs index 1115830..fad8f90 100644 --- a/crates/engine/src/cmd/forms.rs +++ b/crates/engine/src/cmd/forms.rs @@ -716,6 +716,13 @@ pub const MIRROR: &[Field] = &[ json("as", "Images").hint(r#"{"body": "image body"}; default: the design's body at the reflected place"#), ]; +pub const SYMMETRY: &[Field] = &[ + NAME, + reference("datum", "Datum plane", C::DatumPlane).req(), + reference("set", "Set", C::Set).hint("the faces of the design on the plane"), + references("bodies", "Bodies", C::Body).hint("every body"), +]; + pub const HEX_OCTREE: &[Field] = &[ BODY, SURFACE, diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd/mod.rs index e95aa27..d0c0f12 100644 --- a/crates/engine/src/cmd/mod.rs +++ b/crates/engine/src/cmd/mod.rs @@ -19,6 +19,7 @@ mod model; pub(crate) mod octree; mod results; pub(crate) mod solve; +mod symmetry; mod tags; use fieldcraft_model::MAX_LABEL; @@ -96,6 +97,7 @@ pub static ALL: &[CommandSpec] = &[ define::BOUNDARY_CONDITION_CREATE, define::BOUNDARY_CONDITION_EDIT, define::BOUNDARY_CONDITION_DELETE, + symmetry::SYMMETRY, define::LOAD_CREATE, define::LOAD_EDIT, define::LOAD_DELETE, diff --git a/crates/engine/src/cmd/symmetry.rs b/crates/engine/src/cmd/symmetry.rs new file mode 100644 index 0000000..5694255 --- /dev/null +++ b/crates/engine/src/cmd/symmetry.rs @@ -0,0 +1,166 @@ +//! `model.boundary_condition.symmetry`: a symmetry condition on a datum plane, so half of a +//! symmetric part can be solved as a half. +//! +//! The condition holds the displacement normal to the plane, and the rotations about the two +//! axes in it, at zero (`type: "symmetry"`). Its set is given, or made of the faces of the open +//! design's bodies that lie on the plane (the cut faces of a partition by that datum, `partition: +//! :a|b`), so it follows the geometry through a remesh. + +use fieldcraft_geometry::FaceSurface; +use fieldcraft_model::{BoundaryCondition, GeometryRef, Set, Symmetry, Target}; +use serde_json::{Value, json}; + +use crate::requirement::Requirement; +use crate::{CommandKind, CommandSpec, EngineError, Result, Session}; + +pub const SYMMETRY: CommandSpec = CommandSpec { + id: "model.boundary_condition.symmetry", + label: "Symmetry Plane", + params: r#"{"name": "Sym", "datum": "Mid" (a datum plane normal to X, Y or Z), "set"?: "cut" (default: a new set of the same name holding every face of the open design's bodies on the plane, e.g. a partition's cut faces), "bodies"?: ["Part/a"] (only their faces)} — a symmetry boundary condition on the plane: zero displacement normal to it and zero rotation about the axes in it, so half a symmetric part (loaded symmetrically, with half the load) is solved as a half. Add it to the steps (model.step.activate). Planes not normal to X, Y or Z are not supported yet"#, + form: Some(super::forms::SYMMETRY), + kind: CommandKind::Model, + requires: &[Requirement::DatumPlane], + run: symmetry, +}; + +/// A face lies on the plane within this fraction of its body's size. +const ON_PLANE: f64 = 1e-6; + +fn symmetry(s: &mut Session, p: &Value) -> Result { + let name = super::name(p)?.to_string(); + let datum: String = super::req(p, "datum")?; + let (point, normal) = s + .model + .datum(&datum) + .and_then(|d| d.plane()) + .ok_or_else(|| EngineError::Params(format!("no datum plane `{}`", datum.chars().take(64).collect::())))?; + let axis = (0..3).find(|&k| (normal[k].abs() - 1.0).abs() < 1e-9).ok_or_else(|| { + EngineError::Params(format!("not supported yet: symmetry about a plane not normal to X, Y or Z (datum `{datum}` has normal {normal:?})")) + })?; + let plane = [Symmetry::X, Symmetry::Y, Symmetry::Z][axis]; + let set = match p.get("set") { + Some(_) => super::req::(p, "set")?, + None => { + let only: Option> = super::opt(p, "bodies")?; + let design = + s.design.as_deref().ok_or_else(|| EngineError::Params("open a design to find the faces on the plane, or give `set`".into()))?; + let mut faces = Vec::new(); + for b in &design.bodies { + if only.as_ref().is_some_and(|o| !o.contains(&b.name)) { + continue; + } + let tol = ON_PLANE * b.size()?.max(1.0); + for (f, surface) in b.faces().iter().zip(b.face_surfaces()?) { + if let Some(FaceSurface::Plane { normal: m, point: q }) = surface { + let parallel = (m[axis].abs() - 1.0).abs() < 1e-9; + if parallel && (q[axis] - point[axis]).abs() < tol { + faces.push(GeometryRef::face(b.name.as_str(), f.name.as_str())?); + } + } + } + } + if faces.is_empty() { + return Err(EngineError::Params(format!("no face of the design lies on datum `{datum}`: partition by it first, or give `set`"))); + } + s.model.add_set(&name, Set::of_geometry(faces))?; + name.clone() + } + }; + s.model.add_boundary_condition(&name, BoundaryCondition::Symmetry { target: Target::Set(set.clone()), plane })?; + let faces = s.model.set(&set).map_or(0, |x| x.geometry.len()); + let axis_name = ["x", "y", "z"].get(axis).copied().unwrap_or("x"); + Ok(json!({"name": name, "set": set, "plane": axis_name, "faces": faces})) +} + +#[cfg(test)] +mod tests { + use super::*; + + /// A 40 × 10 × 10 bar along x (0..40, 0..10, 0..10), the datum `Mid` at y = 5. + fn bar(half: bool) -> (crate::tests::TempDir, Session) { + let commands = json!({"commands": [ + {"command": "solid.box", "params": {"length": 40, "width": 10, "height": 10, "body_name": "Bar"}}, + ]}); + let bytes = fieldcraft_geometry::script_design(&commands.to_string()).unwrap(); + let (dir, path) = crate::tests::design_file(&bytes); + let mut s = Session::default(); + s.execute("geometry.open", &json!({"path": path})).unwrap(); + s.execute("geometry.datum", &json!({"name": "Mid", "by": {"type": "offset", "plane": "zx", "offset": 5}})).unwrap(); + if half { + s.execute("geometry.partition", &json!({"name": "Half", "datum": "Mid"})).unwrap(); + } + (dir, s) + } + + fn face(s: &Session, body: &str, point: [f64; 3]) -> String { + let shape = s.design.as_ref().unwrap().body(body).unwrap(); + let f = shape.nearest_faces(&[point], 0.01).unwrap()[0].unwrap(); + shape.faces()[f as usize].name.clone() + } + + /// Clamp the x = 0 end and push the x = 40 end down (−z) with `force`, solve, and give the + /// largest downward tip deflection and the clamp's reaction. + fn bend(s: &mut Session, body: &str, force: f64, extra: &[&str]) -> (f64, f64) { + let (root, tip) = (face(s, body, [0.0, 2.5, 5.0]), face(s, body, [40.0, 2.5, 5.0])); + let mut bcs = vec!["Clamp".to_string()]; + bcs.extend(extra.iter().map(|x| x.to_string())); + let script = json!([ + {"command": "model.set.create", "params": {"name": "all", "geometry": [{"body": body}]}}, + {"command": "model.set.create", "params": {"name": "root", "geometry": [{"body": body, "face": root}]}}, + {"command": "model.set.create", "params": {"name": "tip", "geometry": [{"body": body, "face": tip}]}}, + {"command": "model.material.create", "params": {"name": "Steel", "elastic": {"type": "isotropic", "young": 210000, "poisson": 0.3}}}, + {"command": "model.section.create", "params": {"name": "Bar", "set": "all", "material": "Steel", "kind": {"type": "solid"}}}, + {"command": "model.boundary_condition.create", "params": {"name": "Clamp", "type": "fixed", "target": {"set": "root"}}}, + {"command": "model.load.create", "params": {"name": "Push", "type": "force", "target": {"set": "tip"}, "vector": [0, 0, -force]}}, + {"command": "model.step.create", "params": {"name": "Load", "procedure": {"type": "static"}, "boundary_conditions": bcs, "loads": ["Push"]}}, + ]); + s.run_script(&script).unwrap(); + s.execute("solve.static", &json!({})).unwrap(); + let tip = s.model.resolve_set("tip").unwrap().nodes; + let probe = s.execute("solve.probe", &json!({"step": "Load", "nodes": tip})).unwrap(); + let w = probe["nodes"].as_array().unwrap().iter().map(|n| -n["displacement"][2].as_f64().unwrap()).fold(f64::MIN, f64::max); + let r = s.execute("results.reactions", &json!({"step": "Load", "sets": ["root"]})).unwrap(); + (w, r["sets"][0]["force"][2].as_f64().unwrap_or(f64::NAN)) + } + + /// Half the bar, cut on its symmetry plane y = 5, with the symmetry condition and half the + /// load, bends as the whole bar does: the same deflection, half the reaction. + #[test] + fn a_half_model_with_symmetry_matches_the_whole() { + let (_d1, mut whole) = bar(false); + whole.execute("mesh.hex.mapped", &json!({"body": "Bar", "size": 2.5, "order": 2})).unwrap(); + let full = bend(&mut whole, "Bar", 1000.0, &[]); + + let (_d2, mut half) = bar(true); + half.execute("mesh.hex.mapped", &json!({"body": "Bar/a", "size": 2.5, "order": 2})).unwrap(); + let r = half.execute("model.boundary_condition.symmetry", &json!({"name": "Sym", "datum": "Mid", "bodies": ["Bar/a"]})).unwrap(); + assert_eq!(r, json!({"name": "Sym", "set": "Sym", "plane": "y", "faces": 1})); + assert_eq!(half.model.set("Sym").unwrap().geometry[0].entity, fieldcraft_model::geometry::Entity::Face("partition:Half:a".into())); + let halved = bend(&mut half, "Bar/a", 500.0, &["Sym"]); + assert!((halved.0 - full.0).abs() < 1e-9 * full.0, "deflection {} vs {}", halved.0, full.0); + assert!((2.0 * halved.1 - full.1).abs() < 1e-9 * full.1.abs(), "reaction {} vs {}", halved.1, full.1); + } + + #[test] + fn inclined_planes_and_hostile_params_change_nothing() { + let (_d, mut s) = bar(true); + s.execute("geometry.datum", &json!({"name": "Tilt", "by": {"type": "point_normal", "point": [0, 0, 0], "normal": [1, 1, 0]}})).unwrap(); + s.execute("geometry.datum", &json!({"name": "Out", "by": {"type": "offset", "plane": "xy", "offset": 100}})).unwrap(); + s.execute("geometry.datum.axis", &json!({"name": "Ax", "by": {"type": "principal", "axis": "x"}})).unwrap(); + let model = s.model.clone(); + let e = s.execute("model.boundary_condition.symmetry", &json!({"name": "S", "datum": "Tilt"})).unwrap_err(); + assert!(e.to_string().contains("not supported yet"), "{e}"); + for p in [ + json!({"name": "S", "datum": "Out"}), + json!({"name": "S", "datum": "Ax"}), + json!({"name": "S", "datum": "Nope"}), + json!({"name": "S", "datum": "Mid", "set": "nope"}), + json!({"name": "S", "datum": "Mid", "bodies": ["Nope"]}), + json!({"name": "1S", "datum": "Mid"}), + json!({"datum": "Mid"}), + ] { + assert!(s.execute("model.boundary_condition.symmetry", &p).is_err(), "{p}"); + } + assert_eq!(s.model, model); + } +} diff --git a/docs/features.md b/docs/features.md index b711ca4..d360f1d 100644 --- a/docs/features.md +++ b/docs/features.md @@ -91,7 +91,7 @@ the control channel and AI agents over MCP (docs/mcp.md) run the same commands. | Panel | Capability | Status | Command | |---|---|---|---| -| Boundary Conditions | Boundary Condition — Fixed, displacement or symmetry condition on a set or reference point | ready | `model.boundary_condition.create`, `model.boundary_condition.edit`, `model.boundary_condition.delete` | +| Boundary Conditions | Boundary Condition — Fixed, displacement or symmetry condition on a set or reference point | ready | `model.boundary_condition.create`, `model.boundary_condition.edit`, `model.boundary_condition.delete`, `model.boundary_condition.symmetry` | | Loads | Load — Force, moment, pressure, traction, gravity or body force | ready | `model.load.create`, `model.load.edit`, `model.load.delete` | | Flow | Fluid Domain — The box of fluid cells, its fluid, and the obstacle bodies voxelised from their face-tagged surfaces | ready | `model.fluid_domain.create`, `model.fluid_domain.edit`, `model.fluid_domain.delete` | | Flow | Inlet & Outlet — Velocity inlets, pressure outlets, walls, moving and slip walls, periodic faces | ready | `model.fluid_domain.boundary` |