Type Alias Domain3 

pub type Domain3 = Domain<SPATIAL_NDIM, SPATIAL_NDF, Node3Id, Element3>;

Domain’s spatial instantiation — six-DOF Node3/Element3. See Domain’s doc comment for why this is a type alias over one generic implementation rather than a hand-duplicated struct.

Aliased Type

pub struct Domain3 { /* private fields */ }

Implementations

impl Domain3

Spatial rigid diaphragm: for each node in constrained, ties its two in-plane translational dofs (the two coordinate axes other than normal) to retained’s same in-plane translations plus a lever-arm term from retained’s rotation about normal — a genuine general linear constraint (ConstraintHandler::Transformation), not a further identity alias like planar Domain::rigid_diaphragm (see its doc comment for why identity aliasing can’t express a real diaphragm’s lever-arm kinematics).

Deliberately narrower than Xara/OpenSees’s rigidDiaphragm: only the two in-plane translational dofs of each constrained node are tied. Every rotational dof of the constrained node — including its rotation about normal itself — and its out-of-plane translation are left completely free, unconstrained by this call. A floor diaphragm is rigid in its own plane; it doesn’t impose a shared rotation on whatever’s attached to it, and a linear frame model gives it no out-of-plane (vertical) stiffness of its own. This matches planar rigid_diaphragm’s existing scope (which likewise only ties translation, never rz), just generalized from “the one translational in-plane dof a 2D model has” to “the two a 3D diaphragm plane has, with the lever-arm term a real 3D diaphragm needs”.

Kinematics (small-rotation rigid-body motion in the plane perpendicular to normal, at retained node r, evaluated at constrained node c): with n̂ the unit normal and d = pos(c) - pos(r), a rotation theta_n about n̂ displaces c by theta_n * (n̂ × d). Writing a = (normal+1) % 3, b = (normal+2) % 3 for the other two axes (so (n, a, b) is a right-handed triad):

u_c[a] = u_r[a] - theta_r[normal] * (coord[b]_c - coord[b]_r)
u_c[b] = u_r[b] + theta_r[normal] * (coord[a]_c - coord[a]_r)

Cross-checked against Xara/OpenSees’s RigidDiaphragm constraint equations for the z-normal case (perpDirn = 3, their default: Ux_c = Ux_r - Rz_r*(Yc-Yr), Uy_c = Uy_r + Rz_r*(Xc-Xr)) — substituting normal = Z (a = X, b = Y) into the formula above reproduces exactly those two equations. Verified through the full Domain3/Analysis3 stack for rigid-rotation invariance and lever-arm displacement magnitude (core/tests/constraints/rigid_diaphragm_3d.rs), not just asserted by that cross-check.

Lever arms are computed once here, from each node’s fixed reference coords at the time this is called — not re-evaluated from current displacement, matching every other Linear/Linear3 (small- displacement) geometric transform’s scope in this crate.

Planar-only, in its own impl block: normal requires a full 3D coordinate/rotation set (Axis3, and a rotation-about-normal dof) that only the spatial profile’s Node3/SpatialDof provide.

pub fn rigid_diaphragm(&mut self, retained: Node3Id, constrained: &[Node3Id])

rigid_diaphragm_about with normal = Axis3::Y — the “up” axis in this crate’s y-up global convention, so the diaphragm plane is the horizontal x-z plane: the common case (an ordinary floor diaphragm).

pub fn rigid_diaphragm_about( &mut self, retained: Node3Id, constrained: &[Node3Id], normal: Axis3, )

rigid_diaphragm with an explicit diaphragm-plane normal — see this impl block’s doc comment for the kinematics and scope.

pub fn rigid_link(&mut self, master: Node3Id, slave: Node3Id)

Rigid link: slave moves with master as a rigid body. All six slave DOFs are tied: its rotations equal the master’s, and its translations equal the master’s plus the small-rotation lever arm, u_s = u_m + theta_m x d with d = pos(slave) - pos(master) taken from the reference coordinates at the time of the call. Joins, for example, a beam end to the edge of a shell, or an eccentric load point to the member it loads. Requires ConstraintHandler::Transformation.