PyCBA 0.4.1__tar.gz → 0.5.1__tar.gz

{PyCBA-0.4.1/src/PyCBA.egg-info → PyCBA-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyCBA
-Version: 0.4.1
+Version: 0.5.1
 Summary: Python Continuous Beam Analysis
 Author-email: Colin Caprani <colin.caprani@monash.edu>
 License: Apache 2.0

{PyCBA-0.4.1 → PyCBA-0.5.1/src/PyCBA.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyCBA
-Version: 0.4.1
+Version: 0.5.1
 Summary: Python Continuous Beam Analysis
 Author-email: Colin Caprani <colin.caprani@monash.edu>
 License: Apache 2.0

{PyCBA-0.4.1 → PyCBA-0.5.1}/src/pycba/__init__.py

@@ -2,7 +2,7 @@
 PyCBA - Continuous Beam Analysis in Python
 """
 
-__version__ = "0.4.1"
+__version__ = "0.5.1"
 
 from .analysis import *
 from .beam import *

{PyCBA-0.4.1 → PyCBA-0.5.1}/src/pycba/analysis.py

@@ -223,7 +223,7 @@ class BeamAnalysis:
 
         for i in range(self._n):
             dof_i = 2 * i
-            fmbr = self._beam.get_cnl(i)
+            fmbr = self._beam.get_ref(i)
             # Cumulatively apply forces in opposite direction
             f[dof_i : dof_i + 4] -= fmbr
         return f

{PyCBA-0.4.1 → PyCBA-0.5.1}/src/pycba/beam.py

@@ -220,6 +220,18 @@ class Beam:
         """
         return len(self._restraints)
 
+    @property
+    def no_fixed_restraints(self):
+        """
+        Returns the number of fixed restraints of the beam (fully-supported DOFs)
+
+        Returns
+        -------
+        no_fixed_restraints : int
+            The number of fixed restraints in the beam
+        """
+        return len(np.where(np.array(self._restraints) == -1)[0])
+
     @property
     def length(self):
         """
@@ -268,9 +280,10 @@ class Beam:
 
         return ispan, pos_in_span
 
-    def get_cnl(self, i_span: int) -> LoadCNL:
+    def get_ref(self, i_span: int) -> LoadCNL:
         """
-        Returns Consistent Nodal Loads for the member
+        Returns Released End Forces for the member; that is, the Consistent Nodal Loads
+        modified for the element type (i.e. releases)
 
         Parameters
         ----------
@@ -279,18 +292,18 @@ class Beam:
 
         Returns
         -------
-        cnl : LoadCNL
+        ref : LoadCNL
             The totalled CNL object for the member, considering all loads.
 
         """
-        cnl = np.zeros(4)
+        ref = np.zeros(4)
         L = self.mbr_lengths[i_span]
         eType = self.mbr_eletype[i_span]
 
         for load in self._loads:
             if load.i_span == i_span:
-                cnl += load.get_cnl(L, eType)
-        return cnl
+                ref += load.get_ref(L, eType)
+        return ref
 
     def get_span_k(self, i_span: int) -> np.ndarray:
         """

{PyCBA-0.4.1 → PyCBA-0.5.1}/src/pycba/inf_lines.py

@@ -119,21 +119,72 @@ class InfluenceLines:
             self.create_ils()
 
         x = self.vResults[0].results.x
-        dx = x[2] - x[1]
-        idx = np.where(np.abs(x - poi) <= dx * 1e-6)[0][0]
-        # find the nearest support to the poi
-        idxr = (
-            np.abs(np.cumsum(np.insert(self.ba.beam.mbr_lengths, 0, 0)) - poi)
-        ).argmin()
         npts = len(self.vResults)
         eta = np.zeros(npts)
 
-        for i, res in enumerate(self.vResults):
-            if load_effect == "V":
+        # Preparations for reaction ILs
+        #
+        # Get vector of the node locations
+        node_locations = np.cumsum(np.insert(self.ba.beam.mbr_lengths, 0, 0))
+        # Link the supported DOF to the index in the BeamAnalysis reactions vector
+        idx_mask = np.zeros_like(self.ba._beam.restraints)
+        idx_mask[np.where(np.array(self.ba._beam.restraints) == -1)] = np.arange(
+            self.ba.beam.no_fixed_restraints
+        )
+
+        # idx = np.abs(x - poi).argmin()
+
+        if load_effect.upper() == "V":
+            dx = x[2] - x[1]
+            idx = np.where(np.abs(x - poi) <= dx * 1e-6)[0][0]
+            for i, res in enumerate(self.vResults):
                 eta[i] = res.results.V[idx]
-            elif load_effect == "R":
-                eta[i] = res.R[idxr]
-            else:
+
+        elif load_effect.upper() == "R":
+            #
+            # Getting the correct reaction is tricky
+            #
+            # The indices of the supported DOFs wrt the node locations vector
+            vert_sups_dof_idx = np.where(np.array(self.ba._beam.restraints)[::2] == -1)[
+                0
+            ]
+            # The locations then of these supports
+            vert_sups_locs = node_locations[vert_sups_dof_idx]
+            # The index of the closest support
+            closest_vert_sup_idx = np.abs(vert_sups_locs - poi).argmin()
+            # And its value
+            closest_vert_sup = vert_sups_locs[closest_vert_sup_idx]
+            # And now the index of this support in the node locations vector
+            vert_sup_node_idx = np.where(node_locations == closest_vert_sup)[0][0]
+            # And hence its index in the overall DOFs vector
+            vert_sup_dof_idx = 2 * vert_sup_node_idx
+            # And finally the index of the support nearest the POI in the reactions vector
+            vert_sup_idx = idx_mask[vert_sup_dof_idx]
+
+            for i, res in enumerate(self.vResults):
+                eta[i] = res.R[vert_sup_idx]
+
+        elif load_effect.upper() == "MR":
+            #
+            # Follows the same logic for the vertical reaction
+            #
+            mt_sups_dof_idx = np.where(np.array(self.ba._beam.restraints)[1::2] == -1)[
+                0
+            ]
+            mt_sups_locs = node_locations[mt_sups_dof_idx]
+            closest_mt_sup_idx = np.abs(mt_sups_locs - poi).argmin()
+            closest_mt_sup = mt_sups_locs[closest_mt_sup_idx]
+            mt_sup_node_idx = np.where(node_locations == closest_mt_sup)[0][0]
+            mt_sup_dof_idx = 2 * mt_sup_node_idx + 1
+            mt_sup_idx = idx_mask[mt_sup_dof_idx]
+
+            for i, res in enumerate(self.vResults):
+                eta[i] = res.R[mt_sup_idx]
+
+        else:
+            dx = x[2] - x[1]
+            idx = np.where(np.abs(x - poi) <= dx * 1e-6)[0][0]
+            for i, res in enumerate(self.vResults):
                 eta[i] = res.results.M[idx]
 
         return (np.array(self.pos), eta)

{PyCBA-0.4.1 → PyCBA-0.5.1}/src/pycba/load.py

@@ -182,7 +182,7 @@ class Load:
         """
         self.i_span = i_span
 
-    def get_cnl(self, L, eType):
+    def get_cnl(self, L):
         # Enforce virtual base class
         raise NotImplementedError
 
@@ -215,29 +215,26 @@ class Load:
         """
         return np.heaviside(v, value)
 
-    def released_end_forces(self, cnl: LoadCNL, L: float, eType: int) -> LoadCNL:
+    def get_ref(self, L: float, eType: int) -> LoadCNL:
         """
-        The released end forces for each element type: converts the Consistent Nodal
-        Loads of the applied loading to the correct nodal loading depending on the
-        element type.
+        Returns the Released End Forces for a span of length L of element eType:
+        converts the Consistent Nodal Loads of the applied loading to the correct nodal
+        loading depending on the element type.
 
         Parameters
         ----------
-        cnl : LoadCNL
-            The nodal loading statically consistent with the externally applied loads.
         L : float
-            The length of the member.
+            The length of the member
         eType : int
-            The element type.
+            The member element type
 
         Returns
         -------
         LoadCNL
-            The nodal loads to be applied in the analysis, consistent with the element
-            type.
-
+            Released End Forces for this load type: the nodal loads to be applied in
+            the analysis, consistent with the element type.
         """
-
+        cnl = self.get_cnl(L, eType)
         ref = np.zeros(4)
         fm = 6 / (4 * L)  # flexibility coeff for moment
 
@@ -248,14 +245,14 @@ class Load:
             ref[3] = 1.0 * cnl.Mb
         elif eType == 3:  # DOF = moment at i node
             ref[0] = fm * cnl.Ma
-            ref[1] = 0.5 * cnl.Ma
+            ref[1] = 1.0 * cnl.Ma
             ref[2] = -fm * cnl.Ma
-            ref[3] = 1.0 * cnl.Ma
+            ref[3] = 0.5 * cnl.Ma
         elif eType == 4:  # keep only vertical, remove moments
-            ref[0] = 0
-            ref[1] = 1.0 * cnl.Va
-            ref[2] = 0
-            ref[3] = 1.0 * cnl.Va
+            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
@@ -319,8 +316,7 @@ class LoadUDL(Load):
             Ma=w * L**2 / 12.0,
             Mb=-w * L**2 / 12.0,
         )
-
-        return self.released_end_forces(cnl, L, eType)
+        return cnl
 
     def get_mbr_results(self, x: np.ndarray, L: float) -> MemberResults:
         """
@@ -416,8 +412,7 @@ class LoadPL(Load):
             Ma=P * a * b**2 / L**2,
             Mb=-P * a**2 * b / L**2,
         )
-        # implicit conversion to tuple in correct order
-        return self.released_end_forces(cnl, L, eType)
+        return cnl
 
     def get_mbr_results(self, x: np.ndarray, L: float) -> MemberResults:
         """
@@ -512,7 +507,7 @@ class LoadPUDL(Load):
             Mb=-(w * c / L**2) * (t * s**2 + (t - 2 * s) * c**2 / 12),
         )
         # implicit conversion to tuple in correct order
