ANYsolver 0.1.0__py3-none-any.whl

anysolver/mass_properties.py

@@ -0,0 +1,179 @@
+"""Model mass properties and rigid-body inertia diagnostics."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Dict, List, Tuple
+
+import numpy as np
+
+from .elements import BeamElement, QuadraticBeamElement, ShellElement
+from .matrix_assembly import assemble_mass_matrix
+
+if TYPE_CHECKING:
+    from .fe_core import FEModel
+
+
+@dataclass
+class MassProperties:
+    """Integrated and assembled mass diagnostics for an FE model."""
+
+    total_mass: float
+    center_of_mass: np.ndarray
+    first_moment: np.ndarray
+    inertia_tensor_origin: np.ndarray
+    inertia_tensor_center_of_mass: np.ndarray
+    rigid_body_mass_matrix: np.ndarray
+    assembled_translation_masses: Dict[str, float]
+    num_mass_points: int
+    skipped_elements: List[int]
+    assembly_info: Dict[str, Any]
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "total_mass": float(self.total_mass),
+            "center_of_mass": self.center_of_mass.tolist(),
+            "first_moment": self.first_moment.tolist(),
+            "inertia_tensor_origin": self.inertia_tensor_origin.tolist(),
+            "inertia_tensor_center_of_mass": self.inertia_tensor_center_of_mass.tolist(),
+            "rigid_body_mass_matrix": self.rigid_body_mass_matrix.tolist(),
+            "assembled_translation_masses": dict(self.assembled_translation_masses),
+            "num_mass_points": int(self.num_mass_points),
+            "skipped_elements": [int(eid) for eid in self.skipped_elements],
+            "assembly_info": self.assembly_info,
+        }
+
+
+def _point_inertia(points: List[Tuple[float, np.ndarray]], reference: np.ndarray) -> np.ndarray:
+    inertia = np.zeros((3, 3), dtype=float)
+    eye = np.eye(3)
+    for mass, coords in points:
+        r = np.asarray(coords, dtype=float) - reference
+        inertia += float(mass) * ((float(r @ r) * eye) - np.outer(r, r))
+    return inertia
+
+
+def _rigid_body_modes(model: "FEModel", reference: np.ndarray) -> np.ndarray:
+    total_dofs = model.mesh.dof_manager.total_dofs
+    modes = np.zeros((total_dofs, 6), dtype=float)
+    for node in model.mesh.nodes.values():
+        x, y, z = node.coords() - reference
+        ux, uy, uz, rx, ry, rz = node.dofs[:6]
+        modes[ux, 0] = 1.0
+        modes[uy, 1] = 1.0
+        modes[uz, 2] = 1.0
+
+        modes[uy, 3] = -z
+        modes[uz, 3] = y
+        modes[rx, 3] = 1.0
+
+        modes[ux, 4] = z
+        modes[uz, 4] = -x
+        modes[ry, 4] = 1.0
+
+        modes[ux, 5] = -y
+        modes[uy, 5] = x
+        modes[rz, 5] = 1.0
+    return modes
+
+
+def _shell_mass_points(model: "FEModel", element: ShellElement) -> List[Tuple[float, np.ndarray]]:
+    material = model.get_material(element.material_name)
+    coords = element.get_node_coordinates(model.mesh)
+    points: List[Tuple[float, np.ndarray]] = []
+    for (xi, eta), weight in zip(element.gauss_points, element.gauss_weights):
+        N, dN_dxi, dN_deta = element.compute_shape_functions(float(xi), float(eta))
+        _, _, _, det_j = element._local_frame_and_derivatives(coords, dN_dxi, dN_deta)
+        mass = float(material.density) * float(element.thickness) * float(det_j) * float(weight)
+        points.append((mass, np.asarray(N @ coords, dtype=float)))
+    return points
+
+
+def _beam_mass_points(model: "FEModel", element: BeamElement) -> List[Tuple[float, np.ndarray]]:
+    material = model.get_material(element.material_name)
+    coords = element.get_node_coordinates(model.mesh)
+    if isinstance(element, QuadraticBeamElement):
+        length = float(np.linalg.norm(coords[2] - coords[0]))
+        points = []
+        for xi, weight in zip(element.GAUSS_POINTS, element.GAUSS_WEIGHTS):
+            N, _ = element.compute_shape_functions(float(xi))
+            mass = float(material.density) * float(element._A) * length / 2.0 * float(weight)
+            points.append((mass, np.asarray(N @ coords, dtype=float)))
+        return points
+    length = float(np.linalg.norm(coords[1] - coords[0]))
+    xi_values = (-1.0 / np.sqrt(3.0), 1.0 / np.sqrt(3.0))
+    points = []
+    for xi in xi_values:
+        N = np.array([(1.0 - xi) / 2.0, (1.0 + xi) / 2.0], dtype=float)
+        mass = float(material.density) * float(element._A) * length / 2.0
+        points.append((mass, np.asarray(N @ coords, dtype=float)))
+    return points
+
+
+def element_mass_points(model: "FEModel") -> Tuple[List[Tuple[float, np.ndarray]], List[int]]:
+    """Return quadrature mass points for elements with physical density."""
+    points: List[Tuple[float, np.ndarray]] = []
+    skipped: List[int] = []
+    for elem_id, element in model.mesh.elements.items():
+        try:
+            if isinstance(element, ShellElement):
+                points.extend(_shell_mass_points(model, element))
+            elif isinstance(element, BeamElement):
+                points.extend(_beam_mass_points(model, element))
+            else:
+                skipped.append(int(elem_id))
+        except Exception:
+            skipped.append(int(elem_id))
+    return points, skipped
+
+
+def calculate_mass_properties(model: "FEModel", reference_point: Any = None) -> MassProperties:
+    """Calculate integrated mass properties and assembled rigid-body mass.
+
+    The scalar mass, first moment and inertia tensors are obtained from
+    element quadrature plus model point masses.  The 6x6 rigid-body mass matrix
+    is additionally formed from the assembled mass matrix using rigid
+    translation/rotation fields, so shell and beam rotary inertia terms are
+    visible in diagnostics.
+    """
+    points, skipped = element_mass_points(model)
+    for node_id, mass in getattr(model.mesh, "point_masses", {}).items():
+        node = model.mesh.get_node(int(node_id))
+        if node is None:
+            raise ValueError(f"Point mass references missing node {node_id}")
+        mass_value = float(mass)
+        if not np.isfinite(mass_value) or mass_value < 0.0:
+            raise ValueError(f"Point mass at node {node_id} must be finite and non-negative")
+        if mass_value > 0.0:
+            points.append((mass_value, node.coords()))
+    total_mass = float(sum(mass for mass, _ in points))
+    first_moment = np.zeros(3, dtype=float)
+    for mass, coords in points:
+        first_moment += float(mass) * np.asarray(coords, dtype=float)
+    center = first_moment / total_mass if total_mass > 0.0 else np.zeros(3, dtype=float)
+    reference = center if reference_point is None else np.asarray(reference_point, dtype=float).reshape(3)
+
+    M, assembly_info = assemble_mass_matrix(model)
+    modes = _rigid_body_modes(model, reference)
+    rbm = np.asarray(modes.T @ (M @ modes), dtype=float)
+    tx = modes[:, 0]
+    ty = modes[:, 1]
+    tz = modes[:, 2]
+    assembled_translation_masses = {
+        "x": float(tx @ (M @ tx)),
+        "y": float(ty @ (M @ ty)),
+        "z": float(tz @ (M @ tz)),
+    }
+
+    return MassProperties(
+        total_mass=total_mass,
+        center_of_mass=center,
+        first_moment=first_moment,
+        inertia_tensor_origin=_point_inertia(points, np.zeros(3, dtype=float)),
+        inertia_tensor_center_of_mass=_point_inertia(points, center),
+        rigid_body_mass_matrix=rbm,
+        assembled_translation_masses=assembled_translation_masses,
+        num_mass_points=len(points),
+        skipped_elements=skipped,
+        assembly_info=assembly_info,
+    )

anysolver/material_curves.py

@@ -0,0 +1,231 @@
+"""Nonlinear material hardening curves.
+
+Implements the DNV-RP-C208 (September 2019, amended October 2022) section
+4.6.6 recommendation: the flow stress is a function of true plastic strain
+built from a stepwise linear part with a yield plateau and a power-law part:
+
+    Part 1:  sigma_prop  -> sigma_yield    over  0        .. eps_p_y1
+    Part 2:  sigma_yield -> sigma_yield_2  over  eps_p_y1 .. eps_p_y2
+    Part 3:  sigma = K * (eps_p + (sigma_yield_2 / K)**(1/n) - eps_p_y2)**n
+
+All evaluations are vectorized over numpy arrays of equivalent plastic
+strain, because the return mapping calls them for every integration point and
+thickness layer at once.
+
+The curve is expressed in true stress / true plastic strain exactly as
+tabulated by the RP; the solver consumes it directly as the J2 flow stress.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, Mapping, Optional
+
+import numpy as np
+
+
+_MPA = 1.0e6
+
+
+@dataclass(frozen=True)
+class FiberSectionPlasticityConfig:
+    """Opt-in beam fiber plasticity configuration.
+
+    The beam fiber model uses an equivalent rectangular fiber grid whose
+    coordinates are scaled to match the supplied section ``A``, ``Iy`` and
+    ``Iz``.  It is intended for monotonic capacity checks of beam/stiffener
+    idealizations; shear and torsion remain elastic in v1.
+    """
+
+    num_y: int = 5
+    num_z: int = 5
+    material_curve: Optional["DNVC208MaterialCurve"] = None
+
+    def __post_init__(self) -> None:
+        if self.num_y <= 0 or self.num_z <= 0:
+            raise ValueError("num_y and num_z must be positive")
+
+
+@dataclass(frozen=True)
+class DNVC208MaterialCurve:
+    """DNV-RP-C208 stepwise-linear plus power-law flow curve."""
+
+    sigma_prop: float
+    sigma_yield: float
+    sigma_yield_2: float
+    eps_p_y1: float
+    eps_p_y2: float
+    K: float
+    n: float
+
+    def __post_init__(self) -> None:
+        if self.sigma_prop <= 0.0:
+            raise ValueError("sigma_prop must be positive")
+        if self.sigma_yield < self.sigma_prop:
+            raise ValueError("sigma_yield must be >= sigma_prop")
+        if self.sigma_yield_2 < self.sigma_yield:
+            raise ValueError("sigma_yield_2 must be >= sigma_yield")
+        if not (0.0 < self.eps_p_y1 < self.eps_p_y2):
+            raise ValueError("require 0 < eps_p_y1 < eps_p_y2")
+        if self.K <= 0.0 or not (0.0 < self.n < 1.0):
+            raise ValueError("require K > 0 and 0 < n < 1")
+
+    @property
+    def _power_offset(self) -> float:
+        """Plastic-strain offset making Part 3 continuous at eps_p_y2."""
+        return (self.sigma_yield_2 / self.K) ** (1.0 / self.n) - self.eps_p_y2
+
+    def flow_stress(self, eps_p: np.ndarray) -> np.ndarray:
+        """Flow (yield) stress as a function of equivalent plastic strain."""
+        eps_p = np.maximum(np.asarray(eps_p, dtype=float), 0.0)
+        slope_1 = (self.sigma_yield - self.sigma_prop) / self.eps_p_y1
+        slope_2 = (self.sigma_yield_2 - self.sigma_yield) / (self.eps_p_y2 - self.eps_p_y1)
+        part_1 = self.sigma_prop + slope_1 * eps_p
+        part_2 = self.sigma_yield + slope_2 * (eps_p - self.eps_p_y1)
+        part_3 = self.K * np.power(np.maximum(eps_p + self._power_offset, 1.0e-12), self.n)
+        return np.where(
+            eps_p <= self.eps_p_y1,
+            part_1,
+            np.where(eps_p <= self.eps_p_y2, part_2, part_3),
+        )
+
+    def hardening_modulus(self, eps_p: np.ndarray) -> np.ndarray:
+        """d(flow stress)/d(equivalent plastic strain)."""
+        eps_p = np.maximum(np.asarray(eps_p, dtype=float), 0.0)
+        slope_1 = (self.sigma_yield - self.sigma_prop) / self.eps_p_y1
+        slope_2 = (self.sigma_yield_2 - self.sigma_yield) / (self.eps_p_y2 - self.eps_p_y1)
+        base = np.maximum(eps_p + self._power_offset, 1.0e-12)
+        slope_3 = self.K * self.n * np.power(base, self.n - 1.0)
+        return np.where(
+            eps_p <= self.eps_p_y1,
+            slope_1,
+            np.where(eps_p <= self.eps_p_y2, slope_2, slope_3),
+        )
+
+
+def curve_from_properties(properties: dict) -> DNVC208MaterialCurve:
+    """Build a curve from an RP-C208 table row (e.g. Table 4-2 .. 4-6)."""
+    return DNVC208MaterialCurve(
+        sigma_prop=float(properties["sigma_prop"]),
+        sigma_yield=float(properties["sigma_yield"]),
+        sigma_yield_2=float(properties["sigma_yield_2"]),
+        eps_p_y1=float(properties.get("eps_p_y1", 0.004)),
+        eps_p_y2=float(properties["eps_p_y2"]),
+        K=float(properties["K"]),
+        n=float(properties["n"]),
+    )
+
+
+_DNV_C208_LOW_FRACTILE_STEEL_MPA: Dict[str, tuple[tuple[float, float, Mapping[str, float]], ...]] = {
+    "S235": (
+        (0.0, 16.0, {"sigma_prop": 211.7, "sigma_yield": 236.2, "sigma_yield_2": 243.4, "eps_p_y2": 0.020, "K": 520.0, "n": 0.166}),
+        (16.0, 40.0, {"sigma_prop": 202.7, "sigma_yield": 226.1, "sigma_yield_2": 233.2, "eps_p_y2": 0.020, "K": 520.0, "n": 0.166}),
+        (40.0, 63.0, {"sigma_prop": 193.7, "sigma_yield": 216.1, "sigma_yield_2": 223.0, "eps_p_y2": 0.020, "K": 520.0, "n": 0.166}),
+        (63.0, 100.0, {"sigma_prop": 193.7, "sigma_yield": 216.1, "sigma_yield_2": 223.0, "eps_p_y2": 0.020, "K": 520.0, "n": 0.166}),
+    ),
+    "S275": (
+        (0.0, 16.0, {"sigma_prop": 247.8, "sigma_yield": 276.5, "sigma_yield_2": 282.8, "eps_p_y2": 0.017, "K": 620.0, "n": 0.166}),
+        (16.0, 40.0, {"sigma_prop": 238.8, "sigma_yield": 266.4, "sigma_yield_2": 272.6, "eps_p_y2": 0.017, "K": 620.0, "n": 0.166}),
+        (40.0, 63.0, {"sigma_prop": 229.8, "sigma_yield": 256.3, "sigma_yield_2": 262.4, "eps_p_y2": 0.017, "K": 620.0, "n": 0.166}),
+    ),
+    "S355": (
+        (0.0, 16.0, {"sigma_prop": 320.0, "sigma_yield": 357.0, "sigma_yield_2": 363.3, "eps_p_y2": 0.015, "K": 740.0, "n": 0.166}),
+        (16.0, 40.0, {"sigma_prop": 311.0, "sigma_yield": 346.9, "sigma_yield_2": 353.1, "eps_p_y2": 0.015, "K": 740.0, "n": 0.166}),
+        (40.0, 63.0, {"sigma_prop": 301.9, "sigma_yield": 336.9, "sigma_yield_2": 342.9, "eps_p_y2": 0.015, "K": 725.0, "n": 0.166}),
+        (63.0, 100.0, {"sigma_prop": 283.9, "sigma_yield": 316.7, "sigma_yield_2": 322.5, "eps_p_y2": 0.015, "K": 725.0, "n": 0.166}),
+    ),
+    "S420": (
+        (0.0, 16.0, {"sigma_prop": 378.7, "sigma_yield": 422.5, "sigma_yield_2": 427.6, "eps_p_y2": 0.012, "K": 738.0, "n": 0.140}),
+        (16.0, 40.0, {"sigma_prop": 360.6, "sigma_yield": 402.4, "sigma_yield_2": 407.3, "eps_p_y2": 0.012, "K": 703.0, "n": 0.140}),
+        (40.0, 63.0, {"sigma_prop": 351.6, "sigma_yield": 392.3, "sigma_yield_2": 397.1, "eps_p_y2": 0.012, "K": 686.0, "n": 0.140}),
+    ),
+    "S460": (
+        (0.0, 16.0, {"sigma_prop": 414.8, "sigma_yield": 462.8, "sigma_yield_2": 466.9, "eps_p_y2": 0.010, "K": 772.0, "n": 0.120}),
+        (16.0, 40.0, {"sigma_prop": 396.7, "sigma_yield": 442.7, "sigma_yield_2": 446.6, "eps_p_y2": 0.010, "K": 745.0, "n": 0.120}),
+        (40.0, 63.0, {"sigma_prop": 374.2, "sigma_yield": 417.5, "sigma_yield_2": 421.2, "eps_p_y2": 0.010, "K": 703.0, "n": 0.120}),
+    ),
+}
+
+
+def _thickness_class_label(lower_mm: float, upper_mm: float) -> str:
+    if lower_mm <= 0.0:
+        return f"t <= {upper_mm:g}"
+    return f"{lower_mm:g} < t <= {upper_mm:g}"
+
+
+def _normalized_thickness_class(value: str) -> str:
+    return str(value or "auto").strip().lower().replace(" ", "")
+
+
+def dnv_c208_steel_properties(
+    grade: str,
+    thickness: float,
+    thickness_class: str = "auto",
+    fractile: str = "low",
+) -> Dict[str, float | str]:
+    """Return one validated RP-C208 low-fractile steel table row in SI units.
+
+    ``thickness`` is in metres, matching solver SI units.  The built-in table
+    covers the RP-C208 low-fractile curves from section 4.6.6.  Mean curves are
+    intentionally not guessed; pass explicit properties through
+    ``curve_from_properties`` if mean data is required.
+
+    Automatic selection fails closed when the thickness is outside the table.
+    An explicit ``thickness_class`` may select a table row intentionally.
+    """
+    if fractile.lower() not in {"low", "low_fractile", "5%", "5_percent"}:
+        raise NotImplementedError("Built-in RP-C208 mean curves are not available; supply explicit curve properties")
+    grade_key = grade.upper().replace(" ", "")
+    if grade_key not in _DNV_C208_LOW_FRACTILE_STEEL_MPA:
+        raise ValueError(f"Unsupported RP-C208 steel grade {grade!r}; use one of {sorted(_DNV_C208_LOW_FRACTILE_STEEL_MPA)}")
+    thickness_mm = float(thickness) * 1000.0
+    if thickness_mm <= 0.0:
+        raise ValueError("thickness must be positive")
+    rows = _DNV_C208_LOW_FRACTILE_STEEL_MPA[grade_key]
+    selected: Optional[tuple[float, float, Mapping[str, float]]] = None
+    class_key = _normalized_thickness_class(thickness_class)
+    automatic = class_key in {"auto", "automatic", "bythickness", "autobyplatethickness"}
+    if automatic:
+        for row in rows:
+            lower, upper, _properties_mpa = row
+            if lower < thickness_mm <= upper:
+                selected = row
+                break
+        if selected is None:
+            raise ValueError(
+                f"Thickness {thickness_mm:g} mm is outside the built-in RP-C208 range "
+                f"for {grade_key} (maximum {rows[-1][1]:g} mm)"
+            )
+    else:
+        for row in rows:
+            lower, upper, _properties_mpa = row
+            if class_key == _normalized_thickness_class(_thickness_class_label(lower, upper)):
+                selected = row
+                break
+        if selected is None:
+            labels = [_thickness_class_label(lower, upper) for lower, upper, _properties in rows]
+            raise ValueError(f"Unsupported thickness_class {thickness_class!r} for {grade_key}; use one of {labels}")
+
+    lower, upper, selected_mpa = selected
+    properties = {
+        "grade": grade_key,
+        "thickness_class": _thickness_class_label(lower, upper),
+        "thickness_mm": thickness_mm,
+        "source": "DNV-RP-C208 section 4.6.6 low-fractile true stress-strain values",
+        "E_pa": 210_000.0 * _MPA,
+        "sigma_prop": float(selected_mpa["sigma_prop"]) * _MPA,
+        "sigma_yield": float(selected_mpa["sigma_yield"]) * _MPA,
+        "sigma_yield_2": float(selected_mpa["sigma_yield_2"]) * _MPA,
+        "eps_p_y1": float(selected_mpa.get("eps_p_y1", 0.004)),
+        "eps_p_y2": float(selected_mpa["eps_p_y2"]),
+        "K": float(selected_mpa["K"]) * _MPA,
+        "n": float(selected_mpa["n"]),
+    }
+    return properties
+
+
+def dnv_c208_steel_curve(grade: str, thickness: float, fractile: str = "low") -> DNVC208MaterialCurve:
+    """Return a validated RP-C208 steel curve for a grade and plate thickness."""
+
+    properties = dnv_c208_steel_properties(grade, thickness, fractile=fractile)
+    return curve_from_properties(properties)