From 3d6892b4693d38bd44b04419cd76198112d6ca30 Mon Sep 17 00:00:00 2001 From: "Documenter.jl" Date: Mon, 16 Dec 2024 00:48:46 +0000 Subject: [PATCH] build based on d5d41b5 --- dev/.documenter-siteinfo.json | 2 +- dev/guide/guide.html | 2 +- dev/index.html | 2 +- dev/man/man.html | 32 ++++++++++++++++---------------- 4 files changed, 19 insertions(+), 19 deletions(-) diff --git a/dev/.documenter-siteinfo.json b/dev/.documenter-siteinfo.json index c011854..12abee9 100644 --- a/dev/.documenter-siteinfo.json +++ b/dev/.documenter-siteinfo.json @@ -1 +1 @@ -{"documenter":{"julia_version":"1.10.7","generation_timestamp":"2024-12-15T19:29:13","documenter_version":"1.2.1"}} \ No newline at end of file +{"documenter":{"julia_version":"1.10.7","generation_timestamp":"2024-12-16T00:48:41","documenter_version":"1.2.1"}} \ No newline at end of file diff --git a/dev/guide/guide.html b/dev/guide/guide.html index ee9a781..f03533f 100644 --- a/dev/guide/guide.html +++ b/dev/guide/guide.html @@ -1,2 +1,2 @@ -How to guide · FinEtoolsFlexStructures.jl
GitHub

Guide

The FinEtoolsFlexStructures package is used to solve static and dynamic linear and nonlinear problems involving beams and linear static and dynamic analysis of shells.

The basic functionality is provided by the FinEtools package.

Tutorials are provided in the form of Julia scripts and Markdown files in a dedicated folder: index of tutorials.

To understand how the package works in depth, we would suggest inspecting the examples. The examples are organized by category: statics, dynamics, etc. There is usually an indication of what the correct answer should be (frequencies, deflections, buckling factors, ...). Many examples correspond to well-known benchmarks.

+How to guide · FinEtoolsFlexStructures.jl
GitHub

Guide

The FinEtoolsFlexStructures package is used to solve static and dynamic linear and nonlinear problems involving beams and linear static and dynamic analysis of shells.

The basic functionality is provided by the FinEtools package.

Tutorials are provided in the form of Julia scripts and Markdown files in a dedicated folder: index of tutorials.

To understand how the package works in depth, we would suggest inspecting the examples. The examples are organized by category: statics, dynamics, etc. There is usually an indication of what the correct answer should be (frequencies, deflections, buckling factors, ...). Many examples correspond to well-known benchmarks.

diff --git a/dev/index.html b/dev/index.html index 5f625e3..adf7cca 100644 --- a/dev/index.html +++ b/dev/index.html @@ -1,2 +1,2 @@ -Home · FinEtoolsFlexStructures.jl
GitHub

FinEtoolsFlexStructures Documentation

Conceptual guide

The construction of the toolkit is described: the composition of modules, the basic data structures, the methodology of computing quantities required in the finite element methodology, and more.

Manual

The description of the types and the functions, organized by module and/or other logical principle.

Index

+Home · FinEtoolsFlexStructures.jl
GitHub

FinEtoolsFlexStructures Documentation

Conceptual guide

The construction of the toolkit is described: the composition of modules, the basic data structures, the methodology of computing quantities required in the finite element methodology, and more.

Manual

The description of the types and the functions, organized by module and/or other logical principle.

Index

diff --git a/dev/man/man.html b/dev/man/man.html index 684d7ef..8bc7e6a 100644 --- a/dev/man/man.html +++ b/dev/man/man.html @@ -1,8 +1,8 @@ -Reference · FinEtoolsFlexStructures.jl
GitHub

Manual

Composite Layup

FinEtoolsFlexStructures.CompositeLayupModule.cartesian_csys — Method
cartesian_csys(axes)

Create a material Cartesian coordinate system.

  • axes = tuple of signed labels of the axes. For instance, (1, 2, 3) creates a coordinate system identical to the global cartesian coordinate system. (2, 1, -3) creates a coordinate system so that the first material basis vector is along the second global basis vector, the second material basis vector is along the first global basis vector, and the third material basis vector is opposite to the third global basis vector.
source
FinEtoolsFlexStructures.CompositeLayupModule.laminate_stiffnesses! — Method
laminate_stiffnesses!(cl::CompositeLayup, A, B, D)

Compute the laminate stiffness matrices, membrane, extension-bending coupling, and bending.

A, B, and D are the familiar 3x3 matrices: Aij coefficients represent in-plane stiffness of the laminate, the Dij coefficients represent bending stiffness, the Bij represent bending-extension coupling.

source
FinEtoolsFlexStructures.CompositeLayupModule.plane_stress_T_matrix! — Method
plane_stress_T_matrix!(Tm::Array{T, 2}, angle) where {T}

Compute the transformation matrix of stress vector components FROM the PLY coordinate system TO the LAYOUT coordinate system.

angle = angle (in radians) between the first basis vector of the layup coordinate system and the first basis vector of the ply coordinate system m, n = cosine and sine of the angle

The nomenclature is from Barbero, Finite element analysis of composite materials using Abaqus (2013).

source
FinEtoolsFlexStructures.CompositeLayupModule.plane_stress_Tbar_matrix! — Method
plane_stress_Tbar_matrix!(Tm::Array{T, 2}, angle) where {T}
-plane_stress_Tbar_matrix!(Tm::Array{T, 2}, m, n) where {T}

Compute the transformation matrix of engineering strain components FROM the LAYUP coordinate system TO the PLY coordinate system.

angle = angle (in radians) between the first basis vector of the layup coordinate system and the first basis vector of the ply coordinate system m, n = cosine and sine of the angle

The nomenclature is from Barbero, Finite element analysis of composite materials using Abaqus (2013).

source
FinEtoolsFlexStructures.CompositeLayupModule.plane_stress_Tinv_matrix! — Method
plane_stress_Tinv_matrix!(Tinvm::Array{T, 2}, angle) where {T}
-plane_stress_Tinv_matrix!(Tinvm::Array{T, 2}, m, n) where {T}

Compute the transformation matrix of the stress vector components FROM the LAYOUT coordinate system TO the PLY coordinate system.

angle = angle (in radians) between the first basis vector of the layup coordinate system and the first basis vector of the ply coordinate system m, n = cosine and sine of the angle

The nomenclature is from Barbero, Finite element analysis of composite materials using Abaqus (2013).

source
FinEtoolsFlexStructures.CompositeLayupModule.transverse_shear_T_matrix! — Method
transverse_shear_T_matrix!(Tm::Array{T, 2}, angle) where {T}
-transverse_shear_T_matrix!(Tm::Array{T, 2}, m, n) where {T}

Compute the transformation matrix for the transverse shear stresses FROM the LAYOUT coordinate system TO the PLY coordinate system.

angle = angle (in radians) between the first basis vector of the layup coordinate system and the first basis vector of the ply coordinate system m, n = cosine and sine of the angle

source
FinEtoolsFlexStructures.CompositeLayupModule.CompositeLayup — Method
CompositeLayup(name, plies, mcsys)

Create a composite layup.

Provide the name, the array of plies, and the coordinate system that defines the orientation of the composite layup. The first base spector of this coordinate system is the reference direction for the layup.

source
FinEtoolsFlexStructures.CompositeLayupModule.Ply — Method
Ply{M} <: AbstractPly

Create a ply.

Provide name, material of the ply, thickness of the ply, an angle between the first bases vector of the layup coordinate system and the first direction of the ply material coordinate system.

source

Cross Section

Meshing of Frame Members

FE Set for two-node Beams

Base.cat — Method
cat(self::T,  other::T) where {T<:FESetL2Beam}

Concatenate two sets of beam elements.

source
FinEtoolsFlexStructures.FESetL2BeamModule.FESetL2Beam — Type
mutable struct FESetL2Beam{CT} <: AbstractFESet1Manifold{2}

Type of a two-node beam finite element set.

The elements in the set have the same cross section type, but since the cross section dimensions may depend on the coordinate, each individual element may have a different area, second moments of area, etc.

source
FinEtoolsFlexStructures.FESetL2BeamModule.FESetL2Beam — Method
FESetL2Beam(N::IT, crosssection::CT) where {IT<:Integer, CT}

Constructor.

Supply the total number of elements in the set, and the cross-section definition. The parameters of the section are assumed to be uniform along the set of the beam elements.

source

FE Set for Shell T3 shapes

