PyCBA 0.6.0__tar.gz → 0.7.0__tar.gz

{pycba-0.6.0/src/PyCBA.egg-info → pycba-0.7.0}/PKG-INFO

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

{pycba-0.6.0 → pycba-0.7.0/src/PyCBA.egg-info}/PKG-INFO

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

{pycba-0.6.0 → pycba-0.7.0}/src/PyCBA.egg-info/SOURCES.txt

@@ -20,4 +20,5 @@ src/pycba/utils.py
 src/pycba/vehicle.py
 tests/test_basic.py
 tests/test_bridge.py
-tests/test_inf_lines.py
+tests/test_inf_lines.py
+tests/test_results.py

{pycba-0.6.0 → pycba-0.7.0}/src/pycba/__init__.py

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

{pycba-0.6.0 → pycba-0.7.0}/src/pycba/analysis.py

@@ -91,13 +91,15 @@ class BeamAnalysis:
             * ``+k`` — elastic spring stiffness in consistent units.
 
         LM : list of list, optional
-            Load matrix: a list of load descriptors, each of the form
-            ``[span, load_type, value, a, c]``.  Load types:
+            Load matrix: a list of load descriptors.  The number of columns
+            per entry depends on the load type:
 
-            1. UDL — ``value`` is load intensity; set ``a = c = 0``.
-            2. Point load — ``value`` at distance ``a`` from the span start.
-            3. Partial UDL — ``value`` intensity from ``a`` for length ``c``.
-            4. Moment load — ``value`` at distance ``a`` from the span start.
+            1. UDL — ``[span, 1, w]``.
+            2. Point load — ``[span, 2, P, a]``.
+            3. Partial UDL — ``[span, 3, w, a, c]``.
+            4. Moment load — ``[span, 4, M, a]``.
+            5. Trapezoidal — ``[span, 5, w1, w2]`` (full span) or
+               ``[span, 5, w1, w2, a, c]`` (partial).
 
         eletype : array_like of int, optional
             Element type for each span, controlling which end(s) carry moment:
@@ -241,6 +243,44 @@ class BeamAnalysis:
         load = [i_span, 4, m, a]
         self._beam.add_load(load)
 
+    def add_trap(
+        self,
+        i_span: int,
+        w1: float,
+        w2: float,
+        a: Optional[float] = None,
+        c: Optional[float] = None,
+    ):
+        """
+        Append a trapezoidal (linearly varying) distributed load.
+
+        When *a* and *c* are omitted the load covers the full span, varying
+        from *w1* at the left end to *w2* at the right end.  When *a* and *c*
+        are given the load covers the region from *a* to *a + c*, varying from
+        *w1* to *w2* over that length.
+
+        Parameters
+        ----------
+        i_span : int
+            1-based span index.
+        w1 : float
+            Load intensity at the start of the load.  Positive values act downward.
+        w2 : float
+            Load intensity at the end of the load.  Positive values act downward.
+        a : float, optional
+            Distance from the left end of the span to the start of the load.
+            If given, *c* must also be provided.
+        c : float, optional
+            Length (cover) of the load.  Required when *a* is provided.
+        """
+        if a is not None and c is None:
+            raise ValueError("If 'a' is specified, 'c' must also be provided")
+        if a is not None:
+            load = [i_span, 5, w1, w2, a, c]
+        else:
+            load = [i_span, 5, w1, w2]
+        self._beam.add_load(load)
+
     def analyze(self, npts: Optional[int] = None) -> int:
         """
         Execute the direct-stiffness analysis.

{pycba-0.6.0 → pycba-0.7.0}/src/pycba/bridge.py

@@ -209,7 +209,12 @@ class BridgeAnalysis:
         return self.ba.analyze()
 
     def run_vehicle(
-        self, step: float, plot_env: bool = False, plot_all: bool = False
+        self,
+        step: float,
+        plot_env: bool = False,
+        plot_all: bool = False,
+        pos_start: Optional[float] = None,
+        pos_end: Optional[float] = None,
     ) -> Envelopes:
         """
         Runs the vehicle over the bridge performing a static analysis at each point
