truss-analysis 2.0.9__py3-none-any.whl

truss_analysis/__init__.py

@@ -0,0 +1,19 @@
+__version__ = "2.0.9"
+
+from .assembly import assemble_global_matrices
+from .model import Element, Node
+from .postprocess import calculate_element_forces
+from .solver import check_energy, solve
+
+solve_truss = solve
+
+__all__ = [
+    "__version__",
+    "Element",
+    "Node",
+    "solve",
+    "solve_truss",
+    "check_energy",
+    "assemble_global_matrices",
+    "calculate_element_forces",
+]

truss_analysis/assembly.py

@@ -0,0 +1,93 @@
+"""Assembly: global stiffness matrix and force vectors."""
+
+from __future__ import annotations
+
+import numpy as np
+
+from .exceptions import AssemblyError
+from .model import Element, Node
+
+
+def assemble_global_matrices(
+    nodes: list[Node],
+    elements: list[Element],
+) -> tuple[np.ndarray, np.ndarray, np.ndarray, list[int]]:
+    """Assemble global stiffness matrix and force vectors.
+
+    Returns:
+        K: Global stiffness matrix
+        F_ext: External force vector (mechanical + thermal)
+        F_mechanical: Mechanical force vector only
+        fixed_dofs: List of fixed DOF indices
+    """
+    n = len(nodes)
+    K = np.zeros((2 * n, 2 * n))
+    F_ext = np.zeros(2 * n)
+    F_mechanical = np.zeros(2 * n)
+    fixed_dofs = []
+
+    # Build node index map
+    node_map = {node.id: i for i, node in enumerate(nodes)}
+
+    # Assemble element contributions
+    for elem in elements:
+        if elem.node_i not in node_map or elem.node_j not in node_map:
+            raise AssemblyError(f"Element {elem.id} references non-existent nodes")
+
+        i = node_map[elem.node_i]
+        j = node_map[elem.node_j]
+
+        # Element geometry
+        dx = nodes[j].x - nodes[i].x
+        dy = nodes[j].y - nodes[i].y
+        L = np.sqrt(dx**2 + dy**2)
+
+        if L < 1e-12:
+            raise AssemblyError(f"Element {elem.id} has zero or negative length")
+
+        c = dx / L
+        s = dy / L
+
+        # Element stiffness matrix (local to global transformation)
+        k = elem.E * elem.A / L
+        ke = k * np.array(
+            [
+                [c**2, c * s, -(c**2), -c * s],
+                [c * s, s**2, -c * s, -(s**2)],
+                [-(c**2), -c * s, c**2, c * s],
+                [-c * s, -(s**2), c * s, s**2],
+            ]
+        )
+
+        # DOF indices
+        dofs = [2 * i, 2 * i + 1, 2 * j, 2 * j + 1]
+
+        # Assemble into global matrix
+        for ii in range(4):
+            for jj in range(4):
+                K[dofs[ii], dofs[jj]] += ke[ii, jj]
+
+        # Thermal/fabrication forces
+        if elem.alpha != 0 or elem.delta_L_free != 0:
+            delta_L_thermal = elem.alpha * elem.delta_T * L
+            delta_L_prestress = delta_L_thermal + elem.delta_L_free
+
+            # Equivalent nodal forces (in global coordinates)
+            F_thermal = k * delta_L_prestress
+            F_ext[2 * i] -= F_thermal * c
+            F_ext[2 * i + 1] -= F_thermal * s
+            F_ext[2 * j] += F_thermal * c
+            F_ext[2 * j + 1] += F_thermal * s
+
+            # F_mechanical does NOT include thermal forces
+            # (they are internal, not external)
+
+    # Apply boundary conditions
+    for i, node in enumerate(nodes):
+        if node.is_support:
+            if node.support_dx:
+                fixed_dofs.append(2 * i)
+            if node.support_dy:
+                fixed_dofs.append(2 * i + 1)
+
+    return K, F_ext, F_mechanical, fixed_dofs

