femethods 0.1.7a2__py3-none-any.whl → 0.1.8__py3-none-any.whl

femethods/elements.py

@@ -1,389 +0,0 @@
-"""
-The elements module contains finite element classes
-
-Currently the only element that is defined is a beam element.
-
-"""
-
-from typing import Any, List, TYPE_CHECKING, Tuple
-from warnings import warn
-
-import matplotlib.pyplot as plt
-import numpy as np
-from scipy.misc import derivative
-
-# local imports
-from femethods.core._base_elements import BeamElement
-from femethods.core._common import derivative as comm_derivative
-
-if TYPE_CHECKING:  # pragma: no cover
-    from femethods.loads import Load  # noqa: F401 (unused import)
-    from femethods.reactions import Reaction  # noqa: F401 (unused import)
-
-
-# noinspection PyPep8Naming
-class Beam(BeamElement):
-    """A Beam defines a beam element for analysis
-
-    A beam element is a slender member that is subjected to transverse loading.
-    It is assumed to have homogeneous properties, with a constant
-    cross-section.
-
-
-    Parameters:
-        length (:obj:`float`): the length of a beam. This is the total length
-                        of the beam, this is not the length of the meshed
-                        element. This must be a float that is greater than 0.
-        loads (:obj:`list`): list of load elements
-        reactions (:obj:`list`): list of reactions acting on the beam
-        E (:obj:`float`, optional): Young's modulus of the beam in units of
-                         :math:`\\frac{force}{length^2}`. Defaults to 1.
-                         The :math:`force` units used here are the same
-                         units that are used in the input forces, and
-                         calculated reaction forces. The :math:`length` unit
-                         must be the same as the area moment of inertia
-                         (**Ixx**) and the beam **length** units.
-        Ixx (:obj:`float`, optional): Area moment of inertia of the beam.
-                    Defaults to 1. This is constant (constant cross-sectional
-                    area) along the length of the beam. This is in units of
-                    :math:`length^4`. This must be the same length unit of
-                    Young's modulus (**E**) and the beam **length**.
-
-    """
-
-    def __init__(
-        self,
-        length: float,
-        loads: List["Load"],
-        reactions: List["Reaction"],
-        E: float = 1,
-        Ixx: float = 1,
-    ):
-        super().__init__(length, loads, reactions, E=E, Ixx=Ixx)
-
-    def deflection(self, x: float) -> np.float64:
-        """Calculate deflection of the beam at location x
-
-        Parameters:
-            x (:obj:`float | int`): location along the length of the beam where
-                           deflection should be calculated.
-
-        Returns:
-            :obj:`float`: deflection of the beam in units of the beam length
-
-        Raises:
-            :obj:`ValueError`: when the :math:`0\\leq x \\leq length` is False
-            :obj:`TypeError`: when x cannot be converted to a float
-        """
-
-        # TODO: store the lengths/node locations in the class so they only have
-        #  to be assessed without recalculating
-        nodes = self.mesh.nodes
-
-        # validate that x is a valid by ensuring that x is
-        # - x is a number
-        # - 0 <= x <= length of beam
-        try:
-            x = float(x)
-        except ValueError:
-            raise TypeError(
-                f"Cannot calculate deflection with location of type: {type(x)}"
-            )
-
-        if x < 0 or self.length < x:
-            raise ValueError(
-                f"cannot calculate deflection at location {x} as "
-                f"it is outside of the beam!"
-            )
-
-        # Using the given global x-value, determine the local x-value, length
-        # of active element, and the nodal displacements (vertical, angular)
-        # vector d
-        for i in range(len(self.mesh.lengths)):
-            if nodes[i] <= x <= nodes[i + 1]:
-                # this is the element where the global x-value falls into.
-                # Get the parameters in the local system and exit the loop
-                x_local = x - nodes[i]
-                L = self.mesh.lengths[i]
-                d = self.node_deflections[i * 2 : i * 2 + 4]
-                return self.shape(x_local, L).dot(d)[0]
-
-    def moment(self, x: float, dx: float = 1e-5, order: int = 9) -> np.float64:
-        """Calculate the moment at location x
-
-        Calculate the moment in the beam at the global x value by taking
-        the second derivative of the deflection curve.
-
-        .. centered::
-            :math:`M(x) = E \\cdot Ixx \\cdot \\frac{d^2 v(x)}{dx^2}`
-
-        where :math:`M` is the moment, :math:`E` is Young's modulus and
-        :math:`Ixx` is the area moment of inertia.
-
-        .. note: When calculating the moment near the beginning of the beam
-                 the moment calculation may be unreliable.
-
-        Parameters:
-            x (:obj:`int`): location along the beam where moment is calculated
-            dx (:obj:`float`, optional): spacing. Default is 1e-5
-            order (:obj:`int`, optional): number of points to use, must be odd.
-                Default is 9
-
-        Returns:
-            :obj:`float`: moment in beam at location x
-
-        Raises:
-            :obj:`ValueError`: when the :math:`0\\leq x \\leq length` is False
-            :obj:`TypeError`: when x cannot be converted to a float
-
-        For more information on the parameters, see the scipy.misc.derivative
-        documentation.
-        """
-
-        # TODO: Update so that moment can be calculated at both ends of beam
-        if x < 0.75:
-            # this cut-off was found experimentally. Anything less than this,
-            # and calculating the derivative is unreliable
-            warn("Calculated moments below 0.75 may be unreliable")
-
-        try:
-            return (
-                self.E
-                * self.Ixx
-                * derivative(self.deflection, x, dx=dx, n=2, order=order)
-            )
-        except ValueError:
-            # there was an error, probably due to the central difference
-            # method attempting to calculate the moment near the ends of the
-            # beam. Determine whether the desired position is near the start
-            # or end of the beam, and use the forward/backward difference
-            # method accordingly
-
-            if x <= self.length / 2:
-                # the desired moment is near the beginning of the beam, use the
-                # forward difference method
-                method = "forward"
-            else:
-                # the desired moment is near the end of the beam, use the
-                # backward difference method
-                method = "backward"
-            return (
-                self.E
-                * self.Ixx
-                * comm_derivative(self.deflection, x, method=method, n=2)
-            )
-
-    def shear(self, x: float, dx: float = 0.01, order: int = 5) -> np.float64:
-        """
-        Calculate the shear force in the beam at location x
-
-        Calculate the shear in the beam at the global x value by taking
-        the third derivative of the deflection curve.
-
-        .. centered::
-            :math:`V(x) = E \\cdot Ixx \\cdot \\frac{d^3 v(x)}{dx^3}`
-
-        where :math:`V` is the shear force, :math:`E` is Young's modulus and
-        :math:`Ixx` is the area moment of inertia.
-
-        .. note: When calculating the shear near the beginning of the beam
-                 the shear calculation may be unreliable.
-
-        Parameters:
-            x (:obj:`int`): location along the beam where moment is calculated
-            dx (:obj:`float`, optional): spacing. Default is 0.01
-            order (:obj:`int`, optional): number of points to use, must be odd.
-                Default is 5
-
-        Returns:
-            :obj:`float`: moment in beam at location x
-
-        Raises:
-            :obj:`ValueError`: when the :math:`0\\leq x \\leq length` is False
-            :obj:`TypeError`: when x cannot be converted to a float
-
-        For more information on the parameters, see the scipy.misc.derivative
-        documentation.
-        """
-        return (
-            self.E
-            * self.Ixx
-            * derivative(self.deflection, x, dx=dx, n=3, order=order)
-        )
-
-    def bending_stress(self, x, dx=1, c=1):
-        """
-        returns the bending stress at global coordinate x
-
-        .. deprecated:: 0.1.7a1
-            calculate bending stress as :obj:`Beam.moment(x) * c / Ixx`
-
-        """
-        warn("bending_stress will be removed soon", DeprecationWarning)
-        return self.moment(x, dx=dx) * c / self.Ixx
-
-    @staticmethod
-    def __validate_plot_diagrams(diagrams, diagram_labels):
-        """
-        Validate the parameters for the plot function
-        """
-
-        # create default (and complete list of valid) diagrams that are
-        # implemented
-        default_diagrams = ("shear", "moment", "deflection")
-        if diagrams is None and diagram_labels is None:
-            # set both the diagrams and labels to their defaults
-            # no need for further validation of these values since they are
-            # set internally
-            return default_diagrams, default_diagrams
-
-        if diagrams is None and diagram_labels is not None:
-            raise ValueError("cannot set diagrams from labels")
-
-        if diagram_labels is None:
-            diagram_labels = diagrams
-
-        if len(diagrams) != len(diagram_labels):
-            raise ValueError(
-                "length of diagram_labels must match length of diagrams"
-            )
-        for diagram in diagrams:
-            if diagram not in default_diagrams:
-                raise ValueError(
-                    f"values of diagrams must be in {default_diagrams}"
-                )
-        return diagrams, diagram_labels
-
-    def plot(
-        self,
-        n=250,
-        title="Beam Analysis",
-        diagrams=None,
-        diagram_labels=None,
-        **kwargs,
-    ):
-        """
-        Plot the deflection, moment, and shear along the length of the beam
-
-        The plot method will create a :obj:`matplotlib.pyplot` figure with the
-        deflection, moment, and shear diagrams along the length of the beam
-        element. Which of these diagrams, and their order may be customized.
-
-        Parameters:
-            n (:obj:`int`): defaults to `250`:
-                number of data-points to use in plots
-            title (:obj:`str`) defaults to 'Beam Analysis`
-                title on top of plot
-            diagrams (:obj:`tuple`): defaults to
-                `('shear', 'moment', 'deflection')`
-                tuple of diagrams to plot. All values in tuple must be strings,
-                and one of the defaults.
-                Valid values are :obj:`('shear', 'moment', 'deflection')`
-            diagram_labels (:obj:`tuple`): y-axis labels for subplots.
-                Must have the same length as `diagrams`
-
-        Returns:
-             :obj:`tuple`:
-                Tuple of :obj:`matplotlib.pyplot` figure and list of axes in
-                the form :obj:`(figure, axes)`
-
-        .. note:: The plot method will create the figure handle, but will not
-                  automatically show the figure.
-                  To show the figure use :obj:`Beam.show()` or
-                  :obj:`matplotlib.pyplot.show()`
-
-        .. versionchanged:: 0.1.7a1 Removed :obj:`bending_stress` parameter
-        .. versionchanged:: 0.1.7a1
-            Added :obj:`diagrams` and :obj:`diagram_labels` parameters
-
-        """
-
-        kwargs.setdefault("title", "Beam Analysis")
-        kwargs.setdefault("grid", True)
-        kwargs.setdefault("xlabel", "Beam position, x")
-        kwargs.setdefault("fill", True)
-        kwargs.setdefault("plot_kwargs", {})
-        kwargs.setdefault("fill_kwargs", {"color": "b", "alpha": 0.25})
-
-        diagrams, diagram_labels = self.__validate_plot_diagrams(
-            diagrams, diagram_labels
-        )
-        fig, axes = plt.subplots(len(diagrams), 1, sharex="all")
-        if len(diagrams) == 1:
-            # make sure axes are iterable, even if there is only one
-            axes = [axes]
-
-        xd = np.linspace(0, self.length, n)  # deflection
-        x, y = None, None
-        for ax, diagram, label in zip(axes, diagrams, diagram_labels):
-            if diagram == "deflection":
-                x = xd
-                y = [self.deflection(xi) for xi in x]
-            if diagram == "moment":
-                x = xd
-                y = [self.moment(xi, dx=self.length / (n + 3)) for xi in x]
-            if diagram == "shear":
-                x = np.linspace(0, self.length, n + 4)[2:-2]
-                y = [self.shear(xi, dx=self.length / (n + 4)) for xi in x]
-
-            # regardless of the diagram that is being plotted, the number of
-            # data points should always equal the number specified by user
-            assert len(x) == n, "x does not match n"
-            assert len(y) == n, "y does not match n"
-
-            ax.plot(x, y, **kwargs["plot_kwargs"])
-            if kwargs["fill"]:
-                ax.fill_between(x, y, 0, **kwargs["fill_kwargs"])
-            ax.set_ylabel(label)
-            ax.grid(kwargs["grid"])
-
-        locations = self.mesh.nodes  # in global coordinate system
-        axes[-1].set_xlabel(kwargs["xlabel"])
-        axes[-1].set_xticks(locations)
-
-        fig.subplots_adjust(hspace=0.25)
-        fig.suptitle(title)
-        return fig, axes
-
-    @staticmethod
-    def show(*args: Any, **kwargs: Any) -> None:
-        """Wrapper function for showing matplotlib figure
-
-        This method gives direct access to the matplotlib.pyplot.show function
-        so the calling code is not required to import matplotlib directly
-        just to show the plots
-
-        Parameters:
-             args/kwargs: args and kwargs are passed directly to
-                          matplotlib.pyplot.show
-        """
-        plt.show(*args, **kwargs)  # pragma: no cover
-
-    def __str__(self) -> str:
-        assert self.loads is not None
-        assert self.reactions is not None
-
-        L = ""
-        for load in self.loads:
-            L += "Type: {}\n".format(load.name)
-            L += "    Location: {}\n".format(load.location)
-            L += "   Magnitude: {}\n".format(load.magnitude)
-
-        r = ""
-        for reaction in self.reactions:
-            r += "Type: {}\n".format(reaction.name)
-            r += "    Location: {}\n".format(reaction.location)
-            r += "       Force: {}\n".format(reaction.force)
-            r += "      Moment: {}\n".format(reaction.moment)
-
-        msg = (
-            "PARAMETERS\n"
-            f"Length (length): {self.length}\n"
-            f"Young's Modulus (E): {self.E}\n"
-            f"Area moment of inertia (Ixx): {self.Ixx}\n"
-            f"LOADING\n"
-            f"{L}\n"
-            f"REACTIONS\n"
-            f"{r}\n"
-        )
-        return msg

