PyCBA 0.3__tar.gz → 0.4.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyCBA
-Version: 0.3
+Version: 0.4.1
 Summary: Python Continuous Beam Analysis
 Author-email: Colin Caprani <colin.caprani@monash.edu>
 License: Apache 2.0
@@ -49,3 +49,4 @@ One of the main functions of `PyCBA` is that the basic analysis engine forms the
 
 - Influence line generation
 - Moving load analysis for bridges, targeted at bridge access assessments
+- Load patterning and enveloping

{PyCBA-0.3 → PyCBA-0.4.1}/README.md

@@ -14,3 +14,4 @@ One of the main functions of `PyCBA` is that the basic analysis engine forms the
 
 - Influence line generation
 - Moving load analysis for bridges, targeted at bridge access assessments
+- Load patterning and enveloping

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyCBA
-Version: 0.3
+Version: 0.4.1
 Summary: Python Continuous Beam Analysis
 Author-email: Colin Caprani <colin.caprani@monash.edu>
 License: Apache 2.0
@@ -49,3 +49,4 @@ One of the main functions of `PyCBA` is that the basic analysis engine forms the
 
 - Influence line generation
 - Moving load analysis for bridges, targeted at bridge access assessments
+- Load patterning and enveloping

{PyCBA-0.3 → PyCBA-0.4.1}/src/PyCBA.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ src/pycba/beam.py
 src/pycba/bridge.py
 src/pycba/inf_lines.py
 src/pycba/load.py
+src/pycba/pattern.py
 src/pycba/results.py
 src/pycba/utils.py
 src/pycba/vehicle.py

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

@@ -2,7 +2,7 @@
 PyCBA - Continuous Beam Analysis in Python
 """
 
-__version__ = "0.3"
+__version__ = "0.4.1"
 
 from .analysis import *
 from .beam import *
@@ -12,3 +12,4 @@ from .inf_lines import *
 from .utils import *
 from .bridge import *
 from .vehicle import *
+from .pattern import *

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

@@ -351,7 +351,8 @@ class BeamAnalysis:
 
         ax = axs[0]
         ax.plot([0, L], [0, 0], "k", lw=2)
-        ax.plot(res.x, -res.M, "r")
+        ax.plot(res.x, res.M, "r")
+        ax.invert_yaxis()
         ax.grid()
         ax.set_ylabel("Bending Moment (kNm)")
 

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

@@ -799,7 +799,7 @@ def parse_LM(LM: LoadMatrix) -> List[Load]:
     return loads
 
 
-def add_LM(LM1: LoadMatrix, LM2: LoadMatrix):
+def add_LM(LM1: LoadMatrix, LM2: LoadMatrix) -> LoadMatrix:
     """
     Adds two load matrices and returns the sum; this enables superposition
 
@@ -824,3 +824,35 @@ def add_LM(LM1: LoadMatrix, LM2: LoadMatrix):
         LM.append(load)
 
     return LM
+
+
+def factor_LM(LM: LoadMatrix, gamma: float) -> LoadMatrix:
+    """
+    Applies a factor to the loads in a `LoadMatrix` object
+
+    Parameters
+    ----------
+    LM : LoadMatrix
+        The `LoadMatrix` object
+
+    gamma : float
+        A factor to apply to the load magnitudes
+
+    Returns
+    -------
+    LM : LoadMatrix
+        The factored `LoadMatrix` object
+    """
+    LMnew = []
+    for load in LM:
+        i_span = load[0]
+        l_type = load[1]
+        mag = gamma * load[2]
+        if l_type == 1:  # UDL
+            LMnew.append([i_span, l_type, mag])
+        elif l_type == 2 or l_type == 4:  # PL or ML
+            LMnew.append([i_span, l_type, mag, load[3]])
+        else:  # PUDL
+            LMnew.append([i_span, l_type, mag, load[3], load[4]])
+
+    return LMnew