FEMM for Corotational Beams

FinEtoolsFlexStructures.FEMMCorotBeamModule.distribloads_global — Method
distribloads_global(self::FEMMCorotBeam, assembler::ASS, geom0::NodalField{GFT}, u1::NodalField{T}, Rfield1::NodalField{T}, dchi::NodalField{TI}, fi) where {ASS<:AbstractSysvecAssembler, GFT<:Number, T<:Number, TI<:Number}

Compute the load vector due to distributed loads.

Compute the global load vector corresponding to applied distributed load. Here it means force per unit length of the beam, in the configuration u1, Rfield1. These are only forces, not moments.

Note

The force intensity must be uniform across the entire element. The force intensity is given in the global coordinates.

source
FinEtoolsFlexStructures.FEMMCorotBeamModule.geostiffness — Method
geostiffness(self::FEMMCorotBeam, assembler::ASS, geom0::NodalField{GFT}, u1::NodalField{T}, Rfield1::NodalField{T}, dchi::NodalField{TI}) where {ASS<:AbstractSysmatAssembler, GFT<:Number, T<:Number, TI<:Number}

Compute the geometric stiffness matrix.

source
FinEtoolsFlexStructures.FEMMCorotBeamModule.gyroscopic — Method
gyroscopic(self::FEMMCorotBeam, assembler::ASS, geom0::NodalField{GFT}, u1::NodalField{T}, Rfield1::NodalField{T}, v1::NodalField{T}, dchi::NodalField{TI}; mass_type=MASS_TYPE_CONSISTENT_WITH_ROTATION_INERTIA) where {ASS<:AbstractSysmatAssembler, GFT<:Number, T<:Number, TI<:Number}

Compute the quadratic-inertial-term (gyroscopic) mass matrix

This is a general routine for the abstract linear-deformation FEMM.

source
FinEtoolsFlexStructures.FEMMCorotBeamModule.local_cartesian_to_natural! — Method
local_cartesian_to_natural!(aN, L)

Compute transformation from local Cartesian displacements to natural deformations of a beam element.

Matrix defined in Eq (4.8) of COMPUTER METHODS IN APPLIED MECHANICS AND ENGINEERING 14 (1978) 401-451 ON LARGE DISPLACEMENT-SMALL STRAIN ANALYSIS OF STRUCTURES WITH ROTATIONAL DEGREES OF FREEDOM. J.H. ARGYRIS, P.C. DUNNE and D.W. SCHARPF

Arguments

L= current length of the element

Outputs

aN= transformation matrix to take Cartesian (local) displacement increments in the element frame and to produce increments of natural deformations; see local_frame_and_def! for the definition of the natural deformations

source
FinEtoolsFlexStructures.FEMMCorotBeamModule.local_forces! — Method
local_forces!(FL, PN, L, aN)

Compute forces through which the element acts on the nodes in the local coordinate system.

Arguments

PN = column vector of natural forces; L= current length of the element, aN= transformation matrix to take Cartesian (local) displacement increments in the element frame and to produce increments of natural deformations; see local_frame_and_def! for the definition of the natural deformations

Outputs

FL = vector of forces acting on the nodes in the local coordinate system

source
FinEtoolsFlexStructures.FEMMCorotBeamModule.local_frame_and_def! — Method
local_frame_and_def!(Ft, dN, F0, FtI, FtJ, x0, x1x2_vector, xt, RI, RJ)

Compute the current length of the element, the current element frame, and the natural deformations

Arguments

x0= array of node coordinates, one node per row, in initial configuration x1x2_vector= vector that lies in the x1-x2 local element coordinate plane, in initial configuration xt= array of node coordinates, one node per row, in initial configuration RI,RJ=nodal rotation (orthogonal) matrix

Outputs

Lt= current length of the element, Ft= current element frame (orthogonal rotation matrix) whose columns are unit vectors: they are centered halfway between the current locations of the nodes, vector 1 points from node I to node J, vector 3 is orthogonal to the sum of the nodal cross-section frame vectors 2 dN= vector of natural deformations; dN(1)= total change in length between configurations 0 and t; dN(2)= symmetric bending; dN(3)= anti-symmetric bending; dN(4)= symmetric bending dN(5)= anti-symmetric bending; dN(6)=total axial torsion angle.

source
FinEtoolsFlexStructures.FEMMCorotBeamModule.local_geometric_stiffness! — Method
local_geometric_stiffness!(SM, A, I2, I3, PN, L)

Compute the local geometric stiffness matrix.

Arguments

A= cross-sectional area, I2, I3=central moment of inertia of the cross-section about the x2 and x3 coordinate axis, PN= vector of natural forces; see natural_forces() for definitions L= current length of the element,

Outputs

SM = local geometric stiffness matrix, 12 x 12

This geometric stiffness matrix this consistent with relationship between the natural deformations and the natural forces that assumes there is only a linear constitutive link: no non-constitutive effects (bowing etc.) are included. This form of the geometric matrix was derived by Krenk. @BOOK{Krenk:2009, AUTHOR = {S. Krenk}, TITLE = {Non-linear Modeling and Analysis of Solids and Structures }, PUBLISHER = {Cambridge University Press}, YEAR = {2009}, isbn = {9780521830546} }

source
FinEtoolsFlexStructures.FEMMCorotBeamModule.local_mass! — Method
local_mass!(MM, A, I1, I2, I3, rho, L, mass_type)

Mass matrix of the beam.

Arguments

A= cross-sectional area, I1=central moment of inertia of the cross-section about the x1 axis, I2, I3=central moment of inertia of the cross-section about the x2 and x3 coordinate axis, rho=mass density, L= initial length of the element,

Outputs

MM = local mass matrix, 12 x 12 In the element frame the mass matrix is constant.

source
FinEtoolsFlexStructures.FEMMCorotBeamModule.local_stiffness! — Method
local_stiffness!(SM, E, G, A, I2, I3, J, A2s, A3s, L, aN, DN)

Compute the local elastic stiffness matrix.

Arguments

E, G= Young's and shear modulus, A= cross-sectional area, I2, I3=central moment of inertia of the cross-section about the x2 and x3 coordinate axis, J=St Venant torsion constant, L= current length of the element,

Outputs

SM = local stiffness matrix, 12 x 12

source
FinEtoolsFlexStructures.FEMMCorotBeamModule.mass — Method
mass(self::FEMMCorotBeam, assembler::ASS, geom0::NodalField{GFT}, u1::NodalField{T}, Rfield1::NodalField{T}, dchi::NodalField{TI}; mass_type=MASS_TYPE_CONSISTENT_WITH_ROTATION_INERTIA) where {ASS<:AbstractSysmatAssembler, GFT<:Number, T<:Number, TI<:Number}

Compute the consistent mass matrix

This is a general routine for the abstract linear-deformation FEMM.

source
FinEtoolsFlexStructures.FEMMCorotBeamModule.natural_forces! — Method
natural_forces!(PN, E, G, A, I2, I3, J, A2s, A3s, L, dN, DN)

Compute the natural forces from the natural deformations.

Argument

E, G= Young's and shear modulus, A= cross-sectional area, I2, I3=central moment of inertia of the cross-section about the x2 and x3 coordinate axis, J=St Venant torsion constant, L= current length of the element, dN= column vector of natural deformations; see local_frames()

Outputs

PN = column vector of natural forces; PN[1]= axial force; PN[2]= symmetric bending moment in the plane x1-x2; PN[3]= anti-symmetric bending bending moment in the plane x1-x2; PN[4]= symmetric bending bending moment in the plane x1-x3; PN[5]= anti-symmetric bending bending moment in the plane x1-x3; PN[6]= axial torque.

source
FinEtoolsFlexStructures.FEMMCorotBeamModule.natural_stiffness_Bernoulli! — Method
natural_stiffness_Bernoulli!(DN, E, G, A, I2, I3, J, A2s, A3s, L)

Compute the natural stiffness matrix.

function DN = natural_stiffness(self, E, G, A, I2, I3, J, L)

Arguments

  • E, G= Young's and shear modulus,
  • A= cross-sectional area,
  • I2, I3= central moment of inertia of the cross-section about the x2 and x3 coordinate axis,
  • J= St Venant torsion constant,
  • A2s = effective area for shear in the direction of x2 (ignored)
  • A3s = effective area for shear in the direction of x3 (ignored)
  • L= current length of the element,

Outputs

  • DN = 6 x 6 natural stiffness matrix
