anastruct.fem.util.load
=======================

.. py:module:: anastruct.fem.util.load


Classes
-------

.. autoapisummary::

   anastruct.fem.util.load.LoadCase
   anastruct.fem.util.load.LoadCombination


Module Contents
---------------

.. py:class:: LoadCase(name: str)

   Group different loads in a load case


   .. py:attribute:: name
      :type:  str


   .. py:attribute:: spec
      :type:  dict


   .. py:attribute:: c
      :type:  int
      :value: 0



   .. py:method:: q_load(q: Union[float, Sequence[float]], element_id: Union[int, Sequence[int]], direction: Union[str, Sequence[str]] = 'element', rotation: Optional[Union[float, Sequence[float]]] = None, q_perp: Optional[Union[float, Sequence[float]]] = None) -> None

      Apply a q-load to an element.

      :param element_id: (int/ list) representing the element ID
      :param q: (flt) value of the q-load
      :param direction: (str) "element", "x", "y", "parallel"



   .. py:method:: point_load(node_id: Union[int, Sequence[int]], Fx: Union[float, Sequence[float]] = 0, Fy: Union[float, Sequence[float]] = 0, rotation: Union[float, Sequence[float]] = 0) -> None

      Apply a point load to a node.

      :param node_id: (int/ list) Nodes ID.
      :param Fx: (flt/ list) Force in global x direction.
      :param Fy: (flt/ list) Force in global x direction.
      :param rotation: (flt/ list) Rotate the force clockwise. Rotation is in degrees.



   .. py:method:: moment_load(node_id: Union[int, Sequence[int]], Tz: Union[float, Sequence[float]]) -> None

      Apply a moment on a node.

      :param node_id: (int/ list) Nodes ID.
      :param Tz: (flt/ list) Moments acting on the node.



   .. py:method:: dead_load(element_id: Union[int, Sequence[int]], g: Union[float, Sequence[float]]) -> None

      Apply a dead load in kN/m on elements.

      :param element_id: (int/ list) representing the element ID
      :param g: (flt/ list) Weight per meter. [kN/m] / [N/m]



   .. py:method:: __str__() -> str


.. py:class:: LoadCombination(name: str)

   .. py:attribute:: name
      :type:  str


   .. py:attribute:: spec
      :type:  dict


   .. py:method:: add_load_case(lc: Union[LoadCase, Sequence[LoadCase]], factor: Union[float, Sequence[float]]) -> None

      Add a load case to the load combination.

      :param lc: (:class:`anastruct.fem.util.LoadCase`)
      :param factor: (flt) Multiply all the loads in this LoadCase with this factor.



   .. py:method:: solve(system: anastruct.fem.system.SystemElements, force_linear: bool = False, verbosity: int = 0, max_iter: int = 200, geometrical_non_linear: bool = False, **kwargs: Any) -> Dict[str, anastruct.fem.system.SystemElements]

      Evaluate the Load Combination.

      :param system: (:class:`anastruct.fem.system.SystemElements`) Structure to apply loads on.
      :param force_linear: (bool) Force a linear calculation. Even when the system has non
                           linear nodes.
      :param verbosity: (int) 0: Log calculation outputs. 1: silence.
      :param max_iter: (int) Maximum allowed iterations.
      :param geometrical_non_linear: (bool) Calculate second order effects and determine the
                                     buckling factor.
      :return: (ResultObject)

      Development **kwargs:
          :param naked: (bool) Whether or not to run the solve function without doing
                        post processing.
          :param discretize_kwargs: When doing a geometric non linear analysis you can reduce or
                                    increase the number of elements created that are used for
                                    determining the buckling_factor