PyCBA-0.4.1/src/pycba/pattern.py

@@ -0,0 +1,164 @@
+"""
+PyCBA - Continuous Beam Analysis - Load Patterning Module
+"""
+
+from __future__ import annotations  # https://bit.ly/3KYiL2o
+from typing import Optional, Union, Dict, List
+import numpy as np
+import matplotlib.pyplot as plt
+from .analysis import BeamAnalysis
+from .results import Envelopes, BeamResults
+from .load import LoadMatrix
+
+
+class LoadPattern:
+    """
+    Automatically patterns dead and live loads to achieve critical load effects.
+    """
+
+    def __init__(self, ba: BeamAnalysis):
+        """
+        Initialize the LoadPattern class with the beam.
+
+        Parameters
+        ----------
+        ba : BeamAnalysis, optional
+            A :class:`pycba.analysis.BeamAnalysis` object. The default is None.
+
+        Returns
+        -------
+        None.
+        """
+
+        self.ba = ba
+        self.LMg = None
+        self.LMq = None
+        self.gamma_g_min = 0
+        self.gamma_g_max = 0
+        self.gamma_q_min = 0
+        self.gamma_q_max = 0
+
+    def set_dead_loads(self, LM: LoadMatrix, gamma_max: float, gamma_min: float):
+        """
+        Set the nominal dead loads acting on the beam, and the maximum and
+        minimum load factor.
+
+        Parameters
+        ----------
+        LM : List[List[Union[int, float]]]
+            The load matrix for the beam, for this loadcase.
+        gamma_max : float
+            The maximum load factor.
+        gamma_min : float
+            The minimum load factor.
+
+        Returns
+        -------
+        None.
+        """
+
+        self.LMg = LM
+        self.gamma_g_max = gamma_max
+        self.gamma_g_min = gamma_min
+
+    def set_live_loads(self, LM: LoadMatrix, gamma_max: float, gamma_min: float):
+        """
+        Set the nominal live loads acting on the beam, and the maximum and
+        minimum load factor.
+
+        Parameters
+        ----------
+        LM : List[List[Union[int, float]]]
+            The load matrix for the beam, for this loadcase.
+        gamma_max : float
+            The maximum load factor.
+        gamma_min : float
+            The minimum load factor.
+
+        Returns
+        -------
+        None.
+        """
+
+        self.LMq = LM
+        self.gamma_q_max = gamma_max
+        self.gamma_q_min = gamma_min
+
+    def analyze(self, npts: Optional[int] = None) -> Envelopes:
+        """
+        Conduct the load patterning analysis.
+
+        Parameters
+        ----------
+        npts : Optional[int]
+            The number of evaluation points along a member for load effects.
+
+        Returns
+        -------
+        Envelopes : `pycba.Envelopes`
+            The load effect envelopes from the patterning.
+        """
+
+        # Helper function to get the BeamResults object easily
+        def analyze_loadcase(w):
+            self.ba.set_loads(w.tolist())
+            self.ba.analyze(npts)
+            return self.ba.beam_results
+
+        # Basic copies of the load matrices
+        wg = np.array(self.LMg)
+        wq = np.array(self.LMq)
+        gr, gc = wg.shape
+        qr, qc = wq.shape
+        w = np.zeros((gr + qr, max(gc, qc)))
+        wmax = w.copy()
+        wmin = w.copy()
+
+        # Maximum load matrix
+        wmax[:gr, :] = wg
+        wmax[:gr, 2] = self.gamma_g_max * wmax[:gr, 2]
+        wmax[gr : gr + qr, :] = wq
+        wmax[gr : gr + qr, 2] = self.gamma_q_max * wmax[gr : gr + qr, 2]
+
+        # Minimum load matrix
+        wmin[:gr, :] = wg
+        wmin[:gr, 2] = self.gamma_g_min * wmin[:gr, 2]
+        wmin[gr : gr + qr, :] = wq
+        wmin[gr : gr + qr, 2] = self.gamma_q_min * wmin[gr : gr + qr, 2]
+
+        # Parameters for looping over loadcases
+        N = self.ba.beam.no_spans
+        vResults = []
+
+        # Maximum support hogging and reaction -
+        # adjacent spans fully loaded with MAX, other spans loaded with MIN
+        n_max_hog = max(N - 1, 0)
+        for i in range(1, n_max_hog + 1):
+            w = wmin.copy()
+            adjacent_spans = np.array([i, i + 1])
+            mask = np.isin(wmax[:, 0], adjacent_spans)
+            w[mask] = wmax[mask]
+            res = analyze_loadcase(w)
+            vResults.append(res)
+
+        # Odd numbered spans loaded with MAX for maximum sagging moments
+        w = wmax.copy()  # set all loading to maximum
+        odd_spans = np.array([i for i in range(2, N + 1, 2)])
+        mask = np.isin(wmax[:, 0], odd_spans)
+        w[mask] = wmin[mask]
+        res = analyze_loadcase(w)
+        vResults.append(res)
+
+        # Even numbered spans loaded with MAX for maximum sagging moments
+        w = wmin.copy()  # set all loading to minimum
+        even_spans = np.array([i for i in range(2, N + 1, 2)])
+        mask = np.isin(wmin[:, 0], even_spans)
+        w[mask] = wmax[mask]  # make the load a max
+        res = analyze_loadcase(w)
+        vResults.append(res)
+
+        # All spans loaded with MAX
+        res = analyze_loadcase(wmax)
+        vResults.append(res)
+
+        return Envelopes(vResults)

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