femethods/loads.py

@@ -1,38 +0,0 @@
-"""
-Module to define different loads
-"""
-
-from typing import Optional
-
-from femethods.core._common import Forces
-
-
-class Load(Forces):
-    """Base class for all load types
-
-    Used primarily for type checking the loads on input
-    """
-
-    name = ""
-
-
-class PointLoad(Load):
-    """
-    class specific to a point load
-    """
-
-    name = "point load"
-
-    def __init__(self, magnitude: Optional[float], location: float):
-        super().__init__(magnitude, location)
-
-
-class MomentLoad(Load):
-    """
-    class specific to a moment load
-    """
-
-    name = "moment load"
-
-    def __init__(self, magnitude: float, location: float):
-        super().__init__(magnitude, location)

femethods/reactions.py

@@ -1,176 +0,0 @@
-"""
-The reactions module defines different reaction classes
-
-A reaction is required to support an element to resist any input forces.
-
-There are two types of reactions that are defined.
-
-    * PinnedReaction, allows rotational displacement only
-    * FixedReaction, does not allow any displacement
-
-"""
-from typing import Optional, Tuple
-
-from femethods.core._common import Forces
-
-BOUNDARY_CONDITIONS = Tuple[Optional[int], Optional[int]]
-
-
-class Reaction(Forces):
-    """Base class for all reactions
-
-    The Reaction class defines general properties related to all reaction
-    types.
-
-    Parameters:
-        location (:obj:`float`): the axial location of the reaction along the
-                                 length of the beam.
-
-    .. note:: Any force or moment values that where calculated values are
-             invalidated (set to :obj:`None`) any time the location is set.
-
-    Attributes:
-        force (:obj:`float | None`): the force of the reaction after it has
-                                     been calculated
-        moment (:obj:`float | None`): The moment of the reaction after it has
-                                      been calculated
-    """
-
-    name = ""
-
-    def __init__(self, location: float):
-        super().__init__(magnitude=None, location=location)
-        self.force = None
-        self.moment = None
-        self._boundary: BOUNDARY_CONDITIONS = (None, None)
-
-    @property
-    def boundary(self) -> BOUNDARY_CONDITIONS:
-        return self._boundary
-
-    @property
-    def location(self) -> float:
-        """
-        Location of the reaction along the length of the beam
-
-        The units of the length property is the same as the units of the beam
-        length.
-
-        The value of the location must be a positive value that is less than
-        or equal to the length of the beam, or it will raise a ValueError.
-
-        .. note:: The force and moment values are set to :obj:`None` any time
-                  the location is set.
-        """
-        return self._location
-
-    @location.setter
-    def location(self, location: float) -> None:
-        # The location is overloading the location property in Forces so that
-        # the reaction can be invalidated when the location is changed
-        if location < 0:
-            # location cannot be a negative number
-            raise ValueError("location must be positive!")
-        self.invalidate()
-        self._location = location
-
-    @property
-    def value(self) -> Tuple[Optional[float], Optional[float]]:
-        """
-        Simple tuple of force and moment
-
-        Returns:
-            :obj:`tuple` (force, moment)
-        """
-        return self.force, self.moment
-
-    def invalidate(self) -> None:
-        """Invalidate the reaction values
-
-        This will set the force and moment values to :obj:`None`
-
-        To be used whenever the parameters change and the reaction values are
-        no longer valid.
-        """
-        self.force, self.moment = (None, None)
-
-    def __str__(self) -> str:
-        return (
-            f"{self.__class__.__name__}\n"
-            f"  Location: {self.location}\n"
-            f"     Force: {self.force}\n"
-            f"    Moment: {self.moment}\n"
-        )
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(location={self.location})"
-
-    def __eq__(self, other: object) -> bool:
-
-        if not isinstance(other, self.__class__):
-            return False
-
-        if (
-            self.location == other.location
-            and self.force == other.force
-            and self.moment == other.moment
-        ):
-            return True
-
-        return False
-
-
-class PinnedReaction(Reaction):
-    """
-    A PinnedReaction allows rotation displacements only
-
-    A PinnedReaction represents a pinned, frictionless pivot that can
-    resist motion both normal and axial directions to the beam. It will not
-    resist moments.
-    The deflection of a beam at the PinnedReaction is always zero, but
-    the angle is free to change
-
-    Parameters:
-        location (:obj:`float`): the axial location of the reaction along the
-                                 length of the beam
-
-    Attributes:
-        name (:obj:`str`): short name of the reaction (pinned). Used internally
-
-    .. warning:: The **name** attribute is used internally.
-                 **Do not change this value!**
-    """
-
-    name = "pinned"
-
-    def __init__(self, location: float):
-        super().__init__(location)
-        # limit the vertical displacement but allow rotation
-        self._boundary: BOUNDARY_CONDITIONS = (0, None)
-
-
-class FixedReaction(Reaction):
-    """
-    A FixedReaction does not allow any displacement or change in angle
-
-    A FixedReaction resists both force and moments. The displacement and the
-    angle are both constrained and must be zero at the reaction point.
-    FixedReactions are typically applied at the ends of a Beam.
-
-    Parameters:
-        location (:obj:`float`): the axial location of the reaction along the
-                                 length of the beam
-
-    Attributes:
-        name (:obj:`str`): short name of the reaction (fixed). Used internally
-
-    .. warning:: The **name** attribute is used internally.
-                 **Do not change this value!**
-    """
-
-    name = "fixed"
-
-    def __init__(self, location: float):
-        super().__init__(location)
-        # do not allow vertical or rotational displacement
-        self._boundary: BOUNDARY_CONDITIONS = (0, 0)