-        return self.released_end_forces(cnl, L, eType)
+        return cnl
 
     def get_mbr_results(self, x: np.ndarray, L: float) -> MemberResults:
         """
@@ -608,8 +603,7 @@ class LoadMaMb(Load):
             Ma=Ma,
             Mb=Mb,
         )
-        # implicit conversion to tuple in correct order
-        return self.released_end_forces(cnl, L, eType)
+        return cnl
 
     def get_mbr_results(self, x: np.ndarray, L: float) -> MemberResults:
         """
@@ -690,8 +684,7 @@ class LoadML(Load):
             Ma=(m * b / L**2) * (2 * a - b),
             Mb=(m * a / L**2) * (2 * b - a),
         )
-        # implicit conversion to tuple in correct order
-        return self.released_end_forces(cnl, L, eType)
+        return cnl
 
     def get_mbr_results(self, x: np.ndarray, L: float) -> MemberResults:
         """

{PyCBA-0.4.1 → PyCBA-0.5.1}/src/pycba/results.py

@@ -8,7 +8,7 @@ import numpy as np
 import matplotlib.pyplot as plt
 from scipy import integrate
 from .beam import Beam
-from .load import MemberResults, LoadMaMb
+from .load import MemberResults, LoadMaMb, LoadCNL
 from copy import deepcopy
 
 
@@ -105,7 +105,7 @@ class BeamResults:
             fmbr = np.zeros(4)
             for j in range(4):
                 fmbr[j] = np.sum(kb[j][:] * dmbr[:])
-            fmbr += beam.get_cnl(i)
+            fmbr += beam.get_ref(i)
             res = self._member_values(beam, i, fmbr, dmbr)
             # Shift x vals by location of mbr starting point
             res.x += sumL
@@ -138,6 +138,9 @@ class BeamResults:
         """
 
         L = beam.mbr_lengths[i_span]