@@ -5,6 +5,7 @@ PyCBA - Beam Results module
 from __future__ import annotations  # https://bit.ly/3KYiL2o
 from typing import List, Tuple
 import numpy as np
+import matplotlib.pyplot as plt
 from scipy import integrate
 from .beam import Beam
 from .load import MemberResults, LoadMaMb
@@ -348,3 +349,50 @@ class Envelopes:
             # Ensure no misleading results returned
             self.Rmax = np.zeros((self.nsup, self.nres))
             self.Rmin = np.zeros((self.nsup, self.nres))
+
+    def plot(self, each=False, **kwargs):
+        """
+        Plots the envelopes of bending and shear.
+
+        Parameters
+        ----------
+        each : Boolean
+            Wether or not to show each BMD and SFD in the enveloping. The default is False
+        **kwargs : Dict
+            Matplotlib keyword arguments for plotting.
+
+        Returns
+        -------
+        None.
+
+        """
+
+        if self.nres < 1:
+            raise ValueError("No results to display")
+
+        L = self.x[-1]
+
+        fig, axs = plt.subplots(2, 1, sharex=True, **kwargs)
+
+        ax = axs[0]
+        ax.plot([0, L], [0, 0], "k", lw=2)
+        ax.plot(self.x, self.Mmax, "r")
+        ax.plot(self.x, self.Mmin, "b")
+        ax.grid()
+        ax.invert_yaxis()
+        ax.set_ylabel("Bending Moment (kNm)")
+
+        ax = axs[1]
+        ax.plot([0, L], [0, 0], "k", lw=2)
+        ax.plot(self.x, self.Vmax, "r")
+        ax.plot(self.x, self.Vmin, "b")
+        ax.grid()
+        ax.set_ylabel("Shear Force (kN)")
+        ax.set_xlabel("Distance along beam (m)")
+
+        if each:
+            for res in self.vResults:
+                axs[0].plot(self.x, res.results.M, "r", lw=0.5)
+                axs[1].plot(self.x, res.results.V, "b", lw=0.5)
+
+        return fig, ax

{PyCBA-0.3 → PyCBA-0.4.1}/tests/test_basic.py

@@ -226,3 +226,42 @@ def test_moment_load():
         # 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)