ebbef2p-python 0.0.2.dev1__py3-none-any.whl → 1.0.0__py3-none-any.whl

ebbef2p/results.py

@@ -0,0 +1,215 @@
+"""Post-processing of a solved model.
+
+Sign conventions follow :mod:`ebbef2p.model`: ``w`` positive downwards,
+``theta = dw/dx``, bending moment ``M = -EI w''`` (positive when sagging),
+shear force ``V = dM/dx``. Reactions (soil pressure and support reactions)
+are positive when they act upwards on the beam, i.e. against positive loads.
+"""
+
+from dataclasses import dataclass, field
+from typing import Literal
+
+import numpy as np
+import scipy.sparse as sp
+from numpy.typing import ArrayLike, NDArray
+
+from . import elements as el
+from .mesh import Mesh, end_spring_stiffness
+from .model import Model
+
+_GAUSS_X, _GAUSS_W = np.polynomial.legendre.leggauss(4)
+_GAUSS_XI = 0.5*(_GAUSS_X + 1)
+
+
+@dataclass(frozen=True)
+class ElementEndValues:
+    """A quantity evaluated at both ends of every element.
+
+    ``x`` and ``values`` have length ``2 * n_elements``; consecutive pairs
+    belong to one element, so jumps at nodes (under point loads, at
+    changes of stiffness) are preserved.
+    """
+    x: NDArray[np.float64]
+    values: NDArray[np.float64]
+
+    def max(self) -> float:
+        return float(np.max(self.values))
+
+    def min(self) -> float:
+        return float(np.min(self.values))
+
+    def at(self, x: float, side: Literal['left', 'right'] = 'left') -> float:
+        """Value at a node, taken from the element on its left or right."""
+        idx = np.flatnonzero(np.isclose(self.x, x))
+        if idx.size == 0:
+            raise ValueError(f"no element end at x = {x}")
+        if side == 'left':
+            return float(self.values[idx[0]])
+        if side == 'right':
+            return float(self.values[idx[-1]])
+        raise ValueError("side must be 'left' or 'right'")
+
+
+@dataclass(frozen=True)
+class ReactivePressure(ElementEndValues):
+    """Soil reaction under the beam.
+
+    Attributes
+    ----------
+    x, values
+        Distributed pressure p = k w - (g w')' at element ends.
+    concentrated : list of (x, force)
+        Forces where the shear layer is cut: at the beam ends
+        (-g w' at the start, +g w' at the end, plus sqrt(k g) w if the soil
+        continues beyond the ends) and at interior nodes where g jumps.
+    resultant : float
+        Integral of p plus all concentrated forces (total soil reaction).
+    """
+    concentrated: list[tuple[float, float]] = field(default_factory=list)
+    resultant: float = 0.0
+
+
+@dataclass
+class Solution:
+    model: Model
+    mesh: Mesh
+    u: NDArray[np.float64]
+    K: sp.csr_matrix
+    f: NDArray[np.float64]
+    element_stiffness: NDArray[np.float64]
+    element_loads: NDArray[np.float64]
+    fixed_dofs: NDArray[np.intp]
+
+    # -- nodal values ---------------------------------------------------
+    @property
+    def x(self) -> NDArray[np.float64]:
+        """Node coordinates."""
+        return self.mesh.nodes
+
+    @property
+    def w(self) -> NDArray[np.float64]:
+        """Nodal displacements (positive downwards)."""
+        return self.u[0::2]
+
+    @property
+    def theta(self) -> NDArray[np.float64]:
+        """Nodal rotations dw/dx."""
+        return self.u[1::2]
+
+    @property
+    def element_displacements(self) -> NDArray[np.float64]:
+        """Degrees of freedom of every element, shape (n, 4)."""
+        return self.u[self.mesh.element_dofs]
+
+    def element_field(self, xi: ArrayLike, order: int = 0) -> NDArray[np.float64]:
+        """``w`` (order 0) or its ``order``-th derivative at local points.
+
+        ``xi`` holds local coordinates in [0, 1], the same in every element;
+        the result has shape (n_elements, len(xi)).
+        """
+        xi = np.atleast_1d(np.asarray(xi, dtype=float))
+        l = self.mesh.lengths[:, None]
+        N = (el.shape_functions(xi, l) if order == 0
+             else el.shape_function_derivatives(xi, l, order))
+        return np.einsum('iep,ei->ep', N, self.element_displacements)
+
+    def deflection(self, x: ArrayLike) -> NDArray[np.float64]:
+        """Displacement at arbitrary points, from the Hermite interpolation."""
+        x = np.atleast_1d(np.asarray(x, dtype=float))
+        e = self.mesh.element_at(x)
+        l = self.mesh.lengths[e]
+        xi = (x - self.mesh.nodes[e])/l
+        return np.einsum('im,mi->m', el.shape_functions(xi, l), self.element_displacements[e])
+
+    # -- internal forces --------------------------------------------------
+    def _element_end_forces(self) -> NDArray[np.float64]:
+        """Forces exerted on each element by its nodes: K_e d_e - f_e."""
+        return (np.einsum('eij,ej->ei', self.element_stiffness, self.element_displacements)
+                - self.element_loads)
+
+    def _end_coords(self) -> NDArray[np.float64]:
+        return np.column_stack([self.mesh.nodes[:-1], self.mesh.nodes[1:]]).ravel()
+
+    def bending_moment(self) -> ElementEndValues:
+        """Bending moment at element ends, from element equilibrium."""
+        F = self._element_end_forces()
+        M = np.column_stack([F[:, 1], -F[:, 3]]).ravel()
+        return ElementEndValues(self._end_coords(), M)
+
+    def shear_force(self) -> ElementEndValues:
+        """Shear force in the beam at element ends, from element equilibrium.
+
+        The force carried by the foundation's shear layer (g w') is
+        excluded, so this is the shear force in the beam itself.
+        """
+        F = self._element_end_forces()
+        th = self.theta
+        g = self.mesh.g
+        V = np.column_stack([-F[:, 0] - g[:, 0]*th[:-1],
+                             F[:, 2] - g[:, 1]*th[1:]]).ravel()
+        return ElementEndValues(self._end_coords(), V)
+
+    # -- reactions --------------------------------------------------------
+    def reactive_pressure(self) -> ReactivePressure:
+        """Soil reaction: distributed pressure and concentrated forces."""
+        mesh = self.mesh
+        l = mesh.lengths
+        k, g = mesh.k, mesh.g
+        dg = (g[:, 1] - g[:, 0])/l
+        w_end = self.element_field([0.0, 1.0])
+        theta_end = self.element_field([0.0, 1.0], order=1)
+        curvature_end = self.element_field([0.0, 1.0], order=2)
+        values = (k*w_end - g*curvature_end - dg[:, None]*theta_end).ravel()
+
+        flux = g*theta_end                     # g w' at both ends of every element
+        k_gauss = k[:, :1] + (k[:, 1:] - k[:, :1])*_GAUSS_XI
+        w_gauss = self.element_field(_GAUSS_XI)
+        resultant = float((0.5*l) @ ((k_gauss*w_gauss) @ _GAUSS_W)
+                          - np.sum(flux[:, 1] - flux[:, 0]))
+
+        x0, x1 = mesh.nodes[0], mesh.nodes[-1]
+        f0, f1 = -flux[0, 0], flux[-1, 1]
+        if self.model.soil_beyond_ends:
+            k_left, k_right = end_spring_stiffness(mesh)
+            f0 += k_left*self.w[0]
+            f1 += k_right*self.w[-1]
+
+        concentrated = [(float(x0), float(f0))]
+        jumps = flux[:-1, 1] - flux[1:, 0]
+        scale = max(1e-300, np.max(np.abs(flux[:, 1])))
+        for e in np.flatnonzero(np.abs(jumps) > 1e-10*scale):
+            concentrated.append((float(mesh.nodes[e + 1]), float(jumps[e])))
+        concentrated.append((float(x1), float(f1)))
+        resultant += sum(force for _, force in concentrated)
+
+        return ReactivePressure(self._end_coords(), values,
+                                concentrated=concentrated,
+                                resultant=resultant)
+
+    def support_reactions(self) -> list[tuple[float, float, float]]:
+        """Reactions at the supports as a list of (x, force, moment).
+
+        Positive when acting against positive loads (force upwards).
+        """
+        r = self.f - self.K @ self.u
+        out: dict[float, tuple[float, float]] = {}
+        for dof in self.fixed_dofs:
+            node = dof // 2
+            x = float(self.mesh.nodes[node])
+            force, moment = out.get(x, (0.0, 0.0))
+            if dof % 2 == 0:
+                force = float(r[dof])
+            else:
+                moment = float(r[dof])
+            out[x] = (force, moment)
+        return [(x, F, M) for x, (F, M) in sorted(out.items())]
+
+    def equilibrium(self) -> dict[str, float]:
+        """Vertical force balance: applied loads vs soil and support reactions."""
+        applied = sum(p.force for p in self.model.point_loads)
+        applied += sum(0.5*(d.q0 + d.q1)*(d.x1 - d.x0)
+                       for d in self.model.distributed_loads)
+        soil = self.reactive_pressure().resultant
+        supports = sum(F for _, F, _ in self.support_reactions())
+        return dict(applied=applied, soil=soil, supports=supports,
+                    residual=applied - soil - supports)