femethods-0.1.7a2.dist-info/RECORD

@@ -1,18 +0,0 @@
-femethods/__init__.py,sha256=KEvu1iKJntEfs4jna_RsP7ObqyaP7t2g13x1UvL-2Lk,157
-femethods/elements.py,sha256=GRNfGbRYjBDsjmQLA7SSQ2QLkTWaXGlMsH5PWfPgT9U,14850
-femethods/loads.py,sha256=FLoQ1js_vC1iBV0C_bVhXx2ey09uqGniMRjgJwrvDLg,679
-femethods/mesh.py,sha256=aeGr0y25Yt7xD1qmfOF8cAMBd44qube394B5lFrRR4s,2979
-femethods/reactions.py,sha256=dszKp84PtoyH99v-YI6pELp0cxBh-G3aXbBEZbyqHfI,5479
-femethods/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-femethods/core/_base_elements.py,sha256=Ci03v7LntAgYNs3WhxIiqfLZG5IEMRg6vXxyvRD3kAg,15427
-femethods/core/_common.py,sha256=8yOwIsTVqPuFmOTQRf5sSPV4hHu_52AbjTTIdlMC6hg,3461
-tests/__init__.py,sha256=eoZ6GfifbqhMLNzjlqRDVil-yyBkOmVN9ujSgJWNBlY,15
-tests/functional tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/functional tests/settings.py,sha256=K2qEBPjQs-5KYkQyxMDMKhjNBLmEgo5K3kQPd8SgJqE,410
-tests/functional tests/test_fixed_support_beams.py,sha256=zQ3Yo78zV5s3NSm9YUtNZfMUJkl6kwzix21dBOl_EQ0,878
-tests/functional tests/test_simply_supported_beam.py,sha256=XDbmMpQlelC8pq9qKiMlpbc04KJ1e6ynvdvzjK3kfnQ,4067
-tests/functional tests/validate.py,sha256=RcLoOnse-Mug71KstiteHL7EVUI5gcCOZIqf9sdOqRo,1351
-femethods-0.1.7a2.dist-info/METADATA,sha256=b0zNovQTztaKzkPxw882JRQWW3dgVvnQbfdhhmDJwng,8675
-femethods-0.1.7a2.dist-info/WHEEL,sha256=EVRjI69F5qVjm_YgqcTXPnTAv3BfSUr0WVAHuSP3Xoo,92
-femethods-0.1.7a2.dist-info/top_level.txt,sha256=kHq0RoeYIm-d8AhLU7k4YhFsefCyRPywG-3nZWg0Du0,16
-femethods-0.1.7a2.dist-info/RECORD,,