source
FinEtoolsFlexStructures.FEMMCorotBeamModule.natural_stiffness_Timoshenko! — Method
natural_stiffness_Timoshenko!(DN, E, G, A, I2, I3, J, A2s, A3s, L)

Compute the natural stiffness matrix.

function DN = natural_stiffness(self, E, G, A, I2, I3, J, L)

Arguments

  • E, G= Young's and shear modulus,
  • A= cross-sectional area,
  • I2, I3= central moment of inertia of the cross-section about the x2 and x3 coordinate axis,
  • J= St Venant torsion constant,
  • A2s = effective area for shear in the direction of x2
  • A3s = effective area for shear in the direction of x3
  • L= current length of the element,

Outputs

  • DN = 6 x 6 natural stiffness matrix
source
FinEtoolsFlexStructures.FEMMCorotBeamModule.restoringforce — Method
restoringforce(self::FEMMCorotBeam, assembler::ASS, geom0::NodalField{GFT}, u1::NodalField{T}, Rfield1::NodalField{T}, dchi::NodalField{TI}) where {ASS<:AbstractSysvecAssembler, GFT<:Number, T<:Number, TI<:Number}

Compute the vector of the restoring elastic forces

source
FinEtoolsFlexStructures.FEMMCorotBeamModule.stiffness — Method
stiffness(self::FEMMCorotBeam, assembler::ASS, geom0::NodalField{GFT}, u1::NodalField{T}, Rfield1::NodalField{T}, dchi::NodalField{TI}) where {ASS<:AbstractSysmatAssembler, GFT<:Number, T<:Number, TI<:Number}

Compute the material stiffness matrix.

source

FEMM for linear beams with eccentric connections

