nusa 0.4.0__py3-none-any.whl

nusa/__init__.py

@@ -0,0 +1,57 @@
+"""NuSA: Numerical Structural Analysis in Python."""
+
+from .version import __version__
+from .analysis import LinearStaticAnalysis, solve
+from .result import StaticResult
+from .reporting import simple_report
+from .post import element_field, nodal_field
+from .visualization import (
+    plot_model,
+    plot_deformed_shape,
+    plot_element_field,
+    plot_moment_diagram,
+    plot_nodal_field,
+    plot_shear_diagram,
+)
+from .node import Node
+from .element import Bar, Beam, Element, LinearTriangle, Spring, Truss
+from .model import (
+    Model,
+    BarModel,
+    BeamModel,
+    LinearTriangleModel,
+    SpringModel,
+    TrussModel,
+)
+
+__author__ = "P.J. De Los Santos"
+__email__ = "delossantosmfq@gmail.com"
+
+__all__ = [
+    "__version__",
+    "solve",
+    "LinearStaticAnalysis",
+    "StaticResult",
+    "simple_report",
+    "element_field",
+    "nodal_field",
+    "plot_model",
+    "plot_deformed_shape",
+    "plot_nodal_field",
+    "plot_element_field",
+    "plot_moment_diagram",
+    "plot_shear_diagram",
+    "Model",
+    "Element",
+    "Node",
+    "Spring",
+    "Bar",
+    "Truss",
+    "Beam",
+    "LinearTriangle",
+    "SpringModel",
+    "BarModel",
+    "TrussModel",
+    "BeamModel",
+    "LinearTriangleModel",
+]

nusa/_mesh.py

@@ -0,0 +1,174 @@
+# ***********************************
+#  Author: Pedro Jorge De Los Santos
+#  E-mail: delossantosmfq@gmail.com
+#  Blog: numython.github.io
+#  License: MIT License
+# ***********************************
+
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import tempfile
+
+import numpy as np
+
+
+def _resolve_gmsh_command(gmsh_executable, arguments, *, windows=None):
+    """Resolve Gmsh and wrap Windows batch launchers when needed."""
+    resolved = shutil.which(gmsh_executable)
+    if resolved is None:
+        raise RuntimeError(
+            f"Gmsh executable {gmsh_executable!r} was not found on PATH. "
+            "Install Gmsh, verify it with 'gmsh --version', or pass an "
+            "explicit path with gmsh_executable=..."
+        )
+
+    if windows is None:
+        windows = os.name == "nt"
+
+    if windows and resolved.lower().endswith((".bat", ".cmd")):
+        return [
+            os.environ.get("COMSPEC", "cmd.exe"),
+            "/d",
+            "/c",
+            resolved,
+            *arguments,
+        ]
+
+    return [resolved, *arguments]
+
+
+def _load_meshio():
+    try:
+        import meshio
+    except ModuleNotFoundError as exc:
+        raise ModuleNotFoundError(
+            "NuSA mesh utilities require meshio, which is a default NuSA "
+            "dependency. Reinstall NuSA or install meshio explicitly."
+        ) from exc
+    return meshio
+
+
+def read_triangle_mesh(filename):
+    """Read mesh points and triangular connectivity with meshio."""
+    meshio = _load_meshio()
+    mesh = meshio.read(filename)
+
+    try:
+        triangles = np.asarray(mesh.cells_dict["triangle"], dtype=int)
+    except KeyError as exc:
+        raise ValueError(
+            f"Mesh file {str(filename)!r} does not contain triangle cells"
+        ) from exc
+
+    used_points = np.unique(triangles)
+    remap = np.full(len(mesh.points), -1, dtype=int)
+    remap[used_points] = np.arange(len(used_points), dtype=int)
+
+    points = np.asarray(mesh.points)[used_points]
+    triangles = remap[triangles]
+    return points, triangles
+
+
+class SimpleGMSH:
+    """Minimal Gmsh .geo builder used by :class:`nusa.mesh.Modeler`."""
+
+    def __init__(self):
+        self.ID_POINT = 0
+        self.ID_LINE = 0
+        self.ID_CIRCLE = 10000
+        self.ID_LINE_LOOP = 0
+        self.ID_PLANE_SURFACE = 0
+        self.GMSH_CODE = []
+
+    def add_point(self, coords, esize=0.1):
+        self.ID_POINT += 1
+        x, y = coords[0], coords[1]
+        name = str(self.ID_POINT)
+        self.GMSH_CODE.append(
+            f"Point({name}) = {{ {x},{y},0,{esize} }};"
+        )
+        return name
+
+    def add_line(self, p0, p1):
+        self.ID_LINE += 1
+        name = str(self.ID_LINE)
+        self.GMSH_CODE.append(f"Line({name}) = {{ {p0},{p1} }};")
+        return name
+
+    def add_circle_arc(self, center, start, end):
+        self.ID_CIRCLE += 1
+        name = str(self.ID_CIRCLE)
+        self.GMSH_CODE.append(
+            f"Circle({name}) = {{ {start},{center},{end} }};"
+        )
+        return name
+
+    def add_line_loop(self, *lines):
+        self.ID_LINE_LOOP += 1
+        name = str(self.ID_LINE_LOOP)
+        self.GMSH_CODE.append(
+            f"Line Loop({name}) = {{{','.join(lines)}}};"
+        )
+        return name
+
+    def add_plane_surface(self, *loops):
+        self.ID_PLANE_SURFACE += 1
+        name = str(self.ID_PLANE_SURFACE)
+        self.GMSH_CODE.append(
+            f"Plane Surface({name}) = {{{','.join(loops)}}};"
+        )
+        return name
+
+    def delete_surfaces(self, *surfaces):
+        self.GMSH_CODE.append(
+            f"Delete {{ Surface{{ {','.join(surfaces)} }}; }}"
+        )
+
+    def get_code(self):
+        return "\n".join(self.GMSH_CODE)
+
+    def generate_mesh(self, verbose=False, gmsh_executable="gmsh"):
+        """Generate a 2D triangular mesh using the external Gmsh executable."""
+        with tempfile.TemporaryDirectory(prefix="nusa-gmsh-") as tmpdir:
+            tmpdir = Path(tmpdir)
+            geo_path = tmpdir / "model.geo"
+            msh_path = tmpdir / "model.msh"
+            geo_path.write_text(self.get_code(), encoding="utf-8")
+
+            arguments = [
+                "-2",
+                str(geo_path),
+                "-format",
+                "msh2",
+                "-o",
+                str(msh_path),
+            ]
+            command = _resolve_gmsh_command(gmsh_executable, arguments)
+
+            try:
+                result = subprocess.run(
+                    command,
+                    check=True,
+                    text=True,
+                    capture_output=not verbose,
+                )
+            except FileNotFoundError as exc:
+                raise RuntimeError(
+                    f"Gmsh command {command[0]!r} could not be started"
+                ) from exc
+            except subprocess.CalledProcessError as exc:
+                details = (exc.stderr or exc.stdout or "").strip()
+                message = "Gmsh failed while generating the 2D mesh"
+                if details:
+                    message += f": {details}"
+                raise RuntimeError(message) from exc
+
+            if verbose and result.stdout:
+                print(result.stdout, end="")
+
+            if not msh_path.exists():
+                raise RuntimeError("Gmsh completed without creating a mesh file")
+
+            return read_triangle_mesh(msh_path)

nusa/analysis.py

@@ -0,0 +1,131 @@
+"""Linear-static finite-element analysis orchestration."""
+
+from __future__ import annotations
+
+import numpy as np
+
+from .model import Model
+from .result import StaticResult
+
+
+def _element_dof_indices(model, element):
+    indices = []
+    for node in element.nodes:
+        node_index = model._get_node_index(node)
+        base = model.dof * node_index
+        indices.extend(base + component for component in range(model.dof))
+    return indices
+
+
+def _assemble_stiffness(model):
+    model._validate_topology()
+    size = model.dof * model.n_nodes
+    stiffness = np.zeros((size, size), dtype=float)
+
+    for element in model.elements:
+        element_stiffness = np.asarray(
+            element.get_element_stiffness(), dtype=float
+        )
+        indices = _element_dof_indices(model, element)
+        stiffness[np.ix_(indices, indices)] += element_stiffness
+
+    return stiffness
+
+
+def _partition_system(stiffness, loads, prescribed):
+    prescribed_dofs = np.flatnonzero(~np.isnan(prescribed))
+    free_dofs = np.flatnonzero(np.isnan(prescribed))
+
+    reduced = stiffness[np.ix_(free_dofs, free_dofs)]
+    rhs = loads[free_dofs].copy()
+
+    if prescribed_dofs.size:
+        coupling = stiffness[np.ix_(free_dofs, prescribed_dofs)]
+        rhs -= coupling @ prescribed[prescribed_dofs]
+
+    return prescribed_dofs, free_dofs, reduced, rhs
+
+
+class LinearStaticAnalysis:
+    """Perform a small-displacement linear-static finite-element analysis."""
+
+    def solve(self, model):
+        """Solve *model* and return an independent :class:`StaticResult`."""
+        if not isinstance(model, Model):
+            raise TypeError("LinearStaticAnalysis.solve() requires a Model")
+
+        nodes = tuple(model.nodes)
+        elements = tuple(model.elements)
+        stiffness = _assemble_stiffness(model)
+        loads = np.asarray(model.applied_loads, dtype=float).copy()
+        prescribed = np.asarray(
+            model.prescribed_displacements, dtype=float
+        ).copy()
+
+        (
+            prescribed_dofs,
+            free_dofs,
+            reduced,
+            rhs,
+        ) = _partition_system(stiffness, loads, prescribed)
+
+        if reduced.size:
+            if np.linalg.matrix_rank(reduced) < reduced.shape[0]:
+                raise np.linalg.LinAlgError(
+                    "Singular stiffness matrix: the model may be "
+                    "underconstrained or contain a mechanism."
+                )
+            free_displacements = np.linalg.solve(reduced, rhs)
+        else:
+            free_displacements = np.empty(0, dtype=float)
+
+        displacements = prescribed.copy()
+        displacements[free_dofs] = free_displacements
+
+        nodal_forces = stiffness @ displacements
+        reactions = np.zeros_like(nodal_forces)
+        reactions[prescribed_dofs] = (
+            nodal_forces[prescribed_dofs] - loads[prescribed_dofs]
+        )
+
+        node_indices = {node: index for index, node in enumerate(nodes)}
+        connectivity = tuple(
+            tuple(node_indices[node] for node in element.nodes)
+            for element in elements
+        )
+
+        element_results = []
+        for element in elements:
+            indices = _element_dof_indices(model, element)
+            u_e = displacements[indices]
+            values = {
+                name: float(value)
+                for name, value in element.compute_results(u_e).items()
+            }
+            element_results.append(values)
+
+        return StaticResult(
+            model_name=model.name,
+            node_objects=nodes,
+            node_labels=tuple(node.label for node in nodes),
+            node_coordinates=np.array(
+                [[node.x, node.y] for node in nodes], dtype=float
+            ),
+            element_objects=elements,
+            element_labels=tuple(element.label for element in elements),
+            element_types=tuple(element.etype for element in elements),
+            connectivity=connectivity,
+            displacement_dofs=model.displacement_dofs,
+            force_dofs=model.force_dofs,
+            applied_loads=loads,
+            prescribed_displacements=prescribed,
+            displacements=displacements,
+            nodal_forces=nodal_forces,
+            reactions=reactions,
+            element_results=tuple(element_results),
+        )
+
+
+def solve(model):
+    """Solve *model* using the default linear-static analysis."""
+    return LinearStaticAnalysis().solve(model)