truss_analysis/exceptions.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+
+class TrussError(Exception):
+    pass
+
+
+class AssemblyError(TrussError):
+    pass
+
+
+class InputValidationError(TrussError):
+    pass
+
+
+class EnergyValidationError(TrussError):
+    pass
+
+
+class SingularMatrixError(TrussError):
+    pass
+
+
+class UnitConversionError(TrussError):
+    pass

truss_analysis/fileio.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import json
+import os
+
+from .exceptions import InputValidationError
+
+
+def load_json(filepath):
+    if not os.path.exists(filepath):
+        raise FileNotFoundError(f"File not found: {filepath}")
+    size = os.path.getsize(filepath)
+    if size > 10 * 1024 * 1024:
+        raise InputValidationError(f"File too large: {size} bytes.")
+    try:
+        with open(filepath, "r", encoding="utf-8") as f:
+            data = json.load(f)
+    except json.JSONDecodeError:
+        raise InputValidationError("Invalid JSON format.")
+
+    for key in ["nodes", "elements"]:
+        if key not in data:
+            raise InputValidationError(f"Missing key: '{key}'")
+        if not isinstance(data[key], list):
+            raise InputValidationError(f"'{key}' must be a list.")
+
+    node_ids = {n.get("id") for n in data["nodes"]}
+    for elem in data["elements"]:
+        if elem.get("node_i") not in node_ids or elem.get("node_j") not in node_ids:
+            raise InputValidationError(
+                f"Element {elem.get('id')} references non-existent nodes."
+            )
+
+    if "loads" in data:
+        loads = data["loads"]
+        if not isinstance(loads, list):
+            raise InputValidationError("'loads' must be a list of force objects.")
+        for lf in loads:
+            if not isinstance(lf, dict):
+                raise InputValidationError("Each load must be a dictionary.")
+            if "node_id" not in lf and "id" not in lf:
+                raise InputValidationError("Load missing 'node_id' or 'id'.")
+            if "Fx" not in lf and "Fy" not in lf:
+                raise InputValidationError("Load missing 'Fx' or 'Fy'.")
+    return data

truss_analysis/i18n.py

@@ -0,0 +1,30 @@
+"""ماژول مدیریت چندزبانه (i18n) با پشتیبانی از Graceful Degradation"""
+
+import logging
+
+logger = logging.getLogger(__name__)
+TRANSLATIONS = {
+    "fa": {
+        "force": "نیرو",
+        "displacement": "جابجایی",
+        "node": "گره",
+        "element": "عضو",
+        "status": "وضعیت",
+    },
+    "en": {
+        "force": "Force",
+        "displacement": "Displacement",
+        "node": "Node",
+        "element": "Element",
+        "status": "Status",
+    },
+}
+CURRENT_LANG = "fa"
+
+
+def get_text(key: str, lang: str = CURRENT_LANG) -> str:
+    lang_dict = TRANSLATIONS.get(lang, TRANSLATIONS.get("fa", {}))
+    if key in lang_dict:
+        return lang_dict[key]
+    logger.warning(f"Translation key not found: '{key}' in language '{lang}'")
+    return f"!!{key}!!"

truss_analysis/logger.py

@@ -0,0 +1,12 @@
+import logging
+import sys
+
+
+def setup_logger():
+    logger = logging.getLogger("truss_analysis")
+    if not logger.handlers:
+        handler = logging.StreamHandler(sys.stdout)
+        handler.setFormatter(logging.Formatter("%(levelname)s: %(message)s"))
+        logger.addHandler(handler)
+    logger.setLevel(logging.INFO)
+    return logger

truss_analysis/main.py