FinEtools.FEMMBaseModule.inspectintegpoints — Method
inspectintegpoints(
+Reference · FinEtoolsFlexStructures.jl
GitHub
Manual
Composite Layup
FinEtoolsFlexStructures.CompositeLayupModule.cartesian_csys — Method
cartesian_csys(axes)
Create a material Cartesian coordinate system.
  • axes = tuple of signed labels of the axes. For instance, (1, 2, 3) creates a coordinate system identical to the global cartesian coordinate system. (2, 1, -3) creates a coordinate system so that the first material basis vector is along the second global basis vector, the second material basis vector is along the first global basis vector, and the third material basis vector is opposite to the third global basis vector.
source
FinEtoolsFlexStructures.CompositeLayupModule.laminate_stiffnesses! — Method
laminate_stiffnesses!(cl::CompositeLayup, A, B, D)
Compute the laminate stiffness matrices, membrane, extension-bending coupling, and bending.
A, B, and D are the familiar 3x3 matrices: Aij coefficients represent in-plane stiffness of the laminate, the Dij coefficients represent bending stiffness, the Bij represent bending-extension coupling.
source
FinEtoolsFlexStructures.CompositeLayupModule.plane_stress_T_matrix! — Method
plane_stress_T_matrix!(Tm::Array{T, 2}, angle) where {T}
Compute the transformation matrix of stress vector components FROM the PLY coordinate system TO the LAYOUT coordinate system.
angle = angle (in radians) between the first basis vector of the layup     coordinate system and the first basis vector of the ply coordinate system m, n = cosine and sine of the angle
The nomenclature is from Barbero, Finite element analysis of composite materials using Abaqus (2013).
source
FinEtoolsFlexStructures.CompositeLayupModule.plane_stress_Tbar_matrix! — Method
plane_stress_Tbar_matrix!(Tm::Array{T, 2}, angle) where {T}
+plane_stress_Tbar_matrix!(Tm::Array{T, 2}, m, n) where {T}
Compute the transformation matrix of engineering strain components FROM the LAYUP coordinate system TO the PLY coordinate system.
angle = angle (in radians) between the first basis vector of the layup     coordinate system and the first basis vector of the ply coordinate system m, n = cosine and sine of the angle
The nomenclature is from Barbero, Finite element analysis of composite materials using Abaqus (2013).
source
FinEtoolsFlexStructures.CompositeLayupModule.plane_stress_Tinv_matrix! — Method
plane_stress_Tinv_matrix!(Tinvm::Array{T, 2}, angle) where {T}
+plane_stress_Tinv_matrix!(Tinvm::Array{T, 2}, m, n) where {T}
Compute the transformation matrix of the stress vector components FROM the LAYOUT coordinate system TO the PLY coordinate system.
angle = angle (in radians) between the first basis vector of the layup     coordinate system and the first basis vector of the ply coordinate system m, n = cosine and sine of the angle
The nomenclature is from Barbero, Finite element analysis of composite materials using Abaqus (2013).
source
FinEtoolsFlexStructures.CompositeLayupModule.transverse_shear_T_matrix! — Method
transverse_shear_T_matrix!(Tm::Array{T, 2}, angle) where {T}
+transverse_shear_T_matrix!(Tm::Array{T, 2}, m, n) where {T}
Compute the transformation matrix for the transverse shear stresses  FROM the LAYOUT coordinate system TO the PLY coordinate system.
angle = angle (in radians) between the first basis vector of the layup     coordinate system and the first basis vector of the ply coordinate system m, n = cosine and sine of the angle
source
FinEtoolsFlexStructures.CompositeLayupModule.CompositeLayup — Method
CompositeLayup(name, plies, mcsys)
Create a composite layup.
Provide the name, the array of plies, and the coordinate system that defines the orientation of the composite layup. The first base spector of this coordinate system is the reference direction for the layup.
source
FinEtoolsFlexStructures.CompositeLayupModule.Ply — Method
Ply{M} <: AbstractPly
Create a ply.
Provide name, material of the ply, thickness of the ply, an angle between the first bases vector of the layup coordinate system and the first direction of the ply material coordinate system.
source
Cross Section
Meshing of Frame Members
FE Set for two-node Beams
Base.cat — Method
cat(self::T,  other::T) where {T<:FESetL2Beam}
Concatenate two sets of beam elements.
source
FinEtoolsFlexStructures.FESetL2BeamModule.FESetL2Beam — Type
mutable struct FESetL2Beam{CT} <: AbstractFESet1Manifold{2}
Type of a two-node beam finite element set.
The elements in the set have the same cross section type, but since the cross section dimensions may depend on the coordinate, each individual element may have a different area, second moments of area, etc.
source
FinEtoolsFlexStructures.FESetL2BeamModule.FESetL2Beam — Method
FESetL2Beam(N::IT, crosssection::CT) where {IT<:Integer, CT}
Constructor.
Supply the total number of elements in the set, and the cross-section definition. The parameters of the section are assumed to be uniform along the set of the beam elements.
source
FE Set for Shell T3 shapes
FEMM for Corotational Beams
FinEtoolsFlexStructures.FEMMCorotBeamModule.distribloads_global — Method
distribloads_global(self::FEMMCorotBeam, assembler::ASS, geom0::NodalField{GFT}, u1::NodalField{T}, Rfield1::NodalField{T}, dchi::NodalField{TI}, fi) where {ASS<:AbstractSysvecAssembler, GFT<:Number, T<:Number, TI<:Number}
Compute the load vector due to distributed loads.
Compute the global load vector corresponding to applied distributed load. Here it means force per unit length of the beam, in the configuration u1, Rfield1. These are only forces, not moments.
Note
The force intensity must be uniform across the entire element. The force intensity is given in the global coordinates.
source
FinEtoolsFlexStructures.FEMMCorotBeamModule.geostiffness — Method
geostiffness(self::FEMMCorotBeam, assembler::ASS, geom0::NodalField{GFT}, u1::NodalField{T}, Rfield1::NodalField{T}, dchi::NodalField{TI}) where {ASS<:AbstractSysmatAssembler, GFT<:Number, T<:Number, TI<:Number}
Compute the geometric stiffness matrix.
source
FinEtoolsFlexStructures.FEMMCorotBeamModule.gyroscopic — Method
gyroscopic(self::FEMMCorotBeam, assembler::ASS, geom0::NodalField{GFT}, u1::NodalField{T}, Rfield1::NodalField{T}, v1::NodalField{T}, dchi::NodalField{TI}; mass_type=MASS_TYPE_CONSISTENT_WITH_ROTATION_INERTIA) where {ASS<:AbstractSysmatAssembler, GFT<:Number, T<:Number, TI<:Number}
Compute the quadratic-inertial-term (gyroscopic) mass matrix
This is a general routine for the abstract linear-deformation  FEMM.
source
FinEtoolsFlexStructures.FEMMCorotBeamModule.local_cartesian_to_natural! — Method
local_cartesian_to_natural!(aN, L)
Compute transformation from local Cartesian displacements to natural deformations of a beam element.
Matrix defined in Eq (4.8) of COMPUTER  METHODS  IN APPLIED  MECHANICS  AND  ENGINEERING   14  (1978)  401-451 ON LARGE  DISPLACEMENT-SMALL   STRAIN  ANALYSIS   OF  STRUCTURES WITH  ROTATIONAL   DEGREES  OF  FREEDOM. J.H.  ARGYRIS,   P.C.  DUNNE  and  D.W. SCHARPF
Arguments
L= current length of the element
Outputs
aN= transformation matrix to take Cartesian (local) displacement increments in the      element frame and to produce increments of natural deformations;      see local_frame_and_def! for the definition of the natural deformations
source
FinEtoolsFlexStructures.FEMMCorotBeamModule.local_forces! — Method
local_forces!(FL, PN, L, aN)
Compute forces through which the element acts on the nodes in the local coordinate system.
Arguments
PN = column vector of natural forces; L= current length of the element, aN= transformation matrix to take Cartesian (local) displacement increments in the      element frame and to produce increments of natural deformations;      see local_frame_and_def! for the definition of the natural deformations
Outputs
FL = vector of forces acting on the nodes in the local coordinate system
source
FinEtoolsFlexStructures.FEMMCorotBeamModule.local_frame_and_def! — Method
local_frame_and_def!(Ft, dN, F0, FtI, FtJ, x0, x1x2_vector, xt, RI, RJ)
Compute the current length of the element, the current element frame, and the natural deformations
Arguments
x0= array of node coordinates, one node per row, in initial configuration x1x2_vector= vector that lies in the x1-x2 local element coordinate      plane, in initial configuration xt= array of node coordinates, one node per row, in initial configuration RI,RJ=nodal rotation (orthogonal) matrix
Outputs
Lt= current length of the element, Ft= current element frame (orthogonal rotation matrix) whose columns are unit      vectors: they are centered halfway between the current locations of      the nodes, vector 1 points from node I to node J, vector 3 is      orthogonal to the sum of the nodal cross-section frame vectors 2 dN= vector of natural deformations; dN(1)= total change in length      between configurations 0 and t; dN(2)= symmetric bending;      dN(3)= anti-symmetric bending;    dN(4)= symmetric bending      dN(5)= anti-symmetric bending; dN(6)=total axial torsion angle.
source
FinEtoolsFlexStructures.FEMMCorotBeamModule.local_geometric_stiffness! — Method
local_geometric_stiffness!(SM, A, I2, I3, PN, L)
Compute the local geometric stiffness matrix.
Arguments
A= cross-sectional area, I2, I3=central moment of inertia of the cross-section about the x2 and x3 coordinate axis, PN= vector of natural forces; see natural_forces() for definitions L= current length of the element,
Outputs
SM = local geometric stiffness matrix, 12 x 12
This geometric stiffness matrix this consistent with relationship between the natural deformations and the natural forces that assumes there is only a linear constitutive link: no non-constitutive effects (bowing etc.) are included. This form of the geometric matrix was derived by Krenk. @BOOK{Krenk:2009,   AUTHOR =       {S. Krenk},   TITLE =        {Non-linear Modeling and Analysis of Solids and Structures },   PUBLISHER =    {Cambridge University Press},   YEAR =         {2009},   isbn =         {9780521830546} }
source
FinEtoolsFlexStructures.FEMMCorotBeamModule.local_mass! — Method
local_mass!(MM, A, I1, I2, I3, rho, L, mass_type)
Mass matrix of the beam.
Arguments
A= cross-sectional area, I1=central moment of inertia of the cross-section about the x1 axis, I2, I3=central moment of inertia of the cross-section about the x2 and x3 coordinate axis, rho=mass density, L= initial length of the element,
Outputs
MM = local mass matrix, 12 x 12 In the element frame the mass matrix is constant.
source
FinEtoolsFlexStructures.FEMMCorotBeamModule.local_stiffness! — Method
local_stiffness!(SM, E, G, A, I2, I3, J, A2s, A3s, L, aN, DN)
Compute the local elastic stiffness matrix.
Arguments
E, G= Young's and shear modulus, A= cross-sectional area, I2, I3=central moment of inertia of the cross-section about the x2 and x3 coordinate axis, J=St Venant torsion constant, L= current length of the element,
Outputs
SM = local stiffness matrix, 12 x 12
source
FinEtoolsFlexStructures.FEMMCorotBeamModule.mass — Method
mass(self::FEMMCorotBeam, assembler::ASS, geom0::NodalField{GFT}, u1::NodalField{T}, Rfield1::NodalField{T}, dchi::NodalField{TI}; mass_type=MASS_TYPE_CONSISTENT_WITH_ROTATION_INERTIA) where {ASS<:AbstractSysmatAssembler, GFT<:Number, T<:Number, TI<:Number}
Compute the consistent mass matrix
This is a general routine for the abstract linear-deformation  FEMM.
source
FinEtoolsFlexStructures.FEMMCorotBeamModule.natural_forces! — Method
natural_forces!(PN, E, G, A, I2, I3, J, A2s, A3s, L, dN, DN)
Compute the natural forces from the natural deformations.
Argument
E, G= Young's and shear modulus, A= cross-sectional area, I2, I3=central moment of inertia of the cross-section about the x2 and x3 coordinate axis, J=St Venant torsion constant, L= current length of the element, dN= column vector of natural deformations; see local_frames()
Outputs
PN = column vector of natural forces;      PN[1]= axial force;      PN[2]= symmetric bending moment in the plane x1-x2;      PN[3]= anti-symmetric bending bending moment in the plane x1-x2;      PN[4]= symmetric bending bending moment in the plane x1-x3;      PN[5]= anti-symmetric bending bending moment in the plane x1-x3;      PN[6]= axial torque.
source
FinEtoolsFlexStructures.FEMMCorotBeamModule.natural_stiffness_Bernoulli! — Method
natural_stiffness_Bernoulli!(DN, E, G, A, I2, I3, J, A2s, A3s, L)
Compute the natural stiffness matrix.
function DN = natural_stiffness(self, E, G, A, I2, I3, J, L)
Arguments
  • E, G= Young's and shear modulus,
  • A= cross-sectional area,
  • I2, I3= central moment of inertia of the cross-section about the x2 and x3 coordinate axis,
  • J= St Venant torsion constant,
  • A2s = effective area for shear in the direction of x2 (ignored)
  • A3s = effective area for shear in the direction of x3 (ignored)
  • L= current length of the element,
Outputs
  • DN = 6 x 6 natural stiffness matrix
source
FinEtoolsFlexStructures.FEMMCorotBeamModule.natural_stiffness_Timoshenko! — Method
natural_stiffness_Timoshenko!(DN, E, G, A, I2, I3, J, A2s, A3s, L)
Compute the natural stiffness matrix.
function DN = natural_stiffness(self, E, G, A, I2, I3, J, L)
Arguments
  • E, G= Young's and shear modulus,
  • A= cross-sectional area,
  • I2, I3= central moment of inertia of the cross-section about the x2 and x3 coordinate axis,
  • J= St Venant torsion constant,
  • A2s = effective area for shear in the direction of x2
  • A3s = effective area for shear in the direction of x3
  • L= current length of the element,
Outputs
  • DN = 6 x 6 natural stiffness matrix
source
FinEtoolsFlexStructures.FEMMCorotBeamModule.restoringforce — Method
restoringforce(self::FEMMCorotBeam, assembler::ASS, geom0::NodalField{GFT}, u1::NodalField{T}, Rfield1::NodalField{T}, dchi::NodalField{TI}) where {ASS<:AbstractSysvecAssembler, GFT<:Number, T<:Number, TI<:Number}
Compute the vector of the restoring elastic forces
source
FinEtoolsFlexStructures.FEMMCorotBeamModule.stiffness — Method
stiffness(self::FEMMCorotBeam, assembler::ASS, geom0::NodalField{GFT}, u1::NodalField{T}, Rfield1::NodalField{T}, dchi::NodalField{TI}) where {ASS<:AbstractSysmatAssembler, GFT<:Number, T<:Number, TI<:Number}
Compute the material stiffness matrix.
source
FEMM for linear beams with eccentric connections
FinEtools.FEMMBaseModule.inspectintegpoints — Method
inspectintegpoints(
     self::FEMM,
     geom::NodalField{FT},
     felist::AbstractVector{IT},
@@ -10,50 +10,50 @@
     idat,
     quantity = :Cauchy;
     context...,
-) where {FEMM<:AbstractFEMM, FT, IT, F<:Function}
Inspect integration points.
source
FinEtoolsFlexStructures.FEMMLinBeamModule.distribloads_global — Method
distribloads_global(self::FEMMLinBeam, geom0::NodalField{FFlt}, u1::NodalField{T}, Rfield1::NodalField{T}, dchi::NodalField{T}, fi) where {T<:Number}
Compute the load vector due to distributed loads.
Compute the global load vector corresponding to applied distributed load. Here it means force per unit length of the beam, in the configuration u1, Rfield1. These are only forces, not moments.
Note
The force intensity must be uniform across the entire element. The force intensity is given in the global coordinates.
source
FinEtoolsFlexStructures.FEMMLinBeamModule.local_cartesian_to_natural! — Method
local_cartesian_to_natural!(aN, L)
Compute transformation from local Cartesian displacements to natural deformations of a beam element.
Matrix defined in Eq (4.8) of COMPUTER  METHODS  IN APPLIED  MECHANICS  AND  ENGINEERING   14  (1978)  401-451 ON LARGE  DISPLACEMENT-SMALL   STRAIN  ANALYSIS   OF  STRUCTURES WITH  ROTATIONAL   DEGREES  OF  FREEDOM. J.H.  ARGYRIS,   P.C.  DUNNE  and  D.W. SCHARPF
Arguments
L= current length of the element
Outputs
aN= transformation matrix to take Cartesian (local) displacement increments in the      element frame and to produce increments of natural deformations;      see local_frame_and_def! for the definition of the natural deformations
source
FinEtoolsFlexStructures.FEMMLinBeamModule.local_forces! — Method
local_forces!(FL, PN, L, aN)
Compute forces through which the element acts on the nodes in the local coordinate system.
Arguments
PN = column vector of natural forces; L= current length of the element, aN= transformation matrix to take Cartesian (local) displacement increments in the      element frame and to produce increments of natural deformations;      see local_frame_and_def! for the definition of the natural deformations
Outputs
FL = vector of forces acting on the nodes in the local coordinate system
source
FinEtoolsFlexStructures.FEMMLinBeamModule.local_mass! — Method
local_mass!(MM, A, I1, I2, I3, rho, L, mass_type)
Mass matrix of the beam.
Arguments
A= cross-sectional area, I1=central moment of inertia of the cross-section about the x1 axis, I2, I3=central moment of inertia of the cross-section about the x2 and x3 coordinate axis, rho=mass density, L= initial length of the element,
Outputs
MM = local mass matrix, 12 x 12 In the element frame the mass matrix is constant.
source
FinEtoolsFlexStructures.FEMMLinBeamModule.local_stiffness! — Method
local_stiffness!(SM, E, G, A, I2, I3, J, A2s, A3s, L, aN, DN)
Compute the local elastic stiffness matrix.
Arguments
E, G= Young's and shear modulus, A= cross-sectional area, I2, I3=central moment of inertia of the cross-section about the x2 and x3 coordinate axis, J=St Venant torsion constant, L= current length of the element,
Outputs
SM = local stiffness matrix, 12 x 12
source
FinEtoolsFlexStructures.FEMMLinBeamModule.distribloads_global — Method
distribloads_global(self::FEMMLinBeam, geom0::NodalField{FFlt}, u1::NodalField{T}, Rfield1::NodalField{T}, dchi::NodalField{T}, fi) where {T<:Number}
Compute the load vector due to distributed loads.
Compute the global load vector corresponding to applied distributed load. Here it means force per unit length of the beam, in the configuration u1, Rfield1. These are only forces, not moments.
Note
The force intensity must be uniform across the entire element. The force intensity is given in the global coordinates.
source
FinEtoolsFlexStructures.FEMMLinBeamModule.local_cartesian_to_natural! — Method
local_cartesian_to_natural!(aN, L)
Compute transformation from local Cartesian displacements to natural deformations of a beam element.
Matrix defined in Eq (4.8) of COMPUTER  METHODS  IN APPLIED  MECHANICS  AND  ENGINEERING   14  (1978)  401-451 ON LARGE  DISPLACEMENT-SMALL   STRAIN  ANALYSIS   OF  STRUCTURES WITH  ROTATIONAL   DEGREES  OF  FREEDOM. J.H.  ARGYRIS,   P.C.  DUNNE  and  D.W. SCHARPF
Arguments
L= current length of the element
Outputs
aN= transformation matrix to take Cartesian (local) displacement increments in the      element frame and to produce increments of natural deformations;      see local_frame_and_def! for the definition of the natural deformations
source
FinEtoolsFlexStructures.FEMMLinBeamModule.local_forces! — Method
local_forces!(FL, PN, L, aN)
Compute forces through which the element acts on the nodes in the local coordinate system.
Arguments
PN = column vector of natural forces; L= current length of the element, aN= transformation matrix to take Cartesian (local) displacement increments in the      element frame and to produce increments of natural deformations;      see local_frame_and_def! for the definition of the natural deformations
Outputs
FL = vector of forces acting on the nodes in the local coordinate system
source
FinEtoolsFlexStructures.FEMMLinBeamModule.local_mass! — Method
local_mass!(MM, A, I1, I2, I3, rho, L, mass_type)
Mass matrix of the beam.
Arguments
A= cross-sectional area, I1=central moment of inertia of the cross-section about the x1 axis, I2, I3=central moment of inertia of the cross-section about the x2 and x3 coordinate axis, rho=mass density, L= initial length of the element,
Outputs
MM = local mass matrix, 12 x 12 In the element frame the mass matrix is constant.
source
FinEtoolsFlexStructures.FEMMLinBeamModule.local_stiffness! — Method
local_stiffness!(SM, E, G, A, I2, I3, J, A2s, A3s, L, aN, DN)
Compute the local elastic stiffness matrix.
Arguments
E, G= Young's and shear modulus, A= cross-sectional area, I2, I3=central moment of inertia of the cross-section about the x2 and x3 coordinate axis, J=St Venant torsion constant, L= current length of the element,
Outputs
SM = local stiffness matrix, 12 x 12
source
FinEtoolsFlexStructures.FEMMLinBeamModule.mass — Method
mass(self::FEMMLinBeam,  assembler::A,
   geom::NodalField{FFlt},
-  u::NodalField{T}) where {A<:AbstractSysmatAssembler, T<:Number}
Compute the consistent mass matrix
This is a general routine for the abstract linear-deformation  FEMM.
source
FinEtoolsFlexStructures.FEMMLinBeamModule.natural_forces! — Method
natural_forces!(PN, E, G, A, I2, I3, J, A2s, A3s, L, dN, DN)
Compute the natural forces from the natural deformations.
Argument
E, G= Young's and shear modulus, A= cross-sectional area, I2, I3=central moment of inertia of the cross-section about the x2 and x3 coordinate axis, J=St Venant torsion constant, L= current length of the element, dN= column vector of natural deformations; see local_frames()
Outputs
PN = column vector of natural forces;      PN[1]= axial force;      PN[2]= symmetric bending moment in the plane x1-x2;      PN[3]= anti-symmetric bending bending moment in the plane x1-x2;      PN[4]= symmetric bending bending moment in the plane x1-x3;      PN[5]= anti-symmetric bending bending moment in the plane x1-x3;      PN[6]= axial torque.
source
FinEtoolsFlexStructures.FEMMLinBeamModule.natural_stiffness_Bernoulli! — Method
natural_stiffness_Bernoulli!(DN, E, G, A, I2, I3, J, A2s, A3s, L)
Compute the natural stiffness matrix.
function DN = natural_stiffness(self, E, G, A, I2, I3, J, L)
Arguments
  • E, G= Young's and shear modulus,
  • A= cross-sectional area,
  • I2, I3= central moment of inertia of the cross-section about the x2 and x3 coordinate axis,
  • J= St Venant torsion constant,
  • A2s = effective area for shear in the direction of x2 (ignored)
  • A3s = effective area for shear in the direction of x3 (ignored)
  • L= current length of the element,
Outputs
  • DN = 6 x 6 natural stiffness matrix
source
FinEtoolsFlexStructures.FEMMLinBeamModule.natural_stiffness_Timoshenko! — Method
natural_stiffness_Timoshenko!(DN, E, G, A, I2, I3, J, A2s, A3s, L)
Compute the natural stiffness matrix.
function DN = natural_stiffness(self, E, G, A, I2, I3, J, L)
Arguments
  • E, G= Young's and shear modulus,
  • A= cross-sectional area,
  • I2, I3= central moment of inertia of the cross-section about the x2 and x3 coordinate axis,
  • J= St Venant torsion constant,
  • A2s = effective area for shear in the direction of x2
  • A3s = effective area for shear in the direction of x3
  • L= current length of the element,
Outputs
  • DN = 6 x 6 natural stiffness matrix
source
FinEtoolsFlexStructures.FEMMLinBeamModule.stiffness — Method
stiffness(self::FEMMLinBeam, assembler::ASS, geom0::NodalField{FFlt}, u1::NodalField{T}, Rfield1::NodalField{T}, dchi::NodalField{T}) where {ASS<:AbstractSysmatAssembler, T<:Number}
Compute the material stiffness matrix.
source
FinEtoolsFlexStructures.FEMMLinBeamModule.FEMMLinBeam — Type
mutable struct FEMMLinBeam{ID<:IntegDomain{S} where {S<:FESetL2}, M<:MatDeforElastIso} <: AbstractFEMM
Type for linear beam finite element modeling machine.
The beam can be connected to the nodes with given eccentricities (the transverse eccentricity is uniform along its length). Only linear kinematics is implemented at the moment. The beam stiffness can be either shear-flexible (Timoshenko), or shear-rigid (Bernoulli-Euler). The local beam stiffness is expressed analytically: no numerical integration is involved.
source
FinEtoolsFlexStructures.FEMMLinBeamModule.natural_forces! — Method
natural_forces!(PN, E, G, A, I2, I3, J, A2s, A3s, L, dN, DN)
Compute the natural forces from the natural deformations.
Argument
E, G= Young's and shear modulus, A= cross-sectional area, I2, I3=central moment of inertia of the cross-section about the x2 and x3 coordinate axis, J=St Venant torsion constant, L= current length of the element, dN= column vector of natural deformations; see local_frames()
Outputs
PN = column vector of natural forces;      PN[1]= axial force;      PN[2]= symmetric bending moment in the plane x1-x2;      PN[3]= anti-symmetric bending bending moment in the plane x1-x2;      PN[4]= symmetric bending bending moment in the plane x1-x3;      PN[5]= anti-symmetric bending bending moment in the plane x1-x3;      PN[6]= axial torque.
source
FinEtoolsFlexStructures.FEMMLinBeamModule.natural_stiffness_Bernoulli! — Method
natural_stiffness_Bernoulli!(DN, E, G, A, I2, I3, J, A2s, A3s, L)
Compute the natural stiffness matrix.
function DN = natural_stiffness(self, E, G, A, I2, I3, J, L)
Arguments
  • E, G= Young's and shear modulus,
  • A= cross-sectional area,
  • I2, I3= central moment of inertia of the cross-section about the x2 and x3 coordinate axis,
  • J= St Venant torsion constant,
  • A2s = effective area for shear in the direction of x2 (ignored)
  • A3s = effective area for shear in the direction of x3 (ignored)
  • L= current length of the element,
Outputs
  • DN = 6 x 6 natural stiffness matrix
source
FinEtoolsFlexStructures.FEMMLinBeamModule.natural_stiffness_Timoshenko! — Method
natural_stiffness_Timoshenko!(DN, E, G, A, I2, I3, J, A2s, A3s, L)
Compute the natural stiffness matrix.
function DN = natural_stiffness(self, E, G, A, I2, I3, J, L)
Arguments
  • E, G= Young's and shear modulus,
  • A= cross-sectional area,
  • I2, I3= central moment of inertia of the cross-section about the x2 and x3 coordinate axis,
  • J= St Venant torsion constant,
  • A2s = effective area for shear in the direction of x2
  • A3s = effective area for shear in the direction of x3
  • L= current length of the element,
Outputs
  • DN = 6 x 6 natural stiffness matrix
source
FinEtoolsFlexStructures.FEMMLinBeamModule.stiffness — Method
stiffness(self::FEMMLinBeam, assembler::ASS, geom0::NodalField{FFlt}, u1::NodalField{T}, Rfield1::NodalField{T}, dchi::NodalField{T}) where {ASS<:AbstractSysmatAssembler, T<:Number}
Compute the material stiffness matrix.
source
FinEtoolsFlexStructures.FEMMLinBeamModule.FEMMLinBeam — Type
mutable struct FEMMLinBeam{ID<:IntegDomain{S} where {S<:FESetL2}, M<:MatDeforElastIso} <: AbstractFEMM
Type for linear beam finite element modeling machine.
The beam can be connected to the nodes with given eccentricities (the transverse eccentricity is uniform along its length). Only linear kinematics is implemented at the moment. The beam stiffness can be either shear-flexible (Timoshenko), or shear-rigid (Bernoulli-Euler). The local beam stiffness is expressed analytically: no numerical integration is involved.
source
FinEtoolsFlexStructures.FEMMLinBeamModule.FEMMLinBeam — Method
FEMMLinBeam(
     integdomain::ID,
     material::M,
     uniform_eccentricity,
-) where {ID<:IntegDomain{S} where {S<:FESetL2}, M<:MatDeforElastIso}
Constructor.
Supply the integration domain, material, and the eccentricity parameters (given in the order: first node, f1 direction, second node, f1 direction, f2 direction, f3 direction).
source
FinEtoolsFlexStructures.FEMMLinBeamModule.FEMMLinBeam — Method
FEMMLinBeam(
+) where {ID<:IntegDomain{S} where {S<:FESetL2}, M<:MatDeforElastIso}
Constructor.
Supply the integration domain, material, and the eccentricity parameters (given in the order: first node, f1 direction, second node, f1 direction, f2 direction, f3 direction).
source
FEMM for reduced-integration Timoshenko beams
FinEtoolsFlexStructures.FEMMRITBeamModule.distribloads_global — Method
distribloads_global(self::FEMMRITBeam, geom0::NodalField{FFlt}, u1::NodalField{T}, Rfield1::NodalField{T}, dchi::NodalField{T}, fi) where {T<:Number}
Compute the load vector due to distributed loads.
Compute the global load vector corresponding to applied distributed load. Here it means force per unit length of the beam, in the configuration u1, Rfield1. These are only forces, not moments.
Note
The force intensity must be uniform across the entire element. The force intensity is given in the global coordinates.
source
FinEtoolsFlexStructures.FEMMRITBeamModule.stiffness — Method
stiffness(self::FEMMRITBeam, assembler::ASS, geom0::NodalField{FFlt}, u1::NodalField{T}, Rfield1::NodalField{T}, dchi::NodalField{T}) where {ASS<:AbstractSysmatAssembler, T<:Number}
Compute the material stiffness matrix.
source
FinEtoolsFlexStructures.FEMMRITBeamModule.FEMMRITBeam — Type
mutable struct FEMMRITBeam{ID<:IntegDomain{S} where {S<:FESetL2}, M<:MatDeforElastIso} <: AbstractFEMM
Type for linear reduced-integration beam finite element modeling machine.
Only linear kinematics is implemented at the moment, and only linear basis functions are available (i.e. it is a two-node element). The beam stiffness is shear-flexible (Timoshenko). The local beam stiffness is expressed analytically: the one-point numerical integration is hardwired.
source
FEMM for reduced-integration Timoshenko beams
FinEtoolsFlexStructures.FEMMRITBeamModule.distribloads_global — Method
distribloads_global(self::FEMMRITBeam, geom0::NodalField{FFlt}, u1::NodalField{T}, Rfield1::NodalField{T}, dchi::NodalField{T}, fi) where {T<:Number}
Compute the load vector due to distributed loads.
Compute the global load vector corresponding to applied distributed load. Here it means force per unit length of the beam, in the configuration u1, Rfield1. These are only forces, not moments.
Note
The force intensity must be uniform across the entire element. The force intensity is given in the global coordinates.
source
FinEtoolsFlexStructures.FEMMRITBeamModule.stiffness — Method
stiffness(self::FEMMRITBeam, assembler::ASS, geom0::NodalField{FFlt}, u1::NodalField{T}, Rfield1::NodalField{T}, dchi::NodalField{T}) where {ASS<:AbstractSysmatAssembler, T<:Number}
Compute the material stiffness matrix.
source
FinEtoolsFlexStructures.FEMMRITBeamModule.FEMMRITBeam — Type
mutable struct FEMMRITBeam{ID<:IntegDomain{S} where {S<:FESetL2}, M<:MatDeforElastIso} <: AbstractFEMM
Type for linear reduced-integration beam finite element modeling machine.
Only linear kinematics is implemented at the moment, and only linear basis functions are available (i.e. it is a two-node element). The beam stiffness is shear-flexible (Timoshenko). The local beam stiffness is expressed analytically: the one-point numerical integration is hardwired.
source
FEMM for Shell T3FF with homogeneous composition
FEMM for Shell T3FF with homogeneous composition
FinEtools.FEMMBaseModule.inspectintegpoints — Method
inspectintegpoints(self::AbstractFEMMDeforLinear,
   geom::NodalField{FFlt},  u::NodalField{TI},
   dT::NodalField{FFlt},
   felist::FIntVec,
   inspector::F,  idat, quantity=:Cauchy;
-  context...) where {TI<:Number, F<:Function}
Inspect integration point quantities.
  • geom - reference geometry field
  • u - displacement+rotation field
  • dT - temperature difference field
  • felist - indexes of the finite elements that are to be inspected:    The fes to be included are: fes[felist].
  • context    - structure: see the update!() method of the material.
  • inspector - function with the signature       idat = inspector(idat, j, conn, x, out, loc);  where   idat - a structure or an array that the inspector may          use to maintain some state,  for instance minimum or maximum of          stress, j is the element number, conn is the element connectivity,          out is the output of the update!() method,  loc is the location          of the integration point in the reference configuration.
Return
The updated inspector data is returned.
source
FinEtoolsFlexStructures.FEMMShellT3FFModule.mass — Method
mass(self::FEMMShellT3FF,  assembler::A,  geom::NodalField{FFlt}, dchi::NodalField{TI}) where {A<:AbstractSysmatAssembler, TI<:Number}
Compute the diagonal (lumped) mass matrix
The mass matrix can be expected to be non-singular.
source
FinEtoolsFlexStructures.FEMMShellT3FFModule.stiffness — Method
stiffness(self::FEMMShellT3FF, assembler::ASS, geom0::NodalField{FFlt}, u1::NodalField{TI}, Rfield1::NodalField{TI}, dchi::NodalField{TI}) where {ASS<:AbstractSysmatAssembler, TI<:Number}
Compute the material stiffness matrix.
source
FinEtoolsFlexStructures.FEMMShellT3FFModule.FEMMShellT3FF — Type
mutable struct FEMMShellT3FF{ID<:IntegDomain{S} where {S<:FESetT3}, CS<:CSys, M} <: AbstractFEMM
Type for the finite element modeling machine of the T3 triangular Flat-Facet shell with the Discrete Shear Gap technology and a consistent handling of the normals. 
With averaging of the transverse strain-displacement matrix or averaging of the transverse shear stiffness matrix to provide isotropic transverse shear response. 
Also, the formulation is developed to correctly handle the coupling of twisting moments and transverse shear (such as in the twisted beam or the Raasch hook problems) by incorporating "nodal" normals.
Some of the programming developed consistently with the paper
[1] Cui et al, Analysis of plates and shells using an edge-based smoothed finite element method, Comput Mech (2010) 45:141–156 DOI 10.1007/s00466-009-0429-9
The stabilization factor of the shear term of
[2] Mikko Lyly, Rolf Stenberg and Teemu Vihinen, A stable bilinear element for the Reissner-Mindlin plate model Computer Methods in Applied Mechanics and Engineering 110 (1993) 343-357 
is incorporated. Refer to expressions (3.12) and (3.13).
The treatment of the transformation between the element and nodal coordinates is carried out using a clean alternative to the publication
[3] Finite Elements in Analysis and Design 30 (1998) 235—242 The treatment of shell normals in finite element analysis Richard H. MacNeal, Charles T. Wilson, Robert L. Harder, Claus C. Hoff The MacNeal-Schwendler Corporation, 815 Colorado Blvd., Los Angeles, CA 90041, USA
The formula for the element to nodal basis transformation is derived from the expression
[theta]_n = [A]_E^T [theta]_e + [A_3,1:3]_E^T [alpha_3]_e
by disconnecting the drilling degree of freedom from the bending degrees of freedom in the nodal basis.
The following features are incorporated to deal with nodal normals:
  • Nodal normals are averages of the normals of elements that meet at a node.
  • A crease in the surface is taken into account. In that case the normal are not averaged across the crease. At the nodes along the crease every element uses the normal to its surface instead of the nodal normal.
Configuration:
These attributes of the FEMM can be set after it's been created.
  • transv_shear_formulation: which formulation for the transverse shear stiffness? 
    • FEMMShellT3FFModule.__TRANSV_SHEAR_FORMULATION_AVERAGE_B - averaged strains (default)
    • FEMMShellT3FFModule.__TRANSV_SHEAR_FORMULATION_AVERAGE_K - averaged stiffness
  • drilling_stiffness_scale: multiplier of the generalized stiffness coefficient
  • threshold_angle: angle in degrees. If a nodal normal subtends angle bigger then this threshold, the nodal normal at that note is marked as invalid.
  • mult_el_size: multiplier of the square of the element size, used to control transverse shear stiffness.
source
FinEtoolsFlexStructures.FEMMShellT3FFModule.FEMMShellT3FF — Method
FEMMShellT3FF(
+  context...) where {TI<:Number, F<:Function}
Inspect integration point quantities.
  • geom - reference geometry field
  • u - displacement+rotation field
  • dT - temperature difference field
  • felist - indexes of the finite elements that are to be inspected:    The fes to be included are: fes[felist].
  • context    - structure: see the update!() method of the material.
  • inspector - function with the signature       idat = inspector(idat, j, conn, x, out, loc);  where   idat - a structure or an array that the inspector may          use to maintain some state,  for instance minimum or maximum of          stress, j is the element number, conn is the element connectivity,          out is the output of the update!() method,  loc is the location          of the integration point in the reference configuration.
Return
The updated inspector data is returned.
source
FinEtoolsFlexStructures.FEMMShellT3FFModule.mass — Method
mass(self::FEMMShellT3FF,  assembler::A,  geom::NodalField{FFlt}, dchi::NodalField{TI}) where {A<:AbstractSysmatAssembler, TI<:Number}
Compute the diagonal (lumped) mass matrix
The mass matrix can be expected to be non-singular.
source
FinEtoolsFlexStructures.FEMMShellT3FFModule.stiffness — Method
stiffness(self::FEMMShellT3FF, assembler::ASS, geom0::NodalField{FFlt}, u1::NodalField{TI}, Rfield1::NodalField{TI}, dchi::NodalField{TI}) where {ASS<:AbstractSysmatAssembler, TI<:Number}
Compute the material stiffness matrix.
source
FinEtoolsFlexStructures.FEMMShellT3FFModule.FEMMShellT3FF — Type
mutable struct FEMMShellT3FF{ID<:IntegDomain{S} where {S<:FESetT3}, CS<:CSys, M} <: AbstractFEMM
Type for the finite element modeling machine of the T3 triangular Flat-Facet shell with the Discrete Shear Gap technology and a consistent handling of the normals. 
With averaging of the transverse strain-displacement matrix or averaging of the transverse shear stiffness matrix to provide isotropic transverse shear response. 
Also, the formulation is developed to correctly handle the coupling of twisting moments and transverse shear (such as in the twisted beam or the Raasch hook problems) by incorporating "nodal" normals.
Some of the programming developed consistently with the paper
[1] Cui et al, Analysis of plates and shells using an edge-based smoothed finite element method, Comput Mech (2010) 45:141–156 DOI 10.1007/s00466-009-0429-9
The stabilization factor of the shear term of
[2] Mikko Lyly, Rolf Stenberg and Teemu Vihinen, A stable bilinear element for the Reissner-Mindlin plate model Computer Methods in Applied Mechanics and Engineering 110 (1993) 343-357 
is incorporated. Refer to expressions (3.12) and (3.13).
The treatment of the transformation between the element and nodal coordinates is carried out using a clean alternative to the publication
[3] Finite Elements in Analysis and Design 30 (1998) 235—242 The treatment of shell normals in finite element analysis Richard H. MacNeal, Charles T. Wilson, Robert L. Harder, Claus C. Hoff The MacNeal-Schwendler Corporation, 815 Colorado Blvd., Los Angeles, CA 90041, USA
The formula for the element to nodal basis transformation is derived from the expression
[theta]_n = [A]_E^T [theta]_e + [A_3,1:3]_E^T [alpha_3]_e
by disconnecting the drilling degree of freedom from the bending degrees of freedom in the nodal basis.
The following features are incorporated to deal with nodal normals:
  • Nodal normals are averages of the normals of elements that meet at a node.
  • A crease in the surface is taken into account. In that case the normal are not averaged across the crease. At the nodes along the crease every element uses the normal to its surface instead of the nodal normal.
Configuration:
These attributes of the FEMM can be set after it's been created.
  • transv_shear_formulation: which formulation for the transverse shear stiffness? 
    • FEMMShellT3FFModule.__TRANSV_SHEAR_FORMULATION_AVERAGE_B - averaged strains (default)
    • FEMMShellT3FFModule.__TRANSV_SHEAR_FORMULATION_AVERAGE_K - averaged stiffness
  • drilling_stiffness_scale: multiplier of the generalized stiffness coefficient
  • threshold_angle: angle in degrees. If a nodal normal subtends angle bigger then this threshold, the nodal normal at that note is marked as invalid.
  • mult_el_size: multiplier of the square of the element size, used to control transverse shear stiffness.
source
FEMM for Shell T3FF with layered composition
FEMM for Shell T3FF with layered composition
FinEtools.FEMMBaseModule.inspectintegpoints — Method
inspectintegpoints(self::AbstractFEMMDeforLinear,
   geom::NodalField{FFlt},  u::NodalField{TI},
   dT::NodalField{FFlt},
   felist::FIntVec,
   inspector::F,  idat, quantity=:Cauchy;
-  context...) where {TI<:Number, F<:Function}
Inspect integration point quantities.
  • geom - reference geometry field
  • u - displacement+rotation field
  • dT - temperature difference field
  • felist - indexes of the finite elements that are to be inspected:    The fes to be included are: fes[felist].
  • context    - structure: see the update!() method of the material.
  • inspector - function with the signature       idat = inspector(idat, j, conn, x, out, loc);  where   idat - a structure or an array that the inspector may          use to maintain some state,  for instance minimum or maximum of          stress, j is the element number, conn is the element connectivity,          out is the output of the update!() method,  loc is the location          of the integration point in the reference configuration.
Return
The updated inspector data is returned.
source
FinEtoolsFlexStructures.FEMMShellT3FFCompModule.mass — Method
mass(self::FEMMShellT3FFComp,  assembler::A,  geom::NodalField{FFlt}, dchi::NodalField{TI}) where {A<:AbstractSysmatAssembler, TI<:Number}
Compute the diagonal (lumped) mass matrix
The mass matrix can be expected to be non-singular.
source
FinEtoolsFlexStructures.FEMMShellT3FFCompModule.FEMMShellT3FFComp — Type
mutable struct FEMMShellT3FFComp{ID<:IntegDomain{S} where {S<:FESetT3}} <: AbstractFEMM
Type for the finite element modeling machine of the T3 triangular Flat-Facet shell with the Discrete Shear Gap technology and a consistent handling of the normals. This formulation is suitable for modelling of COMPOSITE (layered) materials. 
For details about the homogeneous-shell refer to FinEtoolsFlexStructures.FEMMShellT3FFModule.FEMMShellT3FF.
source
FinEtoolsFlexStructures.FEMMShellT3FFCompModule.FEMMShellT3FFComp — Method
FEMMShellT3FFComp(
+  context...) where {TI<:Number, F<:Function}
Inspect integration point quantities.
  • geom - reference geometry field
  • u - displacement+rotation field
  • dT - temperature difference field
  • felist - indexes of the finite elements that are to be inspected:    The fes to be included are: fes[felist].
  • context    - structure: see the update!() method of the material.
  • inspector - function with the signature       idat = inspector(idat, j, conn, x, out, loc);  where   idat - a structure or an array that the inspector may          use to maintain some state,  for instance minimum or maximum of          stress, j is the element number, conn is the element connectivity,          out is the output of the update!() method,  loc is the location          of the integration point in the reference configuration.
Return
The updated inspector data is returned.
source
FinEtoolsFlexStructures.FEMMShellT3FFCompModule.mass — Method
mass(self::FEMMShellT3FFComp,  assembler::A,  geom::NodalField{FFlt}, dchi::NodalField{TI}) where {A<:AbstractSysmatAssembler, TI<:Number}
Compute the diagonal (lumped) mass matrix
The mass matrix can be expected to be non-singular.
source
FinEtoolsFlexStructures.FEMMShellT3FFCompModule.FEMMShellT3FFComp — Type
mutable struct FEMMShellT3FFComp{ID<:IntegDomain{S} where {S<:FESetT3}} <: AbstractFEMM
Type for the finite element modeling machine of the T3 triangular Flat-Facet shell with the Discrete Shear Gap technology and a consistent handling of the normals. This formulation is suitable for modelling of COMPOSITE (layered) materials. 
For details about the homogeneous-shell refer to FinEtoolsFlexStructures.FEMMShellT3FFModule.FEMMShellT3FF.
source
FEMM for point masses
FEMM for point masses
FinEtoolsFlexStructures.FEMMPointMassModule.mass — Method
mass(
     self::FEMMPointMass,
     assembler::ASS,
     geom0::NodalField{FFlt},
     u1::NodalField{T},
     Rfield1::NodalField{T},
     dchi::NodalField{TI},
-) where {ASS<:AbstractSysmatAssembler,T<:Number,TI<:Number}
Compute the consistent mass matrix
This is a general routine for the abstract linear-deformation  FEMM.
source
FEMM for Grounded springs
FEMM for Grounded springs
Rotation utilities
Transformer functions
FinEtoolsFlexStructures.TransformerModule.TransformerQtEQ — Type
TransformerQtEQ
TransformerQtEQ of element matrices.
A callable object: computes Q^T * E * Q, where E the element stiffness matrix, and Q is the transformation matrix. Both are assumed to be square.
Buffers the intermediate result. Hence no allocation is incurred.
source
Assembly of special matrices
Modules
FinEtoolsFlexStructures.FinEtoolsFlexStructures — Module
FinEtoolsFlexStructures (C) 2020-2024, Petr Krysl
FinEtools used for
  • Simulations of large-displacement response of three-dimensional flexible-beam
structures. Linear static analysis, modal analysis, linear buckling analysis. Nonlinear statics and dynamics; 
  • Simulations of shell structures. Linear static analysis, modal analysis,
explicit dynamic analysis. Shells can be homogeneous or layered (laminated, composite).
source
FinEtoolsFlexStructures.FEMMShellT3FFModule — Module
Module for operations on interiors of domains to construct system matrices and system vectors for linear homogenous shells using the robust flat-facet three-node triangular finite element (T3FF).
source
FinEtoolsFlexStructures.FEMMShellT3FFCompModule — Module
Module for operations on interiors of domains to construct system matrices and system vectors for linear layered (composite) shells using the robust flat-facet three-node triangular finite element (T3FF).
source

+) where {ASS<:AbstractSysmatAssembler,T<:Number,TI<:Number}

