```{raw} latex \clearpage ``` (sec-item-objectbeamgeometricallyexact2d)= # ObjectBeamGeometricallyExact2D A 2D geometrically exact beam finite element, using 2 or 3 nodes of type NodeRigidBody2D. Note that the orientation of the nodes need to follow the cross section orientation in case that includeReferenceRotations=True; e.g., an angle 0 represents the cross section aligned with the $y$-axis, while and angle $\pi/2$ means that the cross section points in negative $x$-direction. Pre-curvature can be included with referenceCurvature and axial pre-stress can be considered by using a length different from the reference configuration of the nodes. The localPosition of the beam with length $L$=length and height $h$ ranges in $X$-direction in range $[-L/2, L/2]$ and in $Y$-direction in range $[-h/2,h/2]$ (which is in fact not needed in the {ref}`EOM `). ## Interface - Python names: `ObjectBeamGeometricallyExact2D` or `Beam2D`, and `VBeam2D` for its visualization - Nodes it takes: [](#sec-item-noderigidbody2d), [](#sec-item-nodepoint2dslope1) - Body markers that can be placed on it: [](#sec-item-markerbodymass), [](#sec-item-markerbodyposition), [](#sec-item-markerbodyrigid) ## Parameters The parameters of the item; in a dictionary, its type is 'BeamGeometricallyExact2D': | name | type | size | default | description | |---|---|---|---|---| | **name** | String | | '' | objects's unique name | | **nodeNumbers** | ArrayNodeIndex | | [] | two node numbers for beam element | | **length** | UReal | | 0. | (symbol: $L$) [SI:m] reference length of beam; such that the total volume (e.g. for volume load) gives $\rho A L$; must be positive | | **massPerLength** | UReal | | 0. | (symbol: $\rho A$) [SI:kg/m] mass per length of beam | | **crossSectionInertia** | UReal | | 0. | (symbol: $\rho J$) [SI:kg m] cross section mass moment of inertia; inertia acting against rotation of cross section | | **bendingStiffness** | UReal | | 0. | (symbol: $EI$) [SI:Nm$^2$] bending stiffness of beam; the bending moment is $m = EI (\kappa - \kappa_0)$, in which $\kappa$ is the material measure of curvature | | **axialStiffness** | UReal | | 0. | (symbol: $EA$) [SI:N] axial stiffness of beam; the axial force is $f_{ax} = EA (\varepsilon -\varepsilon_0)$, in which $\varepsilon$ is the axial strain | | **shearStiffness** | UReal | | 0. | (symbol: $GA$) [SI:N] effective shear stiffness of beam, including stiffness correction | | **bendingDamping** | UReal | | 0. | (symbol: $d_{K}$) [SI:Nm$^2$/s] viscous damping of bending deformation; the additional virtual work due to damping is $\delta W_{\dot \kappa} = \int_0^L \dot \kappa \delta \kappa dx$ | | **axialDamping** | UReal | | 0. | (symbol: $d_{\varepsilon}$) [SI:N/s] viscous damping of axial deformation | | **shearDamping** | UReal | | 0. | (symbol: $d_{\gamma}$) [SI:N/s] viscous damping of shear deformation | | **referenceCurvature** | Real | | 0. | (symbol: $\kappa_0$) [SI:1/m] reference curvature of beam (pre-deformation) of beam | | **includeReferenceRotations** | bool | | False | if True, rotation of the cross section at the nodes includes node reference rotations (within referenceCoordinates of NodeRigidBody2D), which are used for the computation of bending strains (this means that a pre-curved beam is stress-free); if False, the reference rotation of the cross section is orthogonal to the reference slope vector. This allows to easily share nodes among several beams with different reference cross section orientation (i.e., only the change of rotation counts). | | **visualization** | VObjectBeamGeometricallyExact2D | | | parameters for visualization of item | Renamed parameters, still taken with a `DeprecationWarning`: `physicsLength` (deprecated since 1.12.258, removed in 2031): use `length`; `physicsMassPerLength` (deprecated since 1.12.258, removed in 2031): use `massPerLength`; `physicsCrossSectionInertia` (deprecated since 1.12.258, removed in 2031): use `crossSectionInertia`; `physicsBendingStiffness` (deprecated since 1.12.258, removed in 2031): use `bendingStiffness`; `physicsAxialStiffness` (deprecated since 1.12.258, removed in 2031): use `axialStiffness`; `physicsShearStiffness` (deprecated since 1.12.258, removed in 2031): use `shearStiffness`; `physicsBendingDamping` (deprecated since 1.12.258, removed in 2031): use `bendingDamping`; `physicsAxialDamping` (deprecated since 1.12.258, removed in 2031): use `axialDamping`; `physicsShearDamping` (deprecated since 1.12.258, removed in 2031): use `shearDamping`; `physicsReferenceCurvature` (deprecated since 1.12.258, removed in 2031): use `referenceCurvature`. ## Visualization parameters The parameters of `VObjectBeamGeometricallyExact2D`, given as `visualization`: | name | type | size | default | description | |---|---|---|---|---| | **show** | Bool | | True | set true, if item is shown in visualization and false if it is not shown | | **drawHeight** | float | | 0. | if beam is drawn with rectangular shape, this is the drawing height | | **color** | Float4 | 4 | [-1.,-1.,-1.,-1.] | RGBA color of the object; if R==-1, use default color | ## Drawing Drawn as [all finite elements](#sec-drawing-objectsfiniteelement); a band of height `drawHeight` along the axis, of `bodies.beams.axialTiling` segments, or a line if `drawHeight` is 0; the `bodies.beams.drawVertical...` settings draw a value across it. Settings beyond those of all finite elements: [`bodies.beams.axialTiling`](#sec-vsettingsbeams), [`bodies.beams.crossSectionFilled`](#sec-vsettingsbeams), [`bodies.beams.drawVertical`](#sec-vsettingsbeams), [`bodies.beams.drawVerticalColor`](#sec-vsettingsbeams), [`bodies.beams.drawVerticalFactor`](#sec-vsettingsbeams), [`bodies.beams.drawVerticalLines`](#sec-vsettingsbeams), [`bodies.beams.drawVerticalOffset`](#sec-vsettingsbeams), [`bodies.beams.drawVerticalValues`](#sec-vsettingsbeams), [`general.rendererPrecision`](#sec-vsettingsgeneral). ## Output variables Available as `OutputVariableType` in sensors, `Get...Output()` and other functions: ```{tabularcolumns} \Y{0.25}\Y{0.25}\Y{0.5} ``` | output variable | symbol | description | |---|---|---| | Position | | global position vector of local axis (X) and cross section (Y) position | | Displacement | | global displacement vector of local axis (X) and cross section (Y) position | | Velocity | | global velocity vector of local axis (X) and cross section (Y) position | | Rotation | | 3D Tait-Bryan rotation components, containing rotation around $Z$-axis only | | StrainLocal | | 6 (local) strain components, containing only axial ($XX$, index 0) and shear strain ($XY$, index 5); evaluated at beam axis ONLY | | CurvatureLocal | | 3D vector of (local) curvature, only $Z$ component is non-zero | | ForceLocal | | 3D vector of (local) section normal force, containing axial (X) and shear force (Y) | | TorqueLocal | | 3D vector of (local) torques, containing only bending moment (Z) | | KineticEnergy | $T = \frac{1}{2} \dot\qv\tp \Mm\, \dot\qv$ | kinetic energy from the mass matrix of the current state and the velocities of the nodes; current configuration only; localPosition must be $[0,0,0]$ | | PotentialEnergy | $V = \frac{1}{2}\int_0^L EA\,\gamma_1^2 + GA\,\gamma_2^2 + EI\,\theta_x^2\, dx$ | elastic energy of the axial, shear and bending strains, integrated with the rule of the elastic forces; localPosition must be $[0,0,0]$ | (description-objectbeamgeometricallyexact2d)= ## Detailed description A shear deformable beam after Simo and Vu-Quoc (1986): the positions and the rotations of the cross section are interpolated independently. ### Nodes and coordinates Two nodes (linear element) or three nodes (quadratic element) of type `NodeRigidBody2D`, each with the position $[r_{x},\, r_{y}]$ of the axis and the rotation $\theta$ of the cross section; 6 or 9 coordinates. The local axial coordinate is $x \in [-L/2,\, L/2]$. ### Kinematics and interpolation Position and rotation are interpolated with Lagrange shape functions - linear, $S_0 = (L/2 - x)/L$, $S_1 = (L/2 + x)/L$, or quadratic in $\xi = 2x/L$ - $$ \rv(x) = \sum_i S_i(x)\, \rv_i , \quad \theta(x) = \sum_i S_i(x)\, \theta_i . $$ With `includeReferenceRotations = False` (default) the rotation of the cross section is measured from the direction of the reference axis, $\mathrm{atan2}(r'_{y,\mathrm{ref}},\, r'_{x,\mathrm{ref}})$; with `True` the reference rotations of the nodes are used. ### Strains With the tangent $\tv = [\cos\theta,\, \sin\theta]\tp$ and the normal $\nv = [-\sin\theta,\, \cos\theta]\tp$ of the cross section, $$ \gamma_1 = \tv\tp \rv' - 1 , \quad \gamma_2 = \nv\tp \rv' , \quad \kappa = \theta' - \kappa_0 , $$ the axial strain, the shear strain and the curvature, with the reference curvature $\kappa_0$ = `referenceCurvature`. The virtual work of the elastic forces is $$ \delta W_e = \int_{-L/2}^{L/2} \left( EA\,\gamma_1\,\delta\gamma_1 + GA\,\gamma_2\,\delta\gamma_2 + EI\,\kappa\,\delta\kappa \right) dx , $$ with the damping terms $d_\varepsilon \dot\gamma_1$, $d_\gamma \dot\gamma_2$ and $d_K \dot\kappa$ added in the same way. ### Mass matrix and integration The mass matrix is constant: $\rho A$ for the positions and $\rho J$ for the rotations, integrated with Gauss rules of order 3 (linear) or 5 (quadratic). The elastic forces are integrated with **reduced** integration against shear locking: one point for the linear element, the rule of order 3 for the quadratic element. ### Marker interfaces The position and rotation Jacobians follow from the interpolation above; a marker at a local position $(x,\, y)$ moves with the cross section. ### Limitations Planar; the output variables `StrainLocal` and `ForceLocal` give $\gamma_1$ and $\gamma_2$ and the forces $EA\gamma_1$, $GA\gamma_2$. (miniexample-objectbeamgeometricallyexact2d)= ## Mini example ```python #a cantilever of four planar geometrically exact beam elements on rigid body nodes, loaded at the tip L = 1; nElements = 4; EI = 100; GA = 1e4; F = -0.1 mGround = mbs.AddMarker(MarkerNodeCoordinate(nodeNumber=nGround, coordinate=0)) n0 = mbs.AddNode(NodeRigidBody2D(referenceCoordinates=[0,0,0])) for i in range(3): #clamped: x, y, rotation mbs.AddObject(ObjectConnectorCoordinate(markerNumbers=[mGround, mbs.AddMarker(MarkerNodeCoordinate(nodeNumber=n0, coordinate=i))])) for k in range(nElements): n1 = mbs.AddNode(NodeRigidBody2D(referenceCoordinates=[L*(k+1)/nElements,0,0])) mbs.AddObject(ObjectBeamGeometricallyExact2D(nodeNumbers=[n0,n1], length=L/nElements, massPerLength=1, crossSectionInertia=0.01, bendingStiffness=EI, axialStiffness=1e5, shearStiffness=GA)) n0 = n1 mbs.AddLoad(LoadForceVector(markerNumber=mbs.AddMarker(MarkerNodePosition(nodeNumber=n1)), loadVector=[0,F,0])) mbs.Assemble() mbs.SolveStatic() #Timoshenko beam: F*L^3/(3*EI) + F*L/GA = -0.3433e-3, approached with more elements exu.sys['testResult'] = mbs.GetNodeOutput(n1, exu.OutputVariableType.Displacement)[1]*1000 ``` Relevant Examples (Ex) and TestModels (TM) with weblink to github: [`pendulumGeomExactBeam2D.py`](https://github.com/jgerstmayr/EXUDYN/blob/master/python/Examples/pendulumGeomExactBeam2D.py) (Ex), [`ANCFBeamEigTest.py`](https://github.com/jgerstmayr/EXUDYN/blob/master/python/TestModels/ANCFBeamEigTest.py) (TM), [`energiesFlexibleBodiesTest.py`](https://github.com/jgerstmayr/EXUDYN/blob/master/python/TestModels/energiesFlexibleBodiesTest.py) (TM), [`flexiblePendulumBeamComparison.py`](https://github.com/jgerstmayr/EXUDYN/blob/master/python/TestModels/flexiblePendulumBeamComparison.py) (TM), [`geometricallyExactBeam2DquadraticTest.py`](https://github.com/jgerstmayr/EXUDYN/blob/master/python/TestModels/geometricallyExactBeam2DquadraticTest.py) (TM), [`geometricallyExactBeam2Dtest.py`](https://github.com/jgerstmayr/EXUDYN/blob/master/python/TestModels/geometricallyExactBeam2Dtest.py) (TM), [`gridGeomExactBeam2D.py`](https://github.com/jgerstmayr/EXUDYN/blob/master/python/TestModels/gridGeomExactBeam2D.py) (TM), [`LShapeGeomExactBeam2D.py`](https://github.com/jgerstmayr/EXUDYN/blob/master/python/TestModels/LShapeGeomExactBeam2D.py) (TM)