@@ -0,0 +1,271 @@
+"""Main entry point for truss analysis with advanced CLI."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from dataclasses import dataclass, field
+
+from .assembly import assemble_global_matrices
+from .fileio import load_json
+from .model import Element, Node, validate_inputs
+from .plotter import plot_axial_force, plot_truss, setup_persian_font
+from .postprocess import (
+    calculate_element_forces,
+    calculate_reactions,
+    check_equilibrium,
+)
+from .report import to_csv, to_json, to_markdown
+from .solver import check_energy, solve
+from .units import to_si
+
+
+@dataclass
+class AnalysisResult:
+    """Complete analysis results."""
+
+    displacements: dict[str, tuple[float, float]]
+    forces: list[dict]
+    reactions: dict[str, dict[str, float]]
+    strain_energy: float
+    prestress_work: float
+    equilibrium_errors: dict[str, float]
+    nodes: list[Node] = field(default_factory=list)
+    elements: list[Element] = field(default_factory=list)
+
+
+def run(filepath: str, unit_sys: str = "SI") -> AnalysisResult:
+    """Run complete truss analysis."""
+    data = load_json(filepath)
+    nodes = [
+        Node(
+            id=str(n["id"]),
+            x=to_si(n["x"], unit_sys, "L"),
+            y=to_si(n["y"], unit_sys, "L"),
+            is_support=n.get("is_support", False),
+            support_dx=n.get("support_dx", False),
+            support_dy=n.get("support_dy", False),
+        )
+        for n in data["nodes"]
+    ]
+
+    elements = [
+        Element(
+            id=str(e["id"]),
+            node_i=str(e["node_i"]),
+            node_j=str(e["node_j"]),
+            E=to_si(e["E"], unit_sys, "E"),
+            A=to_si(e["A"], unit_sys, "A"),
+            I_sec=to_si(e.get("I_sec", e.get("I", 0.0)), unit_sys, "I_sec"),
+            alpha=to_si(e.get("alpha", 0.0), unit_sys, "alpha"),
+            delta_T=to_si(e.get("delta_T", 0.0), unit_sys, "delta_T"),
+            delta_L_free=to_si(e.get("delta_L_free", 0.0), unit_sys, "L"),
+            density=to_si(e.get("density", 0.0), unit_sys, "density"),
+            effective_length_factor=e.get("effective_length_factor", 1.0),
+        )
+        for e in data["elements"]
+    ]
+
+    validate_inputs(nodes, elements)
+    K, F_ext, F_mechanical, fixed_dofs = assemble_global_matrices(nodes, elements)
+
+    # Add self-weight if density is provided
+    g = 9.81  # m/s²
+    for elem in elements:
+        if elem.density > 0:
+            i = next(j for j, n in enumerate(nodes) if n.id == elem.node_i)
+            j = next(j for j, n in enumerate(nodes) if n.id == elem.node_j)
+            dx = nodes[j].x - nodes[i].x
+            dy = nodes[j].y - nodes[i].y
+            L = (dx**2 + dy**2) ** 0.5
+            weight = elem.density * elem.A * L * g
+            F_ext[2 * i + 1] -= weight / 2
+            F_ext[2 * j + 1] -= weight / 2
+            F_mechanical[2 * i + 1] -= weight / 2
+            F_mechanical[2 * j + 1] -= weight / 2
+
+    loads = data.get("loads", [])
+    if isinstance(loads, dict):
+        loads = loads.get("node_forces", [])
+
+    node_map = {node.id: i for i, node in enumerate(nodes)}
+    for lf in loads:
+        nid = str(lf.get("node_id", lf.get("id")))
+        if nid in node_map:
+            idx = node_map[nid]
+            Fx = to_si(lf.get("Fx", 0.0), unit_sys, "F")
+            Fy = to_si(lf.get("Fy", 0.0), unit_sys, "F")
+            F_ext[idx * 2] += Fx
+            F_ext[idx * 2 + 1] += Fy
+            F_mechanical[idx * 2] += Fx
+            F_mechanical[idx * 2 + 1] += Fy
+
+    U = solve(K, F_ext, fixed_dofs)
+    results, strain_energy, prestress_work = calculate_element_forces(
+        nodes, elements, U
+    )
+    check_energy(U, F_mechanical, strain_energy, prestress_work)
+
+    reactions = calculate_reactions(nodes, elements, U, F_ext)
+    equilibrium_errors = check_equilibrium(nodes, reactions, F_ext)
+    displacements = {node.id: (U[i * 2], U[i * 2 + 1]) for i, node in enumerate(nodes)}
+
+    return AnalysisResult(
+        displacements=displacements,
+        forces=results,
+        reactions=reactions,
+        strain_energy=strain_energy,
+        prestress_work=prestress_work,
+        equilibrium_errors=equilibrium_errors,
+        nodes=nodes,
+        elements=elements,
+    )
+
+
+def main() -> int:
+    # Set UTF-8 encoding for stdout/stderr (Windows compatibility)
+    import io
+
+    try:
+        sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8")
+        sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding="utf-8")
+    except (AttributeError, Exception):
+        pass
+
+    parser = argparse.ArgumentParser(
+        description="2D Truss Analysis Tool with Advanced Features",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python main.py example.json
+  python main.py example.json --plot
+  python main.py example.json --output results --format all
+  python main.py example.json --save-plots --scale 50
+  python main.py example.json --check-buckling
+        """,
+    )
+    parser.add_argument("filepath", help="Path to the JSON input file")
+    parser.add_argument(
+        "unit_sys",
+        nargs="?",
+        default="SI",
+        help="Unit system (SI or Imperial)",
+    )
+    parser.add_argument(
+        "--plot",
+        action="store_true",
+        help="Show interactive plots of the truss",
+    )
+    parser.add_argument(
+        "--save-plots",
+        action="store_true",
+        help="Save plots as PNG files",
+    )
+    parser.add_argument(
+        "--output",
+        type=str,
+        help="Output file prefix (default: results)",
+    )
+    parser.add_argument(
+        "--format",
+        choices=["json", "csv", "markdown", "all"],
+        default="all",
+        help="Output format(s) to generate",
+    )
+    parser.add_argument(
+        "--check-buckling",
+        action="store_true",
+        help="Check Euler buckling for compression members",
+    )
+    parser.add_argument(
+        "--scale",
+        type=float,
+        default=10.0,
+        help="Deformation scale factor for plots (default: 10)",
+    )
+
+    args = parser.parse_args()
+
+    try:
+        result = run(args.filepath, args.unit_sys)
+
+        # Console output
+        print("✅ تحلیل با موفقیت انجام شد.")
+        print(f"انرژی کرنشی: {result.strain_energy:.4f} J")
+        print(f"کار پیش‌تنیدگی: {result.prestress_work:.4f} J")
+        print("\n📊 نیروهای اعضا:")
+        for r in result.forces:
+            status = "📈 کشش" if r["force"] > 0 else "📉 فشار"
+            print(f"  المان {r['element']}: {r['force']:.2f} N ({status})")
+            if r.get("buckling_warning"):
+                print(f"    ⚠️  {r['buckling_warning']}")
+
+        print("\n🔧 عکس‌العمل‌های تکیه‌گاهی:")
+        for node_id, react in result.reactions.items():
+            print(f"  گره {node_id}: Rx={react['Rx']:.2f} N, Ry={react['Ry']:.2f} N")
+
+        print("\n✅ بررسی تعادل استاتیکی:")
+        print(f"  خطای ΣFx: {result.equilibrium_errors['delta_Fx']:.6e}")
+        print(f"  خطای ΣFy: {result.equilibrium_errors['delta_Fy']:.6e}")
+        print(f"  خطای ΣM: {result.equilibrium_errors['delta_M']:.6e}")
+
+        # Generate plots if requested
+        if args.plot or args.save_plots:
+            font_prop = setup_persian_font()
+            prefix = args.output or "results"
+
+            if args.save_plots:
+                plot_truss(
+                    result.nodes,
+                    result.elements,
+                    result.displacements,
+                    show=args.plot,
+                    filename=f"{prefix}_truss.png",
+                    scale=args.scale,
+                    font_prop=font_prop,
+                )
+                plot_axial_force(
+                    result.nodes,
+                    result.elements,
+                    result.forces,
+                    filename=f"{prefix}_forces.png",
+                    font_prop=font_prop,
+                )
+            elif args.plot:
+                plot_truss(
+                    result.nodes,
+                    result.elements,
+                    result.displacements,
+                    show=True,
+                    scale=args.scale,
+                    font_prop=font_prop,
+                )
+                plot_axial_force(
+                    result.nodes,
+                    result.elements,
+                    result.forces,
+                    font_prop=font_prop,
+                )
+
+        # Generate structured outputs
+        if args.output:
+            prefix = args.output
+            if args.format in ["json", "all"]:
+                to_json(result, f"{prefix}.json")
+            if args.format in ["csv", "all"]:
+                to_csv(result, prefix)
+            if args.format in ["markdown", "all"]:
+                to_markdown(result, f"{prefix}.md")
+
+        return 0
+
+    except Exception as e:
+        print(f"❌ خطا در تحلیل: {e}", file=sys.stderr)
+        import traceback
+
+        traceback.print_exc()
+        return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())

