added point loads

Author: connorferster

pyproject.toml

@@ -6,9 +6,9 @@ readme = "README.md"
 authors = [
     { name = "Connor Ferster", email = "connorferster@gmail.com" }
 ]
-requires-python = ">=3.13"
+requires-python = ">=3.11"
 dependencies = [
-    "load-distribution>=0.1.0",
+    "load-distribution==0.1.4",
 ]
 
 [project.scripts]

src/loadbearing_wall/geom_ops.py

@@ -27,10 +27,24 @@ def apply_spread_angle(
     else:
         projected_x1 = min(wall_length, x1 + spread_amount)
     projected_length = projected_x1 - projected_x0
-    assert projected_length <= wall_length
-    original_length = x1 - x0
+    if x1 is not None:
+        original_length = x1 - x0
+    else:
+        original_length = 1
     ratio = original_length / projected_length
     projected_w0 = w0 * ratio
-    projected_w1 = w1 * ratio
-    assert (projected_w0 + projected_w1) / 2 * projected_length == (w0 + w1) / 2 * original_length
-    return (projected_w0, projected_w1, projected_x0, projected_x1)
+    if w1 is not None:
+        projected_w1 = w1 * ratio
+    else:
+        projected_w1 = w0 * ratio
+    return (round_to_close_integer(projected_w0), round_to_close_integer(projected_w1), round_to_close_integer(projected_x0), round_to_close_integer(projected_x1))
+
+
+def round_to_close_integer(x: float, eps = 1e-7) -> float | int:
+    """
+    Rounds to the nearest int if it is REALLY close
+    """
+    if abs(abs(round(x)) - abs(x)) < eps:
+        return round(x)
+    else:
+        return x

src/loadbearing_wall/linear_reactions.py

@@ -1,6 +1,7 @@
 from dataclasses import dataclass
 from typing import Optional
 from load_distribution import Singularity, singularities_to_polygon
+from .geom_ops import round_to_close_integer as rtci
 
 @dataclass
 class LinearReaction:
@@ -45,7 +46,7 @@ def extract_reaction(self, xa: float, xb: float) -> "LinearReaction":
             xj = xb
             yj = y0 + (xj - self.x0) * m
 
-        return LinearReaction(yi, yj, xi, xj)
+        return LinearReaction(rtci(yi), rtci(yj), rtci(xi), rtci(xj))
 
 
 @dataclass
@@ -73,18 +74,19 @@ def from_projected_loads(
         x0 = location_start_key
         x1 = location_end_key
         linear_reaction_components = {}
-        for load_dir, dir_loads in projected_loads.items():
+        for load_dir, load_cases in projected_loads.items():
             linear_reaction_components.setdefault(load_dir, {})
-            for load_case, distributed_loads in dir_loads.items():
+            for load_case, applied_loads in load_cases.items():
                 linear_reaction_components[load_dir].setdefault(load_case, [])
-                for distributed_load in distributed_loads:
+                for applied_load in applied_loads:
                     linear_reaction = LinearReaction(
-                        distributed_load[w0],
-                        distributed_load[w1],
-                        distributed_load[x0],
-                        distributed_load[x1],
+                        applied_load[w0],
+                        applied_load.get(w1),
+                        applied_load[x0],
+                        applied_load.get(x1),
                     )
-                linear_reaction_components[load_dir][load_case].append(linear_reaction)
+
+                    linear_reaction_components[load_dir][load_case].append(linear_reaction)
         return cls(linear_reaction_components, w0, w1, x0, x1)
 
 
@@ -147,16 +149,28 @@ def consolidate_reactions(
         x1 = self.location_end_key
         reaction_components = {}
         flattened_reaction_components = []
-        for load_dir, dir_loads in self.linear_reactions.items():
+        for load_dir, load_cases in self.linear_reactions.items():
             reaction_components.setdefault(load_dir, {})
-            for load_case, linear_reactions in dir_loads.items():
+            for load_case, linear_reactions in load_cases.items():
                 reaction_components[load_dir].setdefault(load_case, [])
                 singularity_functions = []
                 for lr in linear_reactions:
-                    m = (lr.w1 - lr.w0) / (lr.x1 - lr.x0)
-                    y0 = lr.w0
-                    singularity_function = Singularity(x0=lr.x0, y0=y0, x1=lr.x1, m=m, precision=3)
-                    singularity_functions.append(singularity_function)
+                    if lr.w1 is None and lr.x1 is None:
+                        point_load =  {w0: lr.w0, x0: lr.x0, dir_key: load_dir, case_key: load_case}
+                        print(f"{point_load=}")
+                        flattened_reaction_components.append(
+                            point_load
+                        )
+                        reaction_components[load_dir][load_case].append(
+                            point_load
+                        )
+                    else:
+                        m = (lr.w1 - lr.w0) / (lr.x1 - lr.x0)
+                        y0 = lr.w0
+                        singularity_function = Singularity(x0=lr.x0, y0=y0, x1=lr.x1, m=m, precision=6)
+                        print(singularity_function)
+                        singularity_functions.append(singularity_function)
+                if not singularity_functions: continue
                 linear_reactions = singularity_xy_to_distributed_loads(
                     singularities_to_polygon(
                         singularity_functions, xy=True
@@ -173,7 +187,7 @@ def consolidate_reactions(
                 flattened_reaction_components.append(linear_reactions)
 
                 # Get ride of the extrandious dir and case keys for unflattened results
-                reaction_components[load_dir][load_case] = linear_reactions
+                reaction_components[load_dir][load_case] += linear_reactions
         if flatten:
             return flattened_reaction_components
         return reaction_components
@@ -219,16 +233,16 @@ def singularity_xy_to_distributed_loads(
     w1 = magnitude_end_key
     x0 = location_start_key
     x1 = location_end_key
-    filtered = filter_repeated_y_values(xy_vals)
     dist_loads = []
     prev_x = None
-    for idx, (x, y) in enumerate(filtered):
+    for idx, (x, y) in enumerate(zip(*xy_vals)):
+        print(f"{(x, y)=}")
         if idx == 0: continue
         if prev_x is None:
             prev_x = x
             prev_y = y
         elif x - prev_x > 1e-3:
-            dist_load = {w0: prev_y, w1: y, x0: prev_x,  x1: x, case_key: case, dir_key: dir}
+            dist_load = {w0: float(rtci(prev_y)), w1: float(rtci(y)), x0: float(rtci(prev_x)),  x1: float(rtci(x)), case_key: case, dir_key: dir}
             dist_loads.append(dist_load)
             prev_x = x
             prev_y = y

src/loadbearing_wall/wall_model.py

@@ -144,8 +144,8 @@ def spread_loads(self) -> None:
                             self.length, 
                             self.vertical_spread_angle,
                             dist_load[w0],
-                            dist_load.get(w1),
                             dist_load[x0],
+                            dist_load.get(w1),
                             dist_load.get(x1),
                         )
                         proj[load_dir][load_case].append({
@@ -156,6 +156,44 @@ def spread_loads(self) -> None:
                         })
                     else:
                         proj[load_dir][load_case].append(dist_load)
+
+        for load_dir, load_cases in self.point_loads.items():
+            proj.setdefault(load_dir, {})
+            should_apply_spread_angle = (
+                (
+                    load_dir == self.gravity_dir
+                    and self.apply_spread_angle_gravity
+                    and self.vertical_spread_angle != 0.0
+                )
+                or 
+                (
+                    load_dir == self.inplane_dir
+                    and self.apply_spread_angle_inplane
+                    and self.vertical_spread_angle != 0.0
+                )
+            )
+            for load_case, point_loads in load_cases.items():
+                proj[load_dir].setdefault(load_case, [])
+                for point_load in point_loads:
+                    if should_apply_spread_angle:
+                        projected_load = geom.apply_spread_angle(
+                            self.height, 
+                            self.length, 
+                            self.vertical_spread_angle,
+                            point_load[w0],
+                            point_load[x0],
+                            point_load.get(w1),
+                            point_load.get(x1),
+                        )
+                        proj[load_dir][load_case].append({
+                            w0: projected_load[0],
+                            w1: projected_load[1],
+                            x0: projected_load[2],
+                            x1: projected_load[3]
+                        })
+                    else:
+                        proj[load_dir][load_case].append(point_load)
+                        
         self._projected_loads = proj
 
 

tests/test_geom.py

@@ -0,0 +1,15 @@
+from loadbearing_wall.geom_ops import apply_spread_angle
+
+
+def test_apply_spread_angle():
+    ret = apply_spread_angle(
+        4,
+        3,
+        spread_angle=10,
+        w0=10,
+        x0=1,
+        w1=10,
+        x1=2
+
+    )
+    assert ret == (4.148317542163208, 4.148317542163208, 0.2946920771661401, 2.70530792283386)

tests/test_wall_model.py

@@ -25,6 +25,11 @@ def WM0():
                 "L": [
                     {"w1": 100.0, "x1": 0.5},
                 ]
+            },
+            "Fx": {
+                "W": [
+                    {"w1": 2000, "x1": 0.0}
+                ]
             }
         },
         gravity_dir = "Fz",
@@ -43,4 +48,27 @@ def WM1(WM0):
 
 def test_wall_model_runs(WM0, WM1):
     assert WM0.get_reactions()
-    assert WM1.get_reactions()
+    assert WM1.get_reactions()
+
+def test_no_spread(WM0):
+    rxn = WM0.get_reactions(flattened=False)
+    assert rxn['Fz']['D'] == [
+                    {"dir": "Fz", "case": "D", "w1": 100.0, "x1": 0.5},
+                    {"dir": "Fz", "case": "D", "w1": 10.0, "w2": 10.0, "x1": 1.0, "x2": 3.0},
+                ]
+    assert rxn['Fz']['L'] == [
+                {"dir": "Fz", "case": "L", "w1": 100.0, "x1": 0.5},
+                {"dir": "Fz", "case": "L", "w1": 15.0, "w2": 15.0, "x1": 0.0, "x2": 2.0},
+            ]
+    
+def test_45_spread(WM1):
+    rxn = WM1.get_reactions()
+    assert rxn['Fz']['D'] == [
+                    {"dir": "Fz", "case": "D", "w1": 45.0, "w2": 45.0, "x1": 0.0, "x2": 2.499999999999},
+                    {"dir": "Fz", "case": "D", "w1": 5.0, "w2": 5.0, "x1": 2.500000000001, "x2": 4.0},
+                ]
+    
+    assert rxn['Fz']['L'] == [
+                    {"dir": "Fz", "case": "L", "w1": 47.5, "w2": 47.5, "x1": 0.0, "x2": 2.499999999999},
+                    {"dir": "Fz", "case": "L", "w1": 7.5, "w2": 7.5, "x1": 2.500000000001, "x2": 4.0},
+                ]