@@ -223,6 +228,12 @@ class BridgeAnalysis:
         plot_all : bool, optional
             Whether or not to plot the results for each position as an animation.
             The default is False.
+        pos_start : Optional[float], optional
+            The starting position of the front axle. Defaults to 0 (front axle at
+            the left end of the beam).
+        pos_end : Optional[float], optional
+            The ending position of the front axle. Defaults to beam length plus
+            vehicle length (front axle past the right end of the beam).
 
         Raises
         ------
@@ -239,14 +250,20 @@ class BridgeAnalysis:
         self._check_objects()
         self.pos = []
         self.vResults = []
-        npts = round((self.ba.beam.length + self.veh.L) / step) + 1
+
+        if pos_start is None:
+            pos_start = 0.0
+        if pos_end is None:
+            pos_end = self.ba.beam.length + self.veh.L
+
+        npts = round((pos_end - pos_start) / step) + 1
 
         if plot_all:
             fig, axs = plt.subplots(2, 1, sharex=True)
 
         for i in range(npts):
             # load position
-            pos = i * step
+            pos = pos_start + i * step
             self.pos.append(pos)
             out = self._single_analysis(pos)
             if out != 0:
@@ -269,7 +286,11 @@ class BridgeAnalysis:
     ) -> Dict[str, Dict[str, Union[float, np.ndarray]]]:
         """
         From the envelopes output, returns the extreme values, their locations,
-        and the position of the vehicle for each in a dictionary of dictionaries
+        and the position of the vehicle for each in a dictionary of dictionaries.
+
+        Each moment entry (``Mmax``, ``Mmin``) also contains a ``"Vco"`` key with
+        the coincident shear at the critical location. Each shear entry (``Vmax``,
+        ``Vmin``) contains a ``"Mco"`` key with the coincident moment.
 
         Parameters
         ----------
@@ -287,7 +308,8 @@ class BridgeAnalysis:
         -------
         crit_values : Dict[str, Dict[str, Union[float, np.ndarray]]]
             A dictionary of dictionaries containing the critical values (i.e. extremes)
-            of each of the load effects, both maximum and minimum.
+            of each of the load effects, both maximum and minimum, along with
+            coincident values of the other effect.
         """
 
         crit_values = {}
@@ -329,21 +351,25 @@ class BridgeAnalysis:
             "val": Mmax,
             "at": env.x[env.Mmax.argmax()],
             "pos": [self.pos[i] for i in indx["Mmax"]],
+            "Vco": env.Vco_Mmax[env.Mmax.argmax()],
         }
         crit_values["Mmin"] = {
             "val": Mmin,
             "at": env.x[env.Mmin.argmin()],
             "pos": [self.pos[i] for i in indx["Mmin"]],
+            "Vco": env.Vco_Mmin[env.Mmin.argmin()],
         }
         crit_values["Vmax"] = {
             "val": Vmax,
             "at": env.x[env.Vmax.argmax()],
             "pos": [self.pos[i] for i in indx["Vmax"]],
+            "Mco": env.Mco_Vmax[env.Vmax.argmax()],
         }
         crit_values["Vmin"] = {
             "val": Vmin,
             "at": env.x[env.Vmin.argmin()],
             "pos": [self.pos[i] for i in indx["Vmin"]],
+            "Mco": env.Mco_Vmin[env.Vmin.argmin()],
         }
         crit_values["nsup"] = env.nsup
         for i in range(env.nsup):

{pycba-0.6.0 → pycba-0.7.0}/src/pycba/inf_lines.py

@@ -132,13 +132,19 @@ class InfluenceLines:
             self.ba.beam.no_fixed_restraints
         )
 
-        # idx = np.abs(x - poi).argmin()
+        # Find the span containing the poi and the closest non-padding index
+        # within that span. Padding indices (first/last per span) have M/V
+        # forced to zero, so we must avoid them.
+        ispan, _ = self.ba.beam.get_local_span_coords(poi)
+        if ispan == -1:
+            ispan = self.ba.beam.no_spans - 1
+        span_x = self.vResults[0].vRes[ispan].x
+        # Skip padding at indices 0 and -1; real data is at 1:-1
+        idx_in_span = np.abs(span_x[1:-1] - poi).argmin() + 1
 
         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]
