PyCBA 1.0.1__tar.gz → 1.0.2__tar.gz

{pycba-1.0.1/src/PyCBA.egg-info → pycba-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyCBA
-Version: 1.0.1
+Version: 1.0.2
 Summary: Python Continuous Beam Analysis
 Author-email: Colin Caprani <colin.caprani@monash.edu>
 License: AGPL-3.0-or-later

{pycba-1.0.1 → pycba-1.0.2/src/PyCBA.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyCBA
-Version: 1.0.1
+Version: 1.0.2
 Summary: Python Continuous Beam Analysis
 Author-email: Colin Caprani <colin.caprani@monash.edu>
 License: AGPL-3.0-or-later

{pycba-1.0.1 → pycba-1.0.2}/src/PyCBA.egg-info/SOURCES.txt

@@ -31,6 +31,7 @@ tests/test_additive_pattern.py
 tests/test_basic.py
 tests/test_bridge.py
 tests/test_code_load_models.py
+tests/test_double_release.py
 tests/test_foundation.py
 tests/test_inf_lines.py
 tests/test_loadpattern_ergonomics.py

{pycba-1.0.1 → pycba-1.0.2}/src/pycba/__init__.py

@@ -2,7 +2,7 @@
 PyCBA - Continuous Beam Analysis in Python
 """
 
-__version__ = "1.0.1"
+__version__ = "1.0.2"
 
 from .analysis import BeamAnalysis
 from .beam import Beam

{pycba-1.0.1 → pycba-1.0.2}/src/pycba/beam.py

@@ -847,14 +847,11 @@ class Beam:
         )
 
         if eType == 4:
-            # Pinned-pinned: release both end moments.  Mirror the prismatic
-            # :meth:`pycba.load.Load.get_ref` convention exactly (the vertical
-            # correction is ``(Ma + Mb)/L`` applied to the fixed-fixed CNL),
-            # so the constant-EI limit is reproduced.
-            Va_ff, Vb_ff = ref[0], ref[2]
-            ref[0] = Va_ff + (Ma + Mb) / L
+            # Both rotations are free: reactions follow statics, independent
+            # of the stiffness distribution and its fixed-end moments.
+            ref[0] = Va_ss
             ref[1] = 0.0
-            ref[2] = Vb_ff - (Ma + Mb) / L
+            ref[2] = Vb_ss
             ref[3] = 0.0
         elif eType in (2, 3):
             # Single moment release: condense the released rotational DOF so
@@ -1605,11 +1602,11 @@ class Beam:
         )
 
         if eType == 4:
-            # Pinned-pinned: release both end moments (mirror _ref_nonprismatic).
-            Va_ff, Vb_ff = ref[0], ref[2]
-            ref[0] = Va_ff + (Ma + Mb) / L
+            # Both-end releases leave the simply-supported reactions;
+            # shear flexibility must not change this statically determinate case.
+            ref[0] = Va_ss
             ref[1] = 0.0
-            ref[2] = Vb_ff - (Ma + Mb) / L
+            ref[2] = Vb_ss
             ref[3] = 0.0
         elif eType in (2, 3):
             # Single moment release: condense the released rotational DOF using

{pycba-1.0.1 → pycba-1.0.2}/src/pycba/load.py

@@ -112,16 +112,17 @@ class Load:
             ref[3] = 1.0 * cnl.Mb
         elif eType == 3:  # DOF = moment at i node
             ref[0] = fm * cnl.Ma
-            ref[1] = 1.0 * cnl.Ma
-            ref[2] = -fm * cnl.Ma
-            ref[3] = 0.5 * cnl.Ma
-        elif eType == 4:  # keep only vertical, remove moments
-            ref[0] = -(cnl.Ma + cnl.Mb) / L
-            ref[1] = 1.0 * cnl.Ma
-            ref[2] = (cnl.Ma + cnl.Mb) / L
-            ref[3] = 1.0 * cnl.Mb
-        else:
-            # no nothing if it is FF
+            ref[1] = 1.0 * cnl.Ma
+            ref[2] = -fm * cnl.Ma
+            ref[3] = 0.5 * cnl.Ma
+        elif eType == 4:  # keep only vertical, remove moments
+            # Static condensation transfers the end-moment couple to shear.
+            ref[0] = (cnl.Ma + cnl.Mb) / L
+            ref[1] = 1.0 * cnl.Ma
+            ref[2] = -(cnl.Ma + cnl.Mb) / L
+            ref[3] = 1.0 * cnl.Mb
+        else:
+            # no nothing if it is FF
             pass
         # now superimpose the released forces
         return LoadCNL(

{pycba-1.0.1 → pycba-1.0.2}/src/pycba/results.py

@@ -291,6 +291,18 @@ class BeamResults:
         res.R[1:-1] = psi
         res.D[1:-1] = D
 
+        # The padding stations at index 0 and -1 duplicate the true end
+        # stations (x[1] and x[-2]) so that M and V can show their
+        # discontinuity at a support/point load. Rotation and deflection
+        # have no such discontinuity, so the padding should carry the same
+        # (properly computed) value as the true end station, not the raw
+        # per-load superposition value left over from before ``psi``/``D``
+        # were computed above.
+        res.R[0] = psi[0]
+        res.R[-1] = psi[-1]
+        res.D[0] = D[0]
+        res.D[-1] = D[-1]
+
         return res
 
     def at(self, x: float, attrs: Tuple[str, ...] = ("M", "V", "R", "D")) -> Dict:

pycba-1.0.2/tests/test_double_release.py

@@ -0,0 +1,80 @@
+"""Release regressions anchored to statics, not agreement between code paths."""
+import numpy as np
+import pytest
+import pycba as cba
+from pycba.load import LoadPL, LoadUDL, LoadPUDL
+from pycba.section import SectionEI
+
+
+@pytest.mark.parametrize("length", [3.0, 10.0, 27.0])
+@pytest.mark.parametrize("fraction", [0.2, 0.5, 0.8])
+@pytest.mark.parametrize("magnitude", [100.0, -40.0])
+@pytest.mark.parametrize("path", ["prismatic", "nonprismatic", "timoshenko"])
+def test_double_release_point_load_statics(length, fraction, magnitude, path):
+    beam = cba.Beam()
+    load = LoadPL(0, magnitude, fraction * length)
+    if path == "prismatic":
+        actual = load.get_ref(length, 4)
+    elif path == "nonprismatic":
+        section = SectionEI([("linear", [0.0, length], [1e5, 3e5])])
+        actual = beam._ref_nonprismatic(load, section, length, 4)
+    else:
+        actual = beam._ref_timoshenko(load, 1e5, 2.5e4, length, 4)
+    expected = [magnitude * (1 - fraction), 0.0, magnitude * fraction, 0.0]
+    np.testing.assert_allclose(actual, expected, rtol=1e-10, atol=1e-8)
+
+
+@pytest.mark.parametrize("etype", [1, 2, 3, 4])
+@pytest.mark.parametrize(
+    "load",
+    [
+        LoadPL(0, 100.0, 2.0),
+        LoadPL(0, 100.0, 8.0),
+        LoadUDL(0, 20.0),
+        LoadPUDL(0, 20.0, 1.0, 3.0),
+    ],
+)
+def test_release_vector_matches_matrix_condensation(etype, load):
+    # Independent test-only elimination of rotations from the unreleased matrix.
+    k = cba.Beam().k_FF(1e5, 10.0)
+    f = np.array(load.get_cnl(10.0, 1))
+    released = {1: [], 2: [3], 3: [1], 4: [1, 3]}[etype]
+    expected = f.copy()
+    if released:
+        retained = [i for i in range(4) if i not in released]
+        expected[retained] -= k[np.ix_(retained, released)] @ np.linalg.solve(
+            k[np.ix_(released, released)], f[released]
+        )
+        expected[released] = 0.0
+    np.testing.assert_allclose(
+        load.get_ref(10.0, etype), expected, rtol=1e-10, atol=1e-8
+    )
+
+
+@pytest.mark.parametrize("path", ["prismatic", "nonprismatic", "timoshenko"])
+@pytest.mark.parametrize("a", [2.0, 5.0, 8.0])
+def test_suspended_span_global_equilibrium(path, a):
+    lengths = [3.0, 10.0, 7.0]
+    ei = [2e5, 1e5, 4e5]
+    kwargs = {}
+    if path == "nonprismatic":
+        ei[1] = SectionEI([("linear", [0.0, 10.0], [1e5, 3e5])])
+    elif path == "timoshenko":
+        kwargs["GAv"] = 2.5e4
+    analysis = cba.BeamAnalysis(
+        lengths,
+        ei,
+        [-1, -1, 0, 0, 0, 0, -1, -1],
+        [[2, 2, 100.0, a, 0]],
+        eletype=[1, 4, 1],
+        **kwargs,
+    )
+    analysis.analyze()
+    va, vb = 100.0 * (1 - a / 10.0), 100.0 * a / 10.0
+    actual = analysis.beam_results.R
+    np.testing.assert_allclose(
+        actual, [va, 3.0 * va, vb, -7.0 * vb], rtol=1e-10, atol=1e-8
+    )
+    ra, ma, rb, mb = actual
+    assert ra + rb == pytest.approx(100.0, abs=1e-8)
+    assert ma + mb + 20.0 * rb == pytest.approx(100.0 * (3.0 + a), abs=1e-8)

{pycba-1.0.1 → pycba-1.0.2}/tests/test_results.py

@@ -81,3 +81,28 @@ def test_sum_incompatible_envelopes():
     env_sum = cba.Envelopes.zero_like(env1)
     with pytest.raises(ValueError, match="Cannot sum with an inconsistent envelope"):
         env_sum.sum(env2)
+
+
+def test_at_rotation_at_supports_matches_analytical():
+    """Regression test for at() returning the wrong rotation at a member's
+    end stations. A simply supported beam with a central point load has a
+    well known closed form support rotation of P*L**2 / (16*EI).
+    """
+    L = 10.0
+    P = 100.0
+    EI = 30 * 10e9 * 1e-6
+
+    beam_analysis = cba.BeamAnalysis([L], EI, supports=["pinned", "roller"])
+    beam_analysis.set_loads([[1, 2, P, L / 2, 0]])
+    beam_analysis.analyze()
+
+    theta = P * L**2 / (16 * EI)
+
+    assert beam_analysis.at(0.0)["R"] == pytest.approx(-theta)
+    assert beam_analysis.at(L)["R"] == pytest.approx(theta)
+
+    # The padding stations at a member's ends duplicate the true end
+    # stations, so both copies should agree.
+    r = beam_analysis.beam_results.results
+    assert r.R[0] == pytest.approx(r.R[1])
+    assert r.R[-2] == pytest.approx(r.R[-1])