ebbef2p/solver.py

@@ -0,0 +1,130 @@
+"""Assembly and solution of the finite element system."""
+
+import warnings
+
+import numpy as np
+import scipy.sparse as sp
+import scipy.sparse.linalg as spla
+from numpy.typing import NDArray
+
+from . import elements as el
+from .exceptions import ModelError, UnstableModelError
+from .mesh import Mesh, build_mesh, end_spring_stiffness
+from .model import Model
+from .results import Solution
+
+
+def element_matrices(mesh: Mesh) -> tuple[NDArray[np.float64], NDArray[np.float64]]:
+    """Total element stiffness matrices and consistent load vectors.
+
+    Returns arrays of shape (n, 4, 4) and (n, 4).
+    """
+    l = mesh.lengths
+    ke = (el.bending_stiffness(mesh.EI, l)
+          + el.winkler_stiffness(mesh.k[:, 0], mesh.k[:, 1], l)
+          + el.shear_stiffness(mesh.g[:, 0], mesh.g[:, 1], l))
+    fe = el.distributed_load_vector(mesh.q[:, 0], mesh.q[:, 1], l)
+    return ke, fe
+
+
+def assemble(model: Model, mesh: Mesh) -> tuple[sp.csr_matrix, NDArray[np.float64],
+                                                NDArray[np.float64], NDArray[np.float64]]:
+    """Global stiffness matrix (CSR), load vector and element contributions."""
+    ndof = 2*(mesh.n_elements + 1)
+    ke, fe = element_matrices(mesh)
+
+    dofs = mesh.element_dofs
+    rows = np.repeat(dofs, 4, axis=1).ravel()
+    cols = np.tile(dofs, (1, 4)).ravel()
+    K = sp.coo_matrix((ke.ravel(), (rows, cols)), shape=(ndof, ndof)).tolil()
+
+    f = np.zeros(ndof)
+    np.add.at(f, dofs.ravel(), fe.ravel())
+
+    if model.soil_beyond_ends:
+        k_left, k_right = end_spring_stiffness(mesh)
+        K[0, 0] += k_left
+        K[ndof - 2, ndof - 2] += k_right
+
+    for p in model.point_loads:
+        i = mesh.node_index(p.x)
+        f[2*i] += p.force
+        f[2*i + 1] += p.moment
+
+    return K.tocsr(), f, ke, fe
+
+
+def constraints(model: Model, mesh: Mesh) -> tuple[NDArray[np.intp], NDArray[np.float64]]:
+    """Prescribed degrees of freedom and their values."""
+    prescribed: dict[int, float] = {}
+    for s in model.supports:
+        i = mesh.node_index(s.x)
+        for offset, value in ((0, s.w), (1, s.theta)):
+            if value is None:
+                continue
+            dof = 2*i + offset
+            if dof in prescribed and prescribed[dof] != value:
+                raise ModelError(f"conflicting supports at x = {s.x}")
+            prescribed[dof] = float(value)
+    dofs = np.array(sorted(prescribed), dtype=int)
+    values = np.array([prescribed[d] for d in dofs], dtype=float)
+    return dofs, values
+
+
+def check_stability(model: Model, mesh: Mesh, fixed: NDArray[np.intp]) -> None:
+    """Raise if the beam can move as a rigid body.
+
+    A foundation with k > 0 over a finite length restrains both
+    translation and rotation. Without it, the supports must prescribe w at
+    two distinct points, or w and theta at the same point.
+    """
+    if np.any(mesh.k > 0):
+        return
+    w_nodes = {d // 2 for d in fixed if d % 2 == 0}
+    theta_nodes = {d // 2 for d in fixed if d % 2 == 1}
+    if len(w_nodes) >= 2 or (w_nodes and theta_nodes):
+        return
+    raise UnstableModelError(
+        "the beam is not sufficiently supported: without a Winkler "
+        "parameter k > 0 it needs w prescribed at two points, or w and "
+        "theta at one point")
+
+
+def solve(model: Model, n_elements: int = 100) -> Solution:
+    """Solve the static problem.
+
+    Parameters
+    ----------
+    model : Model
+    n_elements : int
+        Approximate number of elements along the beam.
+
+    Returns
+    -------
+    Solution
+    """
+    mesh = build_mesh(model, n_elements)
+    K, f, ke, fe = assemble(model, mesh)
+    ndof = K.shape[0]
+
+    fixed, values = constraints(model, mesh)
+    check_stability(model, mesh, fixed)
+    free = np.setdiff1d(np.arange(ndof), fixed)
+
+    u = np.zeros(ndof)
+    u[fixed] = values
+    rhs = f[free] - K[free][:, fixed] @ values
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", spla.MatrixRankWarning)
+        try:
+            u[free] = spla.spsolve(K[free][:, free].tocsc(), rhs)
+        except (spla.MatrixRankWarning, RuntimeError):
+            u[free] = np.nan
+    if not np.all(np.isfinite(u)):
+        raise UnstableModelError(
+            "the system is singular: the beam is not sufficiently supported "
+            "(add a foundation or supports)")
+
+    return Solution(model=model, mesh=mesh, u=u, K=K, f=f,
+                    element_stiffness=ke, element_loads=fe,
+                    fixed_dofs=fixed)

ebbef2p/vlasov.py

@@ -0,0 +1,177 @@
+"""Modified Vlasov foundation model (Vallabhan & Das, 1991).
+
+The soil is an elastic layer of depth ``H`` on a rigid base, with Poisson's
+ratio ``nu`` and Young's modulus varying linearly from ``E_top`` at the
+surface to ``E_bottom`` at the base. The vertical displacement in the layer
+is ``w(x) * phi(z)`` with
+
+    phi(z) = sinh(gamma*(1 - z/H)) / sinh(gamma),
+
+and the foundation parameters follow from the layer properties and the
+non-dimensional decay parameter ``gamma``:
+
+    k = (1-nu)/((1+nu)(1-2nu)) * int_0^H E(z) phi'(z)^2 dz
+    g = 1/(2(1+nu))            * int_0^H E(z) phi(z)^2  dz     (g = 2t)
+
+``gamma`` itself depends on the beam deflection, so it is found iteratively.
+"""
+
+from dataclasses import dataclass, field, replace
+
+import numpy as np
+
+from .exceptions import ConvergenceError, ModelError
+from .model import Model
+from .results import _GAUSS_W, _GAUSS_XI, Solution
+from .solver import solve
+
+# Taylor coefficients in powers of gamma**2 (up to gamma**14) of the four
+# gamma-dependent factors in VlasovSoil.parameters: k = C_k (E1 kA + dE kB),
+# g = C_g (E1 gA + dE gB). Derived with sympy.
+_SERIES = (
+    (1, 0, 1/45, -4/945, 1/1575, -8/93555, 1382/127702575, -8/6081075),
+    (1/2, -1/12, 1/60, -1/378, 1/2700, -1/20790, 691/116093250, -1/1403325),
+    (1/6, -1/45, 1/315, -2/4725, 1/18711, -1382/212837625, 2/2606175,
+     -14468/162820783125),
+    (1/24, -1/120, 1/756, -1/5400, 1/41580, -691/232186500, 1/2806650,
+     -3617/86837751000),
+)
+_SERIES_GAMMA = 0.3
+
+
+@dataclass(frozen=True)
+class VlasovSoil:
+    """Elastic layer for the modified Vlasov model.
+
+    Parameters
+    ----------
+    E_top : float
+        Young's modulus at the surface.
+    nu : float
+        Poisson's ratio, 0 <= nu < 0.5.
+    depth : float
+        Layer thickness H.
+    E_bottom : float, optional
+        Young's modulus at the base; defaults to ``E_top`` (homogeneous layer).
+    """
+    E_top: float
+    nu: float
+    depth: float
+    E_bottom: float | None = None
+
+    def __post_init__(self) -> None:
+        if not 0 <= self.nu < 0.5:
+            raise ModelError("nu must satisfy 0 <= nu < 0.5")
+        if self.depth <= 0 or self.E_top <= 0:
+            raise ModelError("depth and E_top must be positive")
+        if self.E_bottom is not None and self.E_bottom <= 0:
+            raise ModelError("E_bottom must be positive")
+
+    def parameters(self, gamma: float) -> tuple[float, float]:
+        """Foundation parameters ``(k, g)`` for a given ``gamma`` (g = 2t).
+
+        Below ``_SERIES_GAMMA`` the closed forms lose accuracy to
+        cancellation (the error in g grows like 1e-16/gamma**4), so their
+        Taylor series in gamma**2 is used instead; both agree to 1e-15 at
+        the switch.
+        """
+        E1 = self.E_top
+        E2 = self.E_top if self.E_bottom is None else self.E_bottom
+        nu, H = self.nu, self.depth
+        if gamma < _SERIES_GAMMA:
+            kA, kB, gA, gB = (np.polynomial.polynomial.polyval(gamma**2, c)
+                              for c in _SERIES)
+        else:
+            s2 = np.sinh(gamma)**2
+            kA = (2*gamma*np.sinh(2*gamma) + 4*gamma**2)/(8*s2)
+            kB = (np.cosh(2*gamma) - 1 + 2*gamma**2)/(8*s2)
+            gA = (2*gamma*np.sinh(2*gamma) - 4*gamma**2)/(16*gamma**2*s2)
+            gB = (np.cosh(2*gamma) - 1 - 2*gamma**2)/(16*gamma**2*s2)
+        k = (1 - nu)/((1 + nu)*(1 - 2*nu)*H)*(E1*kA + (E2 - E1)*kB)
+        g = H/(1 + nu)*(E1*gA + (E2 - E1)*gB)
+        return float(k), float(g)
+
+    def gamma_from_deflection(self, solution: Solution, k: float, g: float,
+                              soil_beyond_ends: bool) -> float:
+        """Update gamma from a deflected shape (Vallabhan & Das, 1991).
+
+            (gamma/H)^2 = (1-2nu)/(2(1-nu)) * int w'^2 dx / int w^2 dx
+
+        with the integrals extended beyond the beam ends when the soil
+        continues there (w decays as w_end*exp(-sqrt(k/g)*s)).
+        """
+        half_l = 0.5*solution.mesh.lengths
+        int_w2 = float(half_l @ (solution.element_field(_GAUSS_XI)**2 @ _GAUSS_W))
+        int_dw2 = float(half_l @ (solution.element_field(_GAUSS_XI, order=1)**2 @ _GAUSS_W))
+        if soil_beyond_ends:
+            ends = solution.w[0]**2 + solution.w[-1]**2
+            alpha = np.sqrt(k/g)
+            int_w2 += ends/(2*alpha)
+            int_dw2 += alpha*ends/2
+        nu = self.nu
+        return float(self.depth*np.sqrt((1 - 2*nu)/(2*(1 - nu))*int_dw2/int_w2))
+
+
+@dataclass
+class VlasovResult:
+    """Outcome of :func:`solve_vlasov`."""
+    solution: Solution
+    soil: VlasovSoil
+    gamma: float
+    k: float
+    g: float
+    history: list[float] = field(default_factory=list)
+
+    @property
+    def t(self) -> float:
+        """Vlasov's t (the second parameter is g = 2t)."""
+        return 0.5*self.g
+
+
+def solve_vlasov(model: Model, soil: VlasovSoil, n_elements: int = 100,
+                 gamma0: float = 1.0, tol: float = 1e-6,
+                 max_iter: int = 100) -> VlasovResult:
+    """Solve a beam on a modified Vlasov foundation.
+
+    The foundation parameters are uniform along the beam and are found
+    iteratively together with ``gamma``. Any foundation already defined in
+    ``model`` is not allowed, since the Vlasov layer replaces it.
+
+    Whether the layer continues beyond the beam ends is taken from
+    ``model.soil_beyond_ends``; the same assumption is used in the
+    stiffness matrix and in the gamma update.
+
+    Parameters
+    ----------
+    model : Model
+        Beam, loads and supports.
+    soil : VlasovSoil
+
+    Returns
+    -------
+    VlasovResult
+    """
+    if model.foundation:
+        raise ModelError("solve_vlasov defines the foundation itself; "
+                         "remove the foundation segments from the model")
+    x0, x1 = model.extent
+    beyond = model.soil_beyond_ends
+
+    def solve_with(gamma: float) -> tuple[Solution, float, float]:
+        k, g = soil.parameters(gamma)
+        trial = replace(model, foundation=[])
+        trial.add_foundation(x0, x1, k=k, g=g)
+        return solve(trial, n_elements), k, g
+
+    gamma = float(gamma0)
+    history = [gamma]
+    for _ in range(max_iter):
+        solution, k, g = solve_with(gamma)
+        new_gamma = soil.gamma_from_deflection(solution, k, g, beyond)
+        history.append(new_gamma)
+        if abs(new_gamma - gamma) < tol*max(1.0, gamma):
+            solution, k, g = solve_with(new_gamma)
+            return VlasovResult(solution, soil, new_gamma, k, g, history)
+        gamma = new_gamma
+    raise ConvergenceError(f"gamma did not converge in {max_iter} iterations "
+                       f"(last values: {history[-3:]})")

ebbef2p_python-1.0.0.dist-info/METADATA

@@ -0,0 +1,126 @@
+Metadata-Version: 2.5
+Name: ebbef2p-python
+Version: 1.0.0
+Summary: Finite element analysis of Euler-Bernoulli beams on two-parameter elastic foundations (Winkler, Pasternak, modified Vlasov)
+Project-URL: Homepage, https://github.com/bteodoru/ebbef2p-python
+Project-URL: Documentation, https://ebbef2p-python.readthedocs.io
+Project-URL: Issues, https://github.com/bteodoru/ebbef2p-python/issues
+Project-URL: Changelog, https://github.com/bteodoru/ebbef2p-python/blob/main/CHANGELOG.md
+Author-email: Bogdan Teodoru <bteodoru@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: Pasternak,Vlasov,Winkler,beam on elastic foundation,finite element method,geotechnical engineering,soil-structure interaction
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: numpy>=1.26
+Requires-Dist: scipy>=1.11.3
+Provides-Extra: plot
+Requires-Dist: matplotlib>=3.10.7; extra == 'plot'
+Description-Content-Type: text/markdown
+
+
+# EBBEF2p for Python
+
+[![tests](https://github.com/bteodoru/ebbef2p-python/actions/workflows/tests.yml/badge.svg)](https://github.com/bteodoru/ebbef2p-python/actions/workflows/tests.yml)
+[![PyPI version](https://badge.fury.io/py/ebbef2p-python.svg)](https://badge.fury.io/py/ebbef2p-python)
+[![Python versions](https://img.shields.io/pypi/pyversions/ebbef2p-python)](https://pypi.org/project/ebbef2p-python/)
+[![GitHub license](https://img.shields.io/github/license/bteodoru/ebbef2p-python)](https://github.com/bteodoru/ebbef2p-python/blob/main/LICENSE)
+[![Documentation Status](https://readthedocs.org/projects/ebbef2p-python/badge/?version=latest)](https://ebbef2p-python.readthedocs.io/en/latest/?badge=latest)
+
+EBBEF2p (Euler-Bernoulli Beams on Two-Parameter Elastic Foundations) is a
+finite element package for static analysis of beams on Winkler, Pasternak
+and modified Vlasov foundations.
+
+* both foundation parameters may vary linearly along the beam, with jumps
+  between segments;
+* the soil may continue beyond the beam ends (equivalent end springs);
+* modified Vlasov model (Vallabhan & Das, 1991) with iterated decay
+  parameter and depth-dependent soil modulus;
+* bending moments and shear forces from element equilibrium;
+* soil pressure including the concentrated forces of the shear layer, with
+  a global equilibrium check.
+
+EBBEF2p was originally written as a MATLAB toolbox.
+
+## Installation
+
+```
+pip install ebbef2p-python            # NumPy and SciPy only
+pip install "ebbef2p-python[plot]"    # with Matplotlib for quick-look plots
+```
+
+Python 3.12 or newer is required.
+
+## Quick start
+
+```python
+from ebbef2p import Model, solve
+
+model = Model(soil_beyond_ends=True)
+model.add_beam(0, 10, E=30e6, I=0.01)
+model.add_foundation(0, 10, k=5000, g=2000)   # g = 2t (Vlasov) = Gp (Pasternak)
+model.add_point_load(5, force=100)
+
+solution = solve(model, n_elements=100)
+print(solution.w.max(), solution.bending_moment().max())
+print(solution.equilibrium())
+```
+
+A modified Vlasov foundation is defined by the soil layer instead:
+
+```python
+from ebbef2p import Model, VlasovSoil, solve_vlasov
+
+model = Model(soil_beyond_ends=True)
+model.add_beam(0, 100, E=432000, I=2.25).add_distributed_load(0, 100, 3)
+result = solve_vlasov(model, VlasovSoil(E_top=144, nu=0.2, depth=25))
+print(result.gamma, result.k, result.g)
+```
+
+More in the [documentation](https://ebbef2p-python.readthedocs.io) and in
+the `examples` folder.
+
+## Verification
+
+`tests/verification` compares EBBEF2p with independent references:
+closed-form solutions for beams without foundation, Hetényi's long beam on
+a Winkler foundation, the exact element stiffness and joint rotations of
+Razaqpur & Shah (1991), the decay parameter gamma of Vallabhan & Das
+(1991), numerical integration of the element matrices and Vlasov
+parameters, and global equilibrium. The full table is in the
+[documentation](https://ebbef2p-python.readthedocs.io/en/latest/theory/verification.html).
+
+## Development
+
+The project uses [uv](https://docs.astral.sh/uv/):
+
+```
+uv sync          # environment with the package and the dev tools
+uv run pytest    # tests/unit and tests/verification
+uv run ruff check .
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines and
+[CHANGELOG.md](CHANGELOG.md) for the changes since 0.0.x, including how to
+migrate from the old `Structure` API.
+
+## Citing
+
+If you use EBBEF2p in your work, please cite it using the metadata in
+[CITATION.cff](CITATION.cff) (GitHub shows it under *Cite this
+repository*).
+
+## License
+
+MIT, see [LICENSE](LICENSE).

ebbef2p_python-1.0.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+ebbef2p/__init__.py,sha256=-sA-yQqybcXHEXUWzh6cnAztdvhSiI-NJm7u64bENYA,613
+ebbef2p/elements.py,sha256=OH2CCHXslm05G1mboPmZo5R4LUIPAFm8zDQ4889y9Aw,4431
+ebbef2p/exceptions.py,sha256=ipc_lYRiWENw_-ipEWQpd4WvzenYbDc-3shbxeUrb68,632
+ebbef2p/mesh.py,sha256=cvRsCHnCwD7eeJx2JGHD6IgCvUjUG4QbQkJGbEFV4fo,3816
+ebbef2p/model.py,sha256=OinzyRDz_McZHf7MmOh79T86Tf9jekD2f95cIraLr3g,6681
+ebbef2p/plotting.py,sha256=_kyMC-3xjM_Brp1CF5RKgXAm1xhZBrksyf4VP0i-jSM,1087
+ebbef2p/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ebbef2p/results.py,sha256=j7hAUaL3Prvr_daubhg8bzMcC40kbEM1Ld1sCxQCYqM,8484
+ebbef2p/solver.py,sha256=9zb6n7Js3mD-Mk3wCZ44vbZY0y0rbwELjpnhMB3GZFI,4457
+ebbef2p/vlasov.py,sha256=XUMx1q1sh8LqwJANagH2YN1i9k6TDXEJdSNlHT_kzNo,6609
+ebbef2p_python-1.0.0.dist-info/METADATA,sha256=wXV-UVfbvVOVYdza1FaJNILP9WV9c6X7A6adww4YPKQ,5031
+ebbef2p_python-1.0.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+ebbef2p_python-1.0.0.dist-info/licenses/LICENSE,sha256=6OUFGGXle37w9HVrLxxwjuCNw_OgHgZuMS9tb-EP8qY,1076
+ebbef2p_python-1.0.0.dist-info/RECORD,,

{ebbef2p_python-0.0.2.dev1.dist-info → ebbef2p_python-1.0.0.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.34.2)
+Generator: hatchling 1.32.4
 Root-Is-Purelib: true
 Tag: py3-none-any
-

{ebbef2p_python-0.0.2.dev1.dist-info → ebbef2p_python-1.0.0.dist-info/licenses}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020, Bogdan Teodoru
+Copyright (c) 2020-2026, Bogdan Teodoru
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal