# Manual

## Composite Layup

FinEtoolsFlexStructures.CompositeLayupModule.cartesian_csysMethod
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.
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.

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).

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).

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).

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

FinEtoolsFlexStructures.CompositeLayupModule.CompositeLayupMethod
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.

FinEtoolsFlexStructures.CompositeLayupModule.PlyMethod
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.

## FE Set for two-node Beams

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

Concatenate two sets of beam elements.

FinEtoolsFlexStructures.FESetL2BeamModule.FESetL2BeamType
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.

FinEtoolsFlexStructures.FESetL2BeamModule.FESetL2BeamMethod
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.

## FEMM for Corotational Beams

FinEtoolsFlexStructures.FEMMCorotBeamModule.distribloads_globalMethod
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 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.

FinEtoolsFlexStructures.FEMMCorotBeamModule.geostiffnessMethod
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.

FinEtoolsFlexStructures.FEMMCorotBeamModule.gyroscopicMethod
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.

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

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

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.

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} }

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.

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

FinEtoolsFlexStructures.FEMMCorotBeamModule.massMethod
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.

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.

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
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
FinEtoolsFlexStructures.FEMMCorotBeamModule.restoringforceMethod
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

FinEtoolsFlexStructures.FEMMCorotBeamModule.stiffnessMethod
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.

## FEMM for linear beams with eccentric connections

FinEtools.FEMMBaseModule.inspectintegpointsMethod
inspectintegpoints(
self::FEMM,
geom::NodalField{FT},
felist::AbstractVector{IT},
inspector::F,
idat,
quantity = :Cauchy;
context...,
) where {FEMM<:AbstractFEMM, FT, IT, F<:Function}

Inspect integration points.

FinEtoolsFlexStructures.FEMMLinBeamModule.distribloads_globalMethod
distribloads_global(self::FEMMLinBeam, geom0::NodalField{FFlt}, u1::NodalField{T}, Rfield1::NodalField{T}, dchi::NodalField{T}, fi) where {T<:Number}

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.

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

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

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.

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

FinEtoolsFlexStructures.FEMMLinBeamModule.massMethod
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.

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.

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
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
FinEtoolsFlexStructures.FEMMLinBeamModule.FEMMLinBeamType
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.

FinEtoolsFlexStructures.FEMMLinBeamModule.FEMMLinBeamMethod
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).

## FEMM for reduced-integration Timoshenko beams

FinEtoolsFlexStructures.FEMMRITBeamModule.distribloads_globalMethod
distribloads_global(self::FEMMRITBeam, geom0::NodalField{FFlt}, u1::NodalField{T}, Rfield1::NodalField{T}, dchi::NodalField{T}, fi) where {T<:Number}

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.

FinEtoolsFlexStructures.FEMMRITBeamModule.FEMMRITBeamType
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.

## FEMM for Shell T3FF with homogeneous composition

FinEtools.FEMMBaseModule.inspectintegpointsMethod
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.

FinEtoolsFlexStructures.FEMMShellT3FFModule.massMethod
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.

FinEtoolsFlexStructures.FEMMShellT3FFModule.FEMMShellT3FFType
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 ﬁnite element analysis Richard H. MacNeal, Charles T. Wilson, Robert L. Harder, Claus C. Hoﬀ 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.

## FEMM for Shell T3FF with layered composition

FinEtools.FEMMBaseModule.inspectintegpointsMethod
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.

FinEtoolsFlexStructures.FEMMShellT3FFCompModule.massMethod
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.

FinEtoolsFlexStructures.FEMMShellT3FFCompModule.FEMMShellT3FFCompType
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.

## FEMM for point masses

FinEtoolsFlexStructures.FEMMPointMassModule.massMethod
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.

## Transformer functions

FinEtoolsFlexStructures.TransformerModule.TransformerQtEQType
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.

## Modules

FinEtoolsFlexStructures.FinEtoolsFlexStructuresModule

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).