+        EI = beam.mbr_EIs[i_span]
+        etype = beam.mbr_eletype[i_span]
+
         dx = L / self.npts
         x = np.zeros(self.npts + 3)
         x[1 : self.npts + 2] = dx * np.arange(0, self.npts + 1)
@@ -148,16 +151,29 @@ class BeamResults:
         res = MaMb.get_mbr_results(x, L)
 
         # Now get the results for all the applied loads on a simple span
+        Ma = 0
+        Mb = 0
         for load in beam._loads:
             if load.i_span != i_span:
                 continue
             res += load.get_mbr_results(x, L)
+            cnl = load.get_cnl(L, etype)
+            Ma += cnl.Ma
+            Mb += cnl.Mb
+
+        # If no releases, the rotation at i is easy
+        R0 = d[1]
+
+        # Otherwise, check account for releases
+        if etype > 1:
+            theta = (d[2] - d[0]) / L
+            phi = (L / (3 * EI)) * (-(f[1] - 0.5 * f[3]) + (Ma - 0.5 * Mb))
+            R0 = theta - phi
 
         # And superimpose end displacements using Moment-Area
         h = L / self.npts
-        EI = beam.mbr_EIs[i_span]
 
-        R = integrate.cumtrapz(res.M[1:-1], dx=h, initial=0) / EI + d[1]
+        R = integrate.cumtrapz(res.M[1:-1], dx=h, initial=0) / EI + R0
         D = integrate.cumtrapz(R, dx=h, initial=0) + d[0]
 
         res.R[1:-1] = R

PyCBA-0.5.1/tests/test_basic.py