tests/__init__.py

@@ -1 +0,0 @@
-# coding=utf-8

tests/functional tests/settings.py

@@ -1,11 +0,0 @@
-"""
-Common constants and parameters to be used functional tests. This is done so that
-the beams are all similar in size and loading.
-"""
-
-L = 120  # in, length of beam in inches
-P = -1000  # lbs, load acting on beam
-E = 29e6  # psi, Young's modulus
-Ixx = 350  # in^4 area moment of inertia of beam
-EI = E * Ixx  # common constant
-TOL = 1e-1  # allowable tolerance between exact and numerical solutions to pass

tests/functional tests/test_fixed_support_beams.py

@@ -1,38 +0,0 @@
-"""
-Functional tests for beams with fixed supports
-
-https://www.awc.org/pdf/codes-standards/publications/design-aids/AWC-DA6-BeamFormulas-0710.pdf
-
-"""
-
-import pytest
-from settings import E, EI, Ixx, L, P, TOL
-from validate import validate
-
-from femethods.elements import Beam
-from femethods.loads import PointLoad
-from femethods.reactions import FixedReaction
-
-
-def test_cantilevered_beam_load_at_end():
-    """fixed beam with concentrated load at free end
-    case 13
-    """
-
-    R = -P
-    M_max = P * L  # at fixed end
-
-    d_max = P * L ** 3 / (3 * EI)  # at free end
-
-    beam = Beam(
-        length=L,
-        loads=[PointLoad(magnitude=P, location=0)],
-        reactions=[FixedReaction(L)],
-        E=E,
-        Ixx=Ixx,
-    )
-    beam.solve()
-
-    validate(beam, loc=0, R=[(R, M_max)], M_loc=0, d_loc=d_max)
-
-    assert pytest.approx(beam.moment(L), rel=TOL) == M_max