+                eta[i] = res.vRes[ispan].V[idx_in_span]
 
         elif load_effect.upper() == "R":
             #
@@ -182,10 +188,8 @@ class InfluenceLines:
                 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]
+                eta[i] = res.vRes[ispan].M[idx_in_span]
 
         return (np.array(self.pos), eta)
 

{pycba-0.6.0 → pycba-0.7.0}/src/pycba/load.py

@@ -1,37 +1,34 @@
-"""
-PyCBA - Load module
-
-The load matrix represents the loads as a `List` of `Lists`.
-Each list entry represents a single load and must be in the following format:
-
-     Span No. | Load Type | Load Value | Distance a | Load Cover c
-
-Load Types are:
-
-    1 - **Uniformly Distributed Loads**, which only have a load value; distances `a` and `c` are set to "0".
-
-    2 - **Point Loads**, located at `a` from the left end of the span; distances `c` is set to "0".
-
-    3 - **Partial UDLs**, starting at `a` for a distance of `c` (i.e. the cover) where $L >= a+c$.
-
-    4 - **Moment Load**, located at `a`; distances `c` is set to "0".
-
-It has dimension `M` x 5, where `M` is the number of loads applied to the beam.
-
-The type alias `LoadMatrix` is defined as
-
-.. autodata:: LoadMatrix
-
-"""
-
-from __future__ import annotations
-from typing import Union, List, NamedTuple, Tuple, Optional
-import numpy as np
-
-from .types import LoadType, LoadMatrix, LoadCNL, MemberResults
-
-
-class Load:
+"""
+PyCBA - Load module
+
+The load matrix is a ``List[List]`` of load descriptors.  Each entry
+describes one load; the number of columns varies by load type:
+
+=====  ====================  ================================  ====
+Type   Name                  Format                            Cols
+=====  ====================  ================================  ====
+1      UDL                   ``[span, 1, w]``                  3
+2      Point Load            ``[span, 2, P, a]``               4
+3      Partial UDL           ``[span, 3, w, a, c]``            5
+4      Moment Load           ``[span, 4, M, a]``               4
+5      Trapezoidal (full)    ``[span, 5, w1, w2]``             4
+5      Trapezoidal (partial) ``[span, 5, w1, w2, a, c]``       6
+=====  ====================  ================================  ====
+
+The type alias `LoadMatrix` is defined as
+
+.. autodata:: LoadMatrix
+
+"""
+
+from __future__ import annotations
+from typing import Union, List, NamedTuple, Tuple, Optional
+import numpy as np
+
+from .types import LoadType, LoadMatrix, LoadCNL, MemberResults
+
+
+class Load:
     """
     Beam load container and processor
     """
@@ -430,6 +427,244 @@ class LoadPUDL(Load):
         return res
 
 
+class LoadTrapez(Load):
+    """
+    Trapezoidal (linearly varying) distributed load, optionally partial.
+
+    The load varies linearly from intensity *w1* at position *a* to *w2* at
+    position *a + c*.  When *a* = 0 and *c* = span length the load covers
+    the full span (the default).
+    """
+
+    def __init__(
+        self,
+        i_span: int,
+        w1: float,
+        w2: float,
+        a: float = 0.0,
+        c: Optional[float] = None,
+    ):
+        """
+        Creates a trapezoidal load for the member.
+
+        Parameters
+        ----------
+        i_span : int
+            The member index to which the load is applied.
+        w1 : float
+            The load intensity at position *a* (left edge of the load).
+        w2 : float
+            The load intensity at position *a + c* (right edge of the load).
+        a : float, optional
+            Distance from the left end of the span to the start of the load.
+            Default is 0 (load starts at the left end).
+        c : float or None, optional
+            Length (cover) of the load.  ``None`` (default) means full span
+            from *a* to the right end.
+        """
+        super().__init__(i_span)
+        self.w1 = w1
+        self.w2 = w2
+        self.a = a
+        self._c = c  # None ⇒ full span from a, resolved when L is known
+
+    def _resolve(self, L: float):
+        """Resolve c and clip to span boundaries.
+
+        Returns (w1, w2, dw, a, c) with c > 0, or c = 0 when the load
+        falls outside the span.
+        """
+        a = self.a
+        c = self._c if self._c is not None else L - a
+        w1 = self.w1
+        w2 = self.w2
+
+        if a >= L or c <= 0:
+            return w1, w2, 0.0, a, 0.0
+
+        # Clip overhang
+        if a + c > L:
+            c_orig = c
+            c = L - a
+            w2 = w1 + (w2 - w1) * c / c_orig  # interpolated at clipped end
+
+        return w1, w2, w2 - w1, a, c
+
+    def get_cnl(self, L: float, eType: int) -> LoadCNL:
+        """
+        Consistent Nodal Loads for the trapezoidal load on a fixed-fixed span.
+
+        Derived from the fixed-end force influence integrals:
+
+        .. math::
+            M_A = \\frac{1}{L^2}\\int_a^b w(x)\\,x\\,(L-x)^2\\,dx
+
+        Parameters
+        ----------
+        L : float
+            The length of the member
+        eType : int
+            The member element type
+
+        Returns
+        -------
+        LoadCNL
+            Consistent Nodal Loads for this load type
+        """
+        w1, w2, dw, a, c = self._resolve(L)
+
+        if c <= 0:
+            return LoadCNL(Va=0.0, Vb=0.0, Ma=0.0, Mb=0.0)
+
+        alpha = L - a  # distance: load start → right beam end
+        # delta = L - a - c    # distance: load end → right beam end (not used directly)
+
+        # --- Ma: ∫ w(x) · x · (L−x)² dx / L² ---
+        # Split into UDL(w1) integral I1 and triangular(dw) integral I2.
+        I1 = (
+            c**4 / 4
+            + (a - 2 * alpha) * c**3 / 3
+            + (alpha**2 - 2 * a * alpha) * c**2 / 2
+            + a * alpha**2 * c
+        )
+        I2 = (
+            c**5 / 5
+            + (a - 2 * alpha) * c**4 / 4
+            + (alpha**2 - 2 * a * alpha) * c**3 / 3
+            + a * alpha**2 * c**2 / 2
+        )
+        Ma = (w1 / L**2) * I1 + (dw / (c * L**2)) * I2
+
+        # --- Mb: −∫ w(x) · x² · (L−x) dx / L² ---
+        J1 = (
+            -(c**4) / 4
+            + (alpha - 2 * a) * c**3 / 3
+            + (2 * a * alpha - a**2) * c**2 / 2
+            + a**2 * alpha * c
+        )
+        J2 = (
+            -(c**5) / 5
+            + (alpha - 2 * a) * c**4 / 4
+            + (2 * a * alpha - a**2) * c**3 / 3
+            + a**2 * alpha * c**2 / 2
+        )
+        Mb = -((w1 / L**2) * J1 + (dw / (c * L**2)) * J2)
+
+        # --- Va: ∫ w(x) · (L−x)² · (2x+L) dx / L³ ---
+        K1 = (
+            c**4 / 2
+            + (a - alpha) * c**3
+            - 3 * a * alpha * c**2
+            + (3 * a + alpha) * alpha**2 * c
+        )
+        K2 = (
+            2 * c**5 / 5
+            + 3 * (a - alpha) * c**4 / 4
+            - 2 * a * alpha * c**3
+            + (3 * a + alpha) * alpha**2 * c**2 / 2
+        )
+        Va = (w1 / L**3) * K1 + (dw / (c * L**3)) * K2
+
+        Vb = (w1 + w2) * c / 2 - Va
+
+        return LoadCNL(Va=Va, Vb=Vb, Ma=Ma, Mb=Mb)
+
+    def get_mbr_results(self, x: np.ndarray, L: float) -> MemberResults:
+        """
+        Simply-supported member results using Macaulay bracket integration.
+
+        The load ``w(x) = w1 + (w2−w1)·(x−a)/c`` for ``a ≤ x ≤ a+c`` is
+        integrated using Macaulay brackets at positions *a* and *b = a+c*.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Vector of points along the length of the member
+        L : float
+            The length of the member
+
+        Returns
+        -------
+        res : MemberResults
+            A populated :class:`pycba.load.MemberResults` object
+        """
+        npts = len(x)
+        res = MemberResults(vals=None, n=npts)
+        res.x = x
+
+        w1, w2, dw, a, c = self._resolve(L)
+
+        if c <= 0:
+            res.V = np.zeros(npts)
+            res.M = np.zeros(npts)
+            res.R = np.zeros(npts)
+            res.D = np.zeros(npts)
+            return res
+
+        b = a + c
+        alpha = L - a
+        delta = L - b
+
+        # Simply-supported reaction at left end (moment equilibrium about B)
+        Va = (
+            (w1 / 2) * alpha**2
+            + (dw / (6 * c)) * alpha**3
+            - (w2 / 2) * delta**2
+            - (dw / (6 * c)) * delta**3
+        ) / L
+
+        # Rotation integration constant (from D(0) = D(L) = 0)
+        Ra = (
+            -(Va / 6) * L**3
+            + (w1 / 24) * alpha**4
+            + (dw / (120 * c)) * alpha**5
+            - (w2 / 24) * delta**4
+            - (dw / (120 * c)) * delta**5
+        ) / L
+
+        # Macaulay brackets at load start and end
+        MBa = self.MB(x - a)
+        MBb = self.MB(x - b)
+
+        res.V = (
+            Va
+            - w1 * MBa
+            - (dw / (2 * c)) * MBa**2
+            + w2 * MBb
+            + (dw / (2 * c)) * MBb**2
+        )
+        res.M = (
+            Va * x
+            - (w1 / 2) * MBa**2
+            - (dw / (6 * c)) * MBa**3
+            + (w2 / 2) * MBb**2
+            + (dw / (6 * c)) * MBb**3
+        )
+        res.R = (
+            (Va / 2) * x**2
+            - (w1 / 6) * MBa**3
+            - (dw / (24 * c)) * MBa**4
+            + (w2 / 6) * MBb**3
+            + (dw / (24 * c)) * MBb**4
+            + Ra
+        )
+        res.D = (
+            (Va / 6) * x**3
+            - (w1 / 24) * MBa**4
+            - (dw / (120 * c)) * MBa**5
+            + (w2 / 24) * MBb**4
+            + (dw / (120 * c)) * MBb**5
+            + Ra * x
+        )
+
+        res.V[0] = 0.0
+        res.V[npts - 1] = 0.0
+        res.M[0] = 0.0
+        res.M[npts - 1] = 0.0
+
+        return res
+
+
 class LoadMaMb(Load):
     """
     Member end moment loads
@@ -654,6 +889,13 @@ def parse_LM(LM: LoadMatrix) -> List[Load]:
             m = load[2]
             a = load[3]
             loads.append(LoadML(span, m, a))
+        # Trapezoidal Load
+        elif ltype == 5:
+            w1 = load[2]
+            w2 = load[3]
+            a = load[4] if len(load) > 4 else 0.0
+            c = load[5] if len(load) > 5 else None
+            loads.append(LoadTrapez(span, w1, w2, a, c))
     return loads
 
 
@@ -710,6 +952,11 @@ def factor_LM(LM: LoadMatrix, gamma: float) -> LoadMatrix:
             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]])
+        elif l_type == 5:  # Trapezoidal
+            new_load = [i_span, l_type, mag, gamma * load[3]]
+            if len(load) > 4:
+                new_load.extend(load[4:])  # a, c are not factored
+            LMnew.append(new_load)
         else:  # PUDL
             LMnew.append([i_span, l_type, mag, load[3], load[4]])