truss_analysis/model.py

@@ -0,0 +1,94 @@
+"""Pure DTOs for Truss Analysis."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .exceptions import InputValidationError
+
+
+@dataclass
+class Node:
+    """A node in the truss structure."""
+
+    id: str
+    x: float
+    y: float
+    is_support: bool = False
+    support_dx: bool = False
+    support_dy: bool = False
+
+    def __post_init__(self):
+        if not isinstance(self.id, str):
+            raise InputValidationError(f"Node ID must be string, got {type(self.id)}")
+        if not all(isinstance(v, (int, float)) for v in [self.x, self.y]):
+            raise InputValidationError("Node coordinates must be numeric")
+
+
+@dataclass
+class Element:
+    """A truss element (bar) connecting two nodes."""
+
+    id: str
+    node_i: str
+    node_j: str
+    E: float  # Young's modulus
+    A: float  # Cross-sectional area
+    I_sec: float = 0.0  # Second moment of area
+    alpha: float = 0.0  # Thermal expansion coefficient
+    delta_T: float = 0.0  # Temperature change
+    delta_L_free: float = 0.0  # Free length change (fabrication error)
+    density: float = 0.0  # Material density (for self-weight)
+    effective_length_factor: float = 1.0  # For buckling calculation
+
+    def __post_init__(self):
+        if not isinstance(self.id, str):
+            raise InputValidationError(
+                f"Element ID must be string, got {type(self.id)}"
+            )
+        if self.E <= 0:
+            raise InputValidationError(
+                f"Element {self.id}: E must be positive, got {self.E}"
+            )
+        if self.A <= 0:
+            raise InputValidationError(
+                f"Element {self.id}: A must be positive, got {self.A}"
+            )
+        if self.node_i == self.node_j:
+            raise InputValidationError(
+                f"Element {self.id}: node_i and node_j cannot be the same"
+            )
+
+
+def validate_inputs(nodes: list[Node], elements: list[Element]) -> None:
+    """Validate input data for consistency and correctness."""
+
+    # Check unique node IDs
+    node_ids = {n.id for n in nodes}
+    if len(node_ids) != len(nodes):
+        raise InputValidationError("Duplicate node IDs found")
+
+    # Check unique element IDs
+    elem_ids = {e.id for e in elements}
+    if len(elem_ids) != len(elements):
+        raise InputValidationError("Duplicate element IDs found")
+
+    # Check that all element node references exist
+    for elem in elements:
+        if elem.node_i not in node_ids:
+            raise InputValidationError(
+                f"Element {elem.id} references non-existent node {elem.node_i}"
+            )
+        if elem.node_j not in node_ids:
+            raise InputValidationError(
+                f"Element {elem.id} references non-existent node {elem.node_j}"
+            )
+
+    # Check kinematic stability (at least 3 constraints total)
+    total_constraints = sum(
+        (n.support_dx + n.support_dy) for n in nodes if n.is_support
+    )
+    if total_constraints < 3:
+        raise InputValidationError(
+            f"Insufficient constraints for stability: {total_constraints} < 3"
+        )