Merge pull request #111 from mihdicaballero/punching

Punching phase 0 and 1

Author: mihdicaballero

mento/__init__.py

@@ -66,6 +66,11 @@
     "ACI_318_19_beam",
     "BeamSettings",
     "BeamSummary",
+    "Column",
+    "PunchingSlab",
+    "Opening",
+    "Capital",
+    "PunchingNode",
 ]
 
 if TYPE_CHECKING:
@@ -83,6 +88,8 @@
     from mento.node import Node
     from mento.results import DocumentBuilder, Formatter, TablePrinter
     from mento.summary import BeamSummary
+    from mento.column import Column
+    from mento.punching import Capital, Opening, PunchingNode, PunchingSlab
 
 
 def __getattr__(name: str) -> object:
@@ -103,6 +110,11 @@ def __getattr__(name: str) -> object:
         "EN_1992_2004_beam": "codes",
         "ACI_318_19_beam": "codes",
         "BeamSummary": "summary",
+        "Column": "column",
+        "PunchingSlab": "punching",
+        "Opening": "punching",
+        "Capital": "punching",
+        "PunchingNode": "punching",
     }
 
     if name in module_mapping:

mento/column.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Literal, Optional, TYPE_CHECKING
+
+from mento.units import cm
+
+if TYPE_CHECKING:
+    from pint import Quantity
+
+
+@dataclass
+class Column:
+    """
+    Column geometry for punching shear analysis.
+
+    Parameters
+    ----------
+    shape : "rectangular" | "circular"
+    position : "interior" | "edge" | "corner"
+    b : column width in x-direction (or diameter for circular)
+    h : column width in y-direction (ignored for circular)
+    edge_distance_x : distance from column centroid to free slab edge in x
+        Required for edge and corner columns.
+    edge_distance_y : distance from column centroid to free slab edge in y
+        Required for corner columns.
+    """
+
+    shape: Literal["rectangular", "circular"]
+    position: Literal["interior", "edge", "corner"]
+    b: Quantity = field(default=0 * cm)
+    h: Quantity = field(default=0 * cm)
+    edge_distance_x: Optional[Quantity] = field(default=None)
+    edge_distance_y: Optional[Quantity] = field(default=None)
+
+    def __post_init__(self) -> None:
+        if self.shape not in ("rectangular", "circular"):
+            raise ValueError(f"shape must be 'rectangular' or 'circular', got {self.shape!r}")
+        if self.position not in ("interior", "edge", "corner"):
+            raise ValueError(f"position must be 'interior', 'edge', or 'corner', got {self.position!r}")
+        if self.position in ("edge", "corner") and self.edge_distance_x is None:
+            raise ValueError(f"edge_distance_x is required for '{self.position}' columns")
+        if self.position == "corner" and self.edge_distance_y is None:
+            raise ValueError("edge_distance_y is required for corner columns")
+
+    def __repr__(self) -> str:
+        shape_str = self.shape.capitalize()
+        pos_str = self.position.capitalize()
+        b_cm = self.b.to("cm").magnitude
+        if self.shape == "rectangular":
+            h_cm = self.h.to("cm").magnitude
+            dims = f"b={b_cm:.1f} cm, h={h_cm:.1f} cm"
+        else:
+            dims = f"d={b_cm:.1f} cm"
+        return f"Column({shape_str}, {pos_str}, {dims})"

mento/forces.py

@@ -37,6 +37,7 @@ class Forces:
     _N_x: Quantity = field(default=0 * kN)  # Ensure you use the correct unit type here
     _V_z: Quantity = field(default=0 * kN)
     _M_y: Quantity = field(default=0 * kNm)
+    _M_x: Quantity = field(default=0 * kNm)
     unit_system: str = field(default="metric")  # Add unit_system as a field
 
     def __init__(
@@ -45,6 +46,7 @@ def __init__(
         N_x: Quantity = 0 * kN,
         V_z: Quantity = 0 * kN,
         M_y: Quantity = 0 * kNm,
+        M_x: Quantity = 0 * kNm,
         unit_system: str = "metric",
     ) -> None:
         # Increment the class variable for the next unique ID
@@ -56,7 +58,7 @@ def __init__(
         self.unit_system = unit_system  # Set the unit system
 
         # Set the forces upon initialization
-        self.set_forces(N_x, V_z, M_y)
+        self.set_forces(N_x, V_z, M_y, M_x)
 
     @property
     def id(self) -> int:
@@ -92,26 +94,43 @@ def M_y(self) -> Quantity:
         else:
             return self._M_y.to("ft*kip")
 
+    @property
+    def M_x(self) -> Quantity:
+        """Bending moment about the x-axis — used for biaxial punching shear (default is 0 kN*m)."""
+        if self.unit_system == "metric":
+            return self._M_x.to("kN*m")
+        else:
+            return self._M_x.to("ft*kip")
+
     def get_forces(self) -> Dict[str, Quantity]:
-        """Returns the forces as a dictionary with keys 'N_x', 'V_z', and 'M_y'."""
+        """Returns the forces as a dictionary with keys 'N_x', 'V_z', 'M_y', and 'M_x'."""
         if self.unit_system == "metric":
             return {
                 "N_x": self._N_x.to("kN"),
                 "V_z": self._V_z.to("kN"),
                 "M_y": self._M_y.to("kN*m"),
+                "M_x": self._M_x.to("kN*m"),
             }
         else:
             return {
                 "N_x": self._N_x.to("kip"),
                 "V_z": self._V_z.to("kip"),
                 "M_y": self._M_y.to("ft*kip"),
+                "M_x": self._M_x.to("ft*kip"),
             }
 
-    def set_forces(self, N_x: Quantity = 0 * kN, V_z: Quantity = 0 * kN, M_y: Quantity = 0 * kNm) -> None:
+    def set_forces(
+        self,
+        N_x: Quantity = 0 * kN,
+        V_z: Quantity = 0 * kN,
+        M_y: Quantity = 0 * kNm,
+        M_x: Quantity = 0 * kNm,
+    ) -> None:
         """Sets the forces in the object."""
         self._N_x = N_x
         self._V_z = V_z
         self._M_y = M_y
+        self._M_x = M_x
 
     def compare_to(self, other: "Forces", by: str = "V_z") -> bool:
         """Compares this force with another force based on a selected attribute.
@@ -121,16 +140,19 @@ def compare_to(self, other: "Forces", by: str = "V_z") -> bool:
         other : Forces
             Another Forces instance to compare with.
         by : str
-            The attribute to compare by ('N_x', 'V_z', or 'M_y').
+            The attribute to compare by ('N_x', 'V_z', 'M_y', or 'M_x').
 
         Returns
         -------
         bool
             True if this force is greater than the other force by the selected attribute.
         """
-        if by not in ["N_x", "V_z", "M_y"]:
-            raise ValueError("Comparison attribute must be one of 'N_x', 'V_z', or 'M_y'")
+        if by not in ["N_x", "V_z", "M_y", "M_x"]:
+            raise ValueError("Comparison attribute must be one of 'N_x', 'V_z', 'M_y', or 'M_x'")
         return getattr(self, by).magnitude > getattr(other, by).magnitude
 
     def __str__(self) -> str:
-        return f"Force ID: {self.id}, Label: {self.label}, " f"N_x: {self.N_x}, V_z: {self.V_z}, M_y: {self.M_y}"
+        base = f"Force ID: {self.id}, Label: {self.label}, N_x: {self.N_x}, V_z: {self.V_z}, M_y: {self.M_y}"
+        if self._M_x.magnitude != 0:
+            base += f", M_x: {self.M_x}"
+        return base