Compute the stiffness matrix

source

Rotation utilities

Transformer functions

FinEtoolsFlexStructures.TransformerModule.TransformerQtEQ — Type
TransformerQtEQ

TransformerQtEQ of element matrices.

A callable object: computes Q^T * E * Q, where E the element stiffness matrix, and Q is the transformation matrix. Both are assumed to be square.

Buffers the intermediate result. Hence no allocation is incurred.

source

Assembly of special matrices

Modules

FinEtoolsFlexStructures.FinEtoolsFlexStructures — Module

FinEtoolsFlexStructures (C) 2020-2024, Petr Krysl

FinEtools used for

  • Simulations of large-displacement response of three-dimensional flexible-beam

structures. Linear static analysis, modal analysis, linear buckling analysis. Nonlinear statics and dynamics;

  • Simulations of shell structures. Linear static analysis, modal analysis,

explicit dynamic analysis. Shells can be homogeneous or layered (laminated, composite).

source
FinEtoolsFlexStructures.FEMMShellT3FFModule — Module

Module for operations on interiors of domains to construct system matrices and system vectors for linear homogenous shells using the robust flat-facet three-node triangular finite element (T3FF).

source
FinEtoolsFlexStructures.FEMMShellT3FFCompModule — Module

Module for operations on interiors of domains to construct system matrices and system vectors for linear layered (composite) shells using the robust flat-facet three-node triangular finite element (T3FF).

source