@@ -0,0 +1,554 @@
+"""
+Basic tests for PyCBA operation
+"""
+
+import pytest
+import numpy as np
+import pycba as cba
+
+
+def test_1span_ee():
+    """
+    Test fixed-fixed beam with point load in the middle
+    """
+
+    P = 10  # kN
+    L = 10  # m
+    EI = 30 * 600e7 * 1e-6  # kNm2
+    R = [-1, -1, -1, -1]
+    LM = [[1, 2, P, 0.5 * L, 0]]
+
+    beam_analysis = cba.BeamAnalysis([L], EI, R, LM)
+    out = beam_analysis.analyze()
+    assert out == 0
+
+    Ma = beam_analysis.beam_results.results.M[1]
+    Mb = beam_analysis.beam_results.results.M[-2]
+    Mc = beam_analysis.beam_results.results.M[51]
+
+    assert Ma == pytest.approx(-P * L / 8)
+    assert Mb == pytest.approx(-P * L / 8)
+    assert Mc == pytest.approx(P * L / 8)
+
+
+def test_1span_ep():
+    """
+    Test fixed-pinned beam with point load in the middle
+    """
+
+    P = 10  # kN
+    L = 10  # m
+    EI = 30 * 600e7 * 1e-6  # kNm2
+    R = [-1, -1, -1, 0]
+    LM = [[1, 2, P, 0.5 * L, 0]]
+
+    beam_analysis = cba.BeamAnalysis([L], EI, R, LM)
+    out = beam_analysis.analyze()
+    assert out == 0
+
+    Ma = beam_analysis.beam_results.results.M[1]
+    Mb = beam_analysis.beam_results.results.M[-2]
+    Mc = beam_analysis.beam_results.results.M[51]
+
+    assert Ma == pytest.approx(-3 * P * L / 16)
+    assert Mb == pytest.approx(0)
+    assert Mc == pytest.approx(5 * P * L / 32)
+
+
+def test_1span_ep_eletype2():
+    """
+    Test fixed-pinned beam with point load in the middle, using eleType 2
+    """
+
+    P = 10  # kN
+    L = 10  # m
+    EI = 30 * 600e7 * 1e-6  # kNm2
+    R = [-1, -1, -1, -1]  # Notice, fixed-fixed supports
+    LM = [[1, 2, P, 0.5 * L, 0]]
+
+    beam_analysis = cba.BeamAnalysis([L], EI, R, LM, eletype=[2])
+    out = beam_analysis.analyze()
+    assert out == 0
+
+    Ma = beam_analysis.beam_results.results.M[1]
+    Mb = beam_analysis.beam_results.results.M[-2]
+    Mc = beam_analysis.beam_results.results.M[51]
+
+    assert Ma == pytest.approx(-3 * P * L / 16)
+    assert Mb == pytest.approx(0)
+    assert Mc == pytest.approx(5 * P * L / 32)
+
+
+def test_1span_pe():
+    """
+    Test pinned-fixed beam with point load in the middle
+    """
+
+    P = 10  # kN
+    L = 10  # m
+    EI = 30 * 600e7 * 1e-6  # kNm2
+    R = [-1, 0, -1, -1]
+    LM = [[1, 2, P, 0.5 * L, 0]]
+
+    beam_analysis = cba.BeamAnalysis([L], EI, R, LM)
+    out = beam_analysis.analyze()
+    assert out == 0
+
+    Ma = beam_analysis.beam_results.results.M[1]
+    Mb = beam_analysis.beam_results.results.M[-2]
+    Mc = beam_analysis.beam_results.results.M[51]
+
+    assert Ma == pytest.approx(0)
+    assert Mb == pytest.approx(-3 * P * L / 16)
+    assert Mc == pytest.approx(5 * P * L / 32)
+
+
+def test_1span_pe_eletype3():
+    """
+    Test pinned-fixed beam with point load in the middle, using eleType 3
+    """
+
+    P = 10  # kN
+    L = 10  # m
+    EI = 30 * 600e7 * 1e-6  # kNm2
+    R = [-1, -1, -1, -1]  # Notice, fixed-fixed supports
+    LM = [[1, 2, P, 0.5 * L, 0]]
+
+    beam_analysis = cba.BeamAnalysis([L], EI, R, LM, eletype=[3])
+    out = beam_analysis.analyze()
+    assert out == 0
+
+    Ma = beam_analysis.beam_results.results.M[1]
+    Mb = beam_analysis.beam_results.results.M[-2]
+    Mc = beam_analysis.beam_results.results.M[51]
+
+    assert Ma == pytest.approx(0)
+    assert Mb == pytest.approx(-3 * P * L / 16)
+    assert Mc == pytest.approx(5 * P * L / 32)
+
+
+def test_1span_pp():
+    """
+    Test pinned-pinned beam with point load in the middle
+    """
+
+    P = 10  # kN
+    L = 10  # m
+    EI = 30 * 600e7 * 1e-6  # kNm2
+    R = [-1, 0, -1, 0]
+    LM = [[1, 2, P, 0.5 * L, 0]]
+
+    beam_analysis = cba.BeamAnalysis([L], EI, R, LM)
+    out = beam_analysis.analyze()
+    assert out == 0
+
+    Ma = beam_analysis.beam_results.results.M[1]
+    Mb = beam_analysis.beam_results.results.M[-2]
+    Mc = beam_analysis.beam_results.results.M[51]
+
+    assert Ma == pytest.approx(0)
+    assert Mb == pytest.approx(0)
+    assert Mc == pytest.approx(P * L / 4)
+
+
+def test_1span_pp_eletype4():
+    """
+    Test pinned-pinned beam with point load in the middle, using eleType 4
+    """
+
+    P = 10  # kN
+    L = 10  # m
+    EI = 30 * 600e7 * 1e-6  # kNm2
+    R = [-1, -1, -1, -1]  # Notice, fixed-fixed supports
+    LM = [[1, 2, P, 0.5 * L, 0]]
+
+    beam_analysis = cba.BeamAnalysis([L], EI, R, LM, eletype=[4])
+    out = beam_analysis.analyze()
+    assert out == 0
+
+    Ma = beam_analysis.beam_results.results.M[1]
+    Mb = beam_analysis.beam_results.results.M[-2]
+    Mc = beam_analysis.beam_results.results.M[51]
+
+    assert Ma == pytest.approx(0)
+    assert Mb == pytest.approx(0)
+    assert Mc == pytest.approx(P * L / 4)
+
+
+def get_1span_beam_def(etype):
+    P = 10  # kN
+    L = 10  # m
+    a = 0.25 * L
+    EI = 30 * 600e7 * 1e-6  # kNm2
+    R = [-1, -1, -1, -1]  # Notice, fixed-fixed supports
+    LM = [[1, 2, P, a, 0]]
+
+    beam_analysis = cba.BeamAnalysis([L], EI, R, LM, eletype=[etype])
+    beam_analysis.analyze()
+
+    d = beam_analysis.beam_results.results.D
+    dmax = min(d)
+
+    return P, L, EI, a, dmax
+
+
+def test_1span_def_ff():
+    """
+    Test fixed-fixed beam deflection for off-centre point load
+    """
+
+    P, L, EI, aa, dmax = get_1span_beam_def(etype=1)
+
+    # a>b
+    b = aa
+    a = L - b
+    ymax = -(2 * P * a**3 * b**2) / (3 * (3 * a + b) ** 2 * EI)
+
+    assert dmax == pytest.approx(ymax, abs=1e-6)
+
+
+def test_1span_def_fp():
+    """
+    Test fixed-pinned beam deflection for off-centre point load
+    """
+    P, L, EI, aa, dmax = get_1span_beam_def(etype=2)
+
+    a = aa
+    b = L - a
+    ymax = -(P * a**2 * b) / (6 * EI) * (b / (3 * L - a)) ** 0.5
+
+    assert dmax == pytest.approx(ymax, abs=1e-6)
+
+
+def test_1span_def_pf():
+    """
+    Test pinned-fixed beam deflection for off-centre point load
+    """
+    P, L, EI, aa, dmax = get_1span_beam_def(etype=3)
+
+    b = aa
+    ymax = -(P * b) / (3 * EI) * (L**2 - b**2) ** 3 / (3 * L**2 - b**2) ** 2
+
+    assert dmax == pytest.approx(ymax, abs=1e-6)
+
+
+def test_1span_def_pp():
+    """
+    Test pinned-pinned beam deflection for off-centre point load
+    """
+    P, L, EI, aa, dmax = get_1span_beam_def(etype=4)
+
+    a = aa
+    ymax = -(3**0.5) * P * a * (L**2 - a**2) ** 1.5 / (27 * EI * L)
+
+    assert dmax == pytest.approx(ymax, abs=1e-6)
+
+
+def test_2span_udl():
+    """
+    Execute a two-span beam analysis and check the reaction results.
+    Uses a direct definition of the LM
+    """
+
+    L = [7.5, 7.0]
+    EI = 30 * 600e7 * 1e-6  # kNm2
+    R = [-1, 0, -1, 0, -1, 0]
+    LM = [[1, 1, 20, 0, 0], [2, 1, 20, 0, 0]]
+
+    beam_analysis = cba.BeamAnalysis(L, EI, R, LM)
+    out = beam_analysis.analyze()
+    assert out == 0
+
+    r = beam_analysis.beam_results.R
+    assert r == pytest.approx([57.41666667, 181.42261905, 51.16071429])
+
+    dmax = max(beam_analysis.beam_results.results.D)
+    dmin = min(beam_analysis.beam_results.results.D)
+    assert [dmax, dmin] == pytest.approx(
+        [1.0118938958333364e-05, -0.0020629648925781247], abs=1e-6
+    )
+
+
+def test_2span_load_wrappers():
+    """
+    Execute a two-span beam analysis and check the reaction results.
+    Uses the wrappers for defining loads.
+    """
+
+    L = [7.5, 7.0]
+    EI = 30 * 600e7 * 1e-6  # kNm2
+    R = [-1, 0, -1, 0, -1, 0]
+
+    beam_analysis = cba.BeamAnalysis(L, EI, R)
+    beam_analysis.add_pl(1, 40, 3.5)
+    beam_analysis.add_udl(1, 10)
+    beam_analysis.add_pudl(2, 20, 2.0, 3.0)
+    beam_analysis.add_ml(2, 50, 3)
+
+    out = beam_analysis.analyze()
+    assert out == 0
+
+    r = beam_analysis.beam_results.R
+    assert r == pytest.approx([45.41648878, 121.10155896, 8.48195226])
+
+    dmax = max(beam_analysis.beam_results.results.D)
+    dmin = min(beam_analysis.beam_results.results.D)
+    assert [dmax, dmin] == pytest.approx(
+        [0.00011753212898873195, -0.0023044064201367506]
+    )
+
+
+def test_2span_pl_ml_fixed():
+    """
+    Execute a two-span beam analysis and check the reaction results
+    """
+
+    L = [5.0, 5.0]
+    EI = 30 * 600e7 * 1e-6  # kNm2
+    R = [-1, 0, -1, 0, -1, -1]
+    LM = [[1, 2, 50, 3, 0], [2, 4, 50, 2, 0]]
+
+    beam_analysis = cba.BeamAnalysis(L, EI, R, LM)
+    out = beam_analysis.analyze()
+    assert out == 0
+
+    r = beam_analysis.beam_results.R
+    assert r == pytest.approx([14.0, 57.6, -21.6, 28.0])
+
+    dmax = max(beam_analysis.beam_results.results.D)
+    dmin = min(beam_analysis.beam_results.results.D)
+    assert [dmax, dmin] == pytest.approx(
+        [0.00017414416666666662, -0.00042251493055555565], abs=1e-6
+    )
+
+
+def test_3span_diff_settlement():
+    L = [15, 15, 15]
+    EI = 30 * np.array([500e8, 500e8, 500e8]) * 1e-6  # kNm2
+    R = [-1, 0, 1e8, 0, 1e8, 0, -1, 0]
+    LM = [[1, 1, 20, 0, 0], [2, 1, 20, 0, 0], [3, 1, 20, 0, 0]]
+
+    beam_analysis = cba.BeamAnalysis(L, EI, R, LM)
+    out = beam_analysis.analyze()
+    assert out == 0
+
+    r = beam_analysis.beam_results.R
+    assert r == pytest.approx([120.00175999, 120.00175999])
+
+    dmax = max(beam_analysis.beam_results.results.D)
+    dmin = min(beam_analysis.beam_results.results.D)
+    assert [dmax, dmin] == pytest.approx(
+        [0.0002778734578837245, -0.004648274177216889], abs=1e-5
+    )
+
+
+def test_3span_subframe():
+    L = [6, 8, 6]
+    EI = 30 * np.array([50e8, 50e8, 50e8]) * 1e-6
+    R = [-1, 486e9, -1, 486e9, -1, 486e9, -1, 486e9]
+    LM = [[1, 1, 10, 0, 0], [2, 1, 20, 0, 0], [3, 1, 10, 0, 0]]
+
+    beam_analysis = cba.BeamAnalysis(L, EI, R, LM)
+    out = beam_analysis.analyze()
+    assert out == 0
+
+    r = beam_analysis.beam_results.R
+    assert r == pytest.approx([29.99999451, 110.00000549, 110.00000549, 29.99999451])
+
+    dmax = max(beam_analysis.beam_results.results.D)
+    dmin = min(beam_analysis.beam_results.results.D)
+    assert [dmax, dmin] == pytest.approx([0.0, -0.0014222225377228067], abs=1e-6)
+
+
+def test_4span_posttensioned():
+    L = [6, 8, 6, 8]
+    EI = 30 * np.array([100e8, 100e8, 100e8, 100e8]) * 1e-6  # kNm2
+    R = [-1, 0, -1, 0, -1, 0, -1, 0, -1, 0]
+    LM = [
+        [1, 3, 20, 0, 1],
+        [1, 3, -10, 1, 4],
+        [1, 3, 20, 5, 1],
+        [1, 4, 50, 0, 0],
+        [2, 3, 20, 0, 1.5],
+        [2, 3, -10, 1.5, 5],
+        [2, 3, 20, 6.5, 1.5],
+        [3, 3, 20, 0, 1],
+        [3, 3, -10, 1, 4],
+        [3, 3, 20, 5, 1],
+        [4, 3, 20, 0, 1.5],
+        [4, 3, -10, 1.5, 5],
+        [4, 3, 20, 6.5, 1.5],
+        [4, 4, -75, 8, 0],
+    ]
+    beam_analysis = cba.BeamAnalysis(L, EI, R, LM)
+    out = beam_analysis.analyze()
+    assert out == 0
+
+    r = beam_analysis.beam_results.R
+    assert r == pytest.approx(
+        [14.87359893, -13.64621406, 15.69634808, -17.62411672, 20.70038377]
+    )
+
+    dmax = max(beam_analysis.beam_results.results.D)
+    dmin = min(beam_analysis.beam_results.results.D)
+    assert [dmax, dmin] == pytest.approx(
+        [0.0012715273282923978, -0.00013897273612280755], abs=1e-6
+    )
+
+
+def test_2span_pinned():
+    w = 20
+    L = [10, 10]
+    EI = 30 * np.array([600e7, 600e7]) * 1e-6
+    eType = [2, 1]
+    R = [-1, 0, -1, 0, -1, 0]
+    LM = [[1, 1, w, 0, 0], [2, 1, w, 0, 0]]
+    beam_analysis = cba.BeamAnalysis(L, EI, R, LM, eType)
+    out = beam_analysis.analyze()
+    assert out == 0
+
+    r = beam_analysis.beam_results.R
+    assert r == pytest.approx([w * 5, w * 10, w * 5])
+
+    dmax = max(beam_analysis.beam_results.results.D)
+    dmin = min(beam_analysis.beam_results.results.D)
+    assert [dmax, dmin] == pytest.approx([0, -5 * w * L[0] ** 4 / (384 * EI[0])])
+
+
+def test_3span_hinge():
+    L = [5, 5, 10]
+    EI = 30 * 600e7 * np.ones(len(L)) * 1e-6
+    eType = [2, 1, 1]
+    R = [-1, -1, 0, 0, -1, 0, -1, 0]
+    LM = [[3, 2, 20, 5, 0]]
+    beam_analysis = cba.BeamAnalysis(L, EI, R, LM, eType)
+    out = beam_analysis.analyze()
+    assert out == 0
+
+    r = beam_analysis.beam_results.R
+    assert r == pytest.approx([-3.75, -18.75, 15.625, 8.125])
+
+    dmax = max(beam_analysis.beam_results.results.D)
+    dmin = min(beam_analysis.beam_results.results.D)
+    assert [dmax, dmin] == pytest.approx(
+        [0.0008680555555555557, -0.0016677326388888887], abs=1e-6
+    )
+
+
+def test_flipped_hinge():
+    # 3-span with etype 2
+    L = [5, 5, 10]
+    EI = 30 * 600e7 * np.ones(len(L)) * 1e-6
+    eType = [2, 1, 1]
+    R = [-1, -1, 0, 0, -1, 0, -1, -1]
+    LM = [[3, 2, 20, 5, 0]]
+    beam_analysis = cba.BeamAnalysis(L, EI, R, LM, eType)
+    out = beam_analysis.analyze()
+    d1 = beam_analysis.beam_results.results.D
+
+    # Same beam flipped, etype 3
+    L = [10, 5, 5]
+    EI = 30 * 600e7 * np.ones(len(L)) * 1e-6
+    eType = [1, 1, 3]
+    R = [-1, -1, -1, 0, 0, 0, -1, -1]
+    LM = [[1, 2, 20, 5, 0]]
+    beam_analysis = cba.BeamAnalysis(L, EI, R, LM, eType)
+    beam_analysis.analyze()
+    d2 = beam_analysis.beam_results.results.D
+
+    # Confirm flipped deflected shapes are close
+    assert d1 == pytest.approx(d2[::-1], abs=1e-7)
+
+
+def test_hinges():
+    # Based on example in Logan's First Course in FE, Ex. 4.10
+    a = 4
+    b = 2
+    P = 20
+    L = [a, b]
+    EI = 30 * 600e7 * 1e-6
+    EIvec = EI * np.ones(len(L))
+    eType = [1, 3]
+    R = [-1, -1, 0, 0, -1, -1]
+    LM = [[1, 2, P, a, 0]]
+    beam_analysis = cba.BeamAnalysis(L, EIvec, R, LM, eType)
+    beam_analysis.analyze()
+
+    phi2_1 = beam_analysis.beam_results.vRes[0].R[-2]
+    phi2_1_theory = -(a**2 * b**3 * P) / (2 * (b**3 + a**3) * EI)
+
+    assert phi2_1_theory == pytest.approx(phi2_1)
+
+    phi2_2 = beam_analysis.beam_results.vRes[1].R[1]
+    phi2_2_theory = (a**3 * b**2 * P) / (2 * (b**3 + a**3) * EI)
+
+    assert phi2_2_theory == pytest.approx(phi2_2)
+
+
+def test_3span_hinge_il():
+    L = [5, 5, 10]
+    EI = 30 * 600e7 * np.ones(len(L)) * 1e-6
+    eType = [2, 1, 1]
+    R = [-1, -1, 0, 0, -1, 0, -1, 0]
+
+    ils = cba.InfluenceLines(L, EI, R, eType)
+    ils.create_ils(step=0.05)
+    (x, y) = ils.get_il(15.0, "V")
+
+    assert [min(y), max(y)] == pytest.approx([-0.4009469062500001, 0.59375], abs=1e-6)
+
+
+def test_moment_load():
+    L = [10.0]
+    EI = 30 * 600e7 * np.ones(len(L)) * 1e-6
+    eType = [1]
+    R = [-1, 0, -1, 0]
+
+    for a in [0, 5, 10]:
+        LM = [[1, 4, 10, a, 0]]
+        beam_analysis = cba.BeamAnalysis(L, EI, R, LM, eType)
+        out = beam_analysis.analyze()
+        assert out == 0
+
+        # Check deflection closes
+        d = beam_analysis.beam_results.D[[0, 2]]
+        assert d == pytest.approx([0.0, 0.0])
+
+
+def test_envelopes():
+    L = [6, 4, 6]
+    EI = 30 * 10e9 * 1e-6
+    R = [-1, 0, -1, 0, -1, 0, -1, 0]
+    beam_analysis = cba.BeamAnalysis(L, EI, R)
+
+    LMg = [[1, 1, 25, 0, 0], [2, 1, 25, 0, 0], [3, 1, 25, 0, 0]]
+    γg_max = 1.4
+    γg_min = 1.0
+    LMq = [[1, 1, 10, 0, 0], [2, 1, 10, 0, 0], [3, 1, 10, 0, 0]]
+    γq_max = 1.6
+    γq_min = 0
+
+    lp = cba.LoadPattern(beam_analysis)
+    lp.set_dead_loads(LMg, γg_max, γg_min)
+    lp.set_live_loads(LMq, γq_max, γq_min)
+    env = lp.analyze()
+
+    m_locs = np.array([3, 6, 8, 10, 13])
+    idx = [(np.abs(env.x - x)).argmin() for x in m_locs]
+    assert np.allclose(
+        env.Mmax[idx], np.array([163.79, 0, 11.75, 0, 163.79]), atol=1e-2
+    )
+    assert np.allclose(
+        env.Mmin[idx], np.array([0, -163.38, -81.42, -163.38, 0]), atol=1e-2
+    )
+
+    n = beam_analysis.beam_results.npts
+    nspans = beam_analysis.beam.no_spans
+    Vmax = np.array(
+        [np.max(env.Vmax[i * (n + 3) : (i + 1) * (n + 3)]) for i in range(nspans)]
+    )
+    assert np.allclose(Vmax, np.array([131.1, 123.94, 180.23]), atol=1e-2)
+    Vmin = np.array(
+        [np.min(env.Vmin[i * (n + 3) : (i + 1) * (n + 3)]) for i in range(nspans)]
+    )
+    assert np.allclose(Vmin, np.array([-180.23, -123.94, -131.10]), atol=1e-2)

{PyCBA-0.4.1 → PyCBA-0.5.1}/tests/test_inf_lines.py

@@ -177,7 +177,7 @@ def test_parse_beam_notation():
     assert eType == [1, 2, 1, 1]
 
 
-def test_distcretization():
+def test_discretization():
     """
     Confirm that poi rounding to find the closest idx for ILs works
     """

PyCBA-0.4.1/tests/test_basic.py

@@ -1,267 +0,0 @@
-"""
-Basic tests for PyCBA operation
-"""
-
-import pytest
-import numpy as np
-import pycba as cba
-
-
-def test_2span_udl():
-    """
-    Execute a two-span beam analysis and check the reaction results.
-    Uses a direct definition of the LM
-    """
-
-    L = [7.5, 7.0]
-    EI = 30 * 600e7 * 1e-6  # kNm2
-    R = [-1, 0, -1, 0, -1, 0]
-    LM = [[1, 1, 20, 0, 0], [2, 1, 20, 0, 0]]
-
-    beam_analysis = cba.BeamAnalysis(L, EI, R, LM)
-    out = beam_analysis.analyze()
-    assert out == 0
-
-    r = beam_analysis.beam_results.R
-    assert r == pytest.approx([57.41666667, 181.42261905, 51.16071429])
-
-    dmax = max(beam_analysis.beam_results.results.D)
-    dmin = min(beam_analysis.beam_results.results.D)
-    assert [dmax, dmin] == pytest.approx(
-        [1.0118938958333364e-05, -0.0020629648925781247], abs=1e-6
-    )
-
-
-def test_2span_load_wrappers():
-    """
-    Execute a two-span beam analysis and check the reaction results.
-    Uses the wrappers for defining loads.
-    """
-
-    L = [7.5, 7.0]
-    EI = 30 * 600e7 * 1e-6  # kNm2
-    R = [-1, 0, -1, 0, -1, 0]
-
-    beam_analysis = cba.BeamAnalysis(L, EI, R)
-    beam_analysis.add_pl(1, 40, 3.5)
-    beam_analysis.add_udl(1, 10)
-    beam_analysis.add_pudl(2, 20, 2.0, 3.0)
-    beam_analysis.add_ml(2, 50, 3)
-
-    out = beam_analysis.analyze()
-    assert out == 0
-
-    r = beam_analysis.beam_results.R
-    assert r == pytest.approx([45.41648878, 121.10155896, 8.48195226])
-
-    dmax = max(beam_analysis.beam_results.results.D)
-    dmin = min(beam_analysis.beam_results.results.D)
-    assert [dmax, dmin] == pytest.approx(
-        [0.00011753212898873195, -0.0023044064201367506]
-    )
-
-
-def test_2span_pl_ml_fixed():
-    """
-    Execute a two-span beam analysis and check the reaction results
-    """
-
-    L = [5.0, 5.0]
-    EI = 30 * 600e7 * 1e-6  # kNm2
-    R = [-1, 0, -1, 0, -1, -1]
-    LM = [[1, 2, 50, 3, 0], [2, 4, 50, 2, 0]]
-
-    beam_analysis = cba.BeamAnalysis(L, EI, R, LM)
-    out = beam_analysis.analyze()
-    assert out == 0
-
-    r = beam_analysis.beam_results.R
-    assert r == pytest.approx([14.0, 57.6, -21.6, 28.0])
-
-    dmax = max(beam_analysis.beam_results.results.D)
-    dmin = min(beam_analysis.beam_results.results.D)
-    assert [dmax, dmin] == pytest.approx(
-        [0.00017414416666666662, -0.00042251493055555565], abs=1e-6
-    )
-
-
-def test_3span_diff_settlement():
-    L = [15, 15, 15]
-    EI = 30 * np.array([500e8, 500e8, 500e8]) * 1e-6  # kNm2
-    R = [-1, 0, 1e8, 0, 1e8, 0, -1, 0]
-    LM = [[1, 1, 20, 0, 0], [2, 1, 20, 0, 0], [3, 1, 20, 0, 0]]
-
-    beam_analysis = cba.BeamAnalysis(L, EI, R, LM)
-    out = beam_analysis.analyze()
-    assert out == 0
-
-    r = beam_analysis.beam_results.R
-    assert r == pytest.approx([120.00175999, 120.00175999])
-
-    dmax = max(beam_analysis.beam_results.results.D)
-    dmin = min(beam_analysis.beam_results.results.D)
-    assert [dmax, dmin] == pytest.approx(
-        [0.0002778734578837245, -0.004648274177216889], abs=1e-6
-    )
-
-
-def test_3span_subframe():
-    L = [6, 8, 6]
-    EI = 30 * np.array([50e8, 50e8, 50e8]) * 1e-6
-    R = [-1, 486e9, -1, 486e9, -1, 486e9, -1, 486e9]
-    LM = [[1, 1, 10, 0, 0], [2, 1, 20, 0, 0], [3, 1, 10, 0, 0]]
-
-    beam_analysis = cba.BeamAnalysis(L, EI, R, LM)
-    out = beam_analysis.analyze()
-    assert out == 0
-
-    r = beam_analysis.beam_results.R
-    assert r == pytest.approx([29.99999451, 110.00000549, 110.00000549, 29.99999451])
-
-    dmax = max(beam_analysis.beam_results.results.D)
-    dmin = min(beam_analysis.beam_results.results.D)
-    assert [dmax, dmin] == pytest.approx([0.0, -0.0014222225377228067], abs=1e-6)
-
-
-def test_4span_posttensioned():
-    L = [6, 8, 6, 8]
-    EI = 30 * np.array([100e8, 100e8, 100e8, 100e8]) * 1e-6  # kNm2
-    R = [-1, 0, -1, 0, -1, 0, -1, 0, -1, 0]
-    LM = [
-        [1, 3, 20, 0, 1],
-        [1, 3, -10, 1, 4],
-        [1, 3, 20, 5, 1],
-        [1, 4, 50, 0, 0],
-        [2, 3, 20, 0, 1.5],
-        [2, 3, -10, 1.5, 5],
-        [2, 3, 20, 6.5, 1.5],
-        [3, 3, 20, 0, 1],
-        [3, 3, -10, 1, 4],
-        [3, 3, 20, 5, 1],
-        [4, 3, 20, 0, 1.5],
-        [4, 3, -10, 1.5, 5],
-        [4, 3, 20, 6.5, 1.5],
-        [4, 4, -75, 8, 0],
-    ]
-    beam_analysis = cba.BeamAnalysis(L, EI, R, LM)
-    out = beam_analysis.analyze()
-    assert out == 0
-
-    r = beam_analysis.beam_results.R
-    assert r == pytest.approx(
-        [14.87359893, -13.64621406, 15.69634808, -17.62411672, 20.70038377]
-    )
-
-    dmax = max(beam_analysis.beam_results.results.D)
-    dmin = min(beam_analysis.beam_results.results.D)
-    assert [dmax, dmin] == pytest.approx(
-        [0.0012715273282923978, -0.00013897273612280755], abs=1e-6
-    )
-
-
-def test_2span_pinned():
-    w = 20
-    L = [10, 10]
-    EI = 30 * np.array([600e7, 600e7]) * 1e-6
-    eType = [2, 1]
-    R = [-1, 0, -1, 0, -1, 0]
-    LM = [[1, 1, w, 0, 0], [2, 1, w, 0, 0]]
-    beam_analysis = cba.BeamAnalysis(L, EI, R, LM, eType)
-    out = beam_analysis.analyze()
-    assert out == 0
-
-    r = beam_analysis.beam_results.R
-    assert r == pytest.approx([w * 5, w * 10, w * 5])
-
-    dmax = max(beam_analysis.beam_results.results.D)
-    dmin = min(beam_analysis.beam_results.results.D)
-    assert [dmax, dmin] == pytest.approx([0, -5 * w * L[0] ** 4 / (384 * EI[0])])
-
-
-def test_3span_hinge():
-    L = [5, 5, 10]
-    EI = 30 * 600e7 * np.ones(len(L)) * 1e-6
-    eType = [2, 1, 1]
-    R = [-1, -1, 0, 0, -1, 0, -1, 0]
-    LM = [[3, 2, 20, 5, 0]]
-    beam_analysis = cba.BeamAnalysis(L, EI, R, LM, eType)
-    out = beam_analysis.analyze()
-    assert out == 0
-
-    r = beam_analysis.beam_results.R
-    assert r == pytest.approx([-3.75, -18.75, 15.625, 8.125])
-
-    dmax = max(beam_analysis.beam_results.results.D)
-    dmin = min(beam_analysis.beam_results.results.D)
-    assert [dmax, dmin] == pytest.approx(
-        [0.0008680555555555557, -0.0016677326388888887], abs=1e-6
-    )
-
-
-def test_3span_hinge_il():
-    L = [5, 5, 10]
-    EI = 30 * 600e7 * np.ones(len(L)) * 1e-6
-    eType = [2, 1, 1]
-    R = [-1, -1, 0, 0, -1, 0, -1, 0]
-
-    ils = cba.InfluenceLines(L, EI, R, eType)
-    ils.create_ils(step=0.05)
-    (x, y) = ils.get_il(15.0, "V")
-
-    assert [min(y), max(y)] == pytest.approx([-0.4009469062500001, 0.59375], abs=1e-6)
-
-
-def test_moment_load():
-    L = [10.0]
-    EI = 30 * 600e7 * np.ones(len(L)) * 1e-6
-    eType = [1]
-    R = [-1, 0, -1, 0]
-
-    for a in [0, 5, 10]:
-        LM = [[1, 4, 10, a, 0]]
-        beam_analysis = cba.BeamAnalysis(L, EI, R, LM, eType)
-        out = beam_analysis.analyze()
-        assert out == 0
-
-        # Check deflection closes
-        d = beam_analysis.beam_results.D[[0, 2]]
-        assert d == pytest.approx([0.0, 0.0])
-
-
-def test_envelopes():
-    L = [6, 4, 6]
-    EI = 30 * 10e9 * 1e-6
-    R = [-1, 0, -1, 0, -1, 0, -1, 0]
-    beam_analysis = cba.BeamAnalysis(L, EI, R)
-
-    LMg = [[1, 1, 25, 0, 0], [2, 1, 25, 0, 0], [3, 1, 25, 0, 0]]
-    γg_max = 1.4
-    γg_min = 1.0
-    LMq = [[1, 1, 10, 0, 0], [2, 1, 10, 0, 0], [3, 1, 10, 0, 0]]
-    γq_max = 1.6
-    γq_min = 0
-
-    lp = cba.LoadPattern(beam_analysis)
-    lp.set_dead_loads(LMg, γg_max, γg_min)
-    lp.set_live_loads(LMq, γq_max, γq_min)
-    env = lp.analyze()
-
-    m_locs = np.array([3, 6, 8, 10, 13])
-    idx = [(np.abs(env.x - x)).argmin() for x in m_locs]
-    assert np.allclose(
-        env.Mmax[idx], np.array([163.79, 0, 11.75, 0, 163.79]), atol=1e-2
-    )
-    assert np.allclose(
-        env.Mmin[idx], np.array([0, -163.38, -81.42, -163.38, 0]), atol=1e-2
-    )
-
-    n = beam_analysis.beam_results.npts
-    nspans = beam_analysis.beam.no_spans
-    Vmax = np.array(
-        [np.max(env.Vmax[i * (n + 3) : (i + 1) * (n + 3)]) for i in range(nspans)]
-    )
-    assert np.allclose(Vmax, np.array([131.1, 123.94, 180.23]), atol=1e-2)
-    Vmin = np.array(
-        [np.min(env.Vmin[i * (n + 3) : (i + 1) * (n + 3)]) for i in range(nspans)]
-    )
-    assert np.allclose(Vmin, np.array([-180.23, -123.94, -131.10]), atol=1e-2)