Manual

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.

lamina_material(E1, E2, nu12, G12, G13, G23)

Create a transversely isotropic lamina material with default (zero) mass density.

lamina_material(rho, E1, E2, nu12, G12, G13, G23)

Create a transversely isotropic lamina material.

lamina_material(rho, E, nu)

Create an isotropic lamina material.

lamina_material(E, nu)

Create an isotropic lamina material with default (zero) mass density.

laminate_inertia!(cl::CompositeLayup)

Compute the laminate inertia.

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.

laminate_transverse_stiffness!(cl::CompositeLayup, H)

Compute the laminate transverse stiffness.

Hij represent intralaminar shear stiffness.

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

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

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

thickness(cl::CompositeLayup)

Compute the thickness of the layup (some of the thicknesses of the plies).

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

CompositeLayup

Type for composite layup.

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.

Ply{M} <: AbstractPly

Type of a ply.

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.

CrossSectionCircle(radius, x1x2_vector, shear_resisting_area_factor = 6/7; label = 0)

Create a circular section for use with a Timoshenko model.

Commonly accepted value is shear_resisting_area_factor = 6/7.

CrossSectionCircle(radius, x1x2_vector; label = 0)

Create a circular section for use with a Bernoulli model.

CrossSectionRectangle(d2f, d3f, x1x2_vector; label = 0)

Create a rectangular section for use with a Timoshenko model.

Commonly accepted value is shear_resisting_area_factor = 5/6.

CrossSectionRectangle(d2f, d3f, x1x2_vector; label = 0)

Create a rectangular section for use with a Bernoulli model.

frame_member(xyz, nL, crosssection; label = 0)

Mesh of a generally curved beam member given by the location of the vertices of the spline curve.

nL = number of elements

fuse_members(members; tolerance = 0.001)

Fuse members by merging the meshes for the members.

Computes an array of meshes.

merge_members(members; tolerance = 0.001)

Merge together meshes of the members.

Uses fuse_members to merge the nodes, then concatenates the finite elements.

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

Concatenate two sets of beam elements.

subset(self::T, L::IT) where {T<:FESetL2Beam, IT}

Subset of a beam-element set.

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.

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.

struct FESetShellT3 <: AbstractFESet2Manifold{3}

Type of a finite element set for the three-node shell.

current_local_frame!(Ft, xt, FtI, FtJ)

Compute the current local frame from the positions of the nodes and the orientation matrices (frames) at the nodes.

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.

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.

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.

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

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

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.

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

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.

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

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.

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.

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

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

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

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.

mutable struct FEMMCorotBeam{ID<:IntegDomain{S} where {S<:FESetL2}, M<:MatDeforElastIso} <: AbstractFEMM

Type for co-rotational beam finite element modeling machine (FEMM).

FEMMCorotBeam(integdomain::IntegDomain{S, F}, material::MatDeforElastIso) where {S<:FESetL2, F<:Function}

Constructor.

Supply the integration domain and the material.

Type of the mass matrix formulation.

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.

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.

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

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

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.

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

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.

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.

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

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

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.

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.

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

FEMMLinBeam(
    integdomain::ID,
    material::M,
) where {ID<:IntegDomain{S} where {S<:FESetL2}, M<:MatDeforElastIso}

Constructor.

Supply the integration domain and the material. The eccentricities are assumed to be zero.

Type of the mass matrix formulation.

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.

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.

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.

FEMMRITBeam(
    integdomain::ID,
    material::M,
) where {ID<:IntegDomain{S} where {S<:FESetL2}, M<:MatDeforElastIso}

Constructor.

Supply integration domain (mesh) and the material.

associategeometry!(self::FEMMShellT3FF,  geom::NodalField{FFlt})

Associate geometry with the FEMM.

In this case it means evaluate the nodal normals.

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.

make(integdomain, mcsys, material)

Make a T3FF FEMM from the integration domain, a coordinate system to define the orientation of the normals, and a material.

make(integdomain, mcsys, material)

Make a T3FF FEMM from the integration domain, and a material. Default isoparametric method for computing the normals is used.

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.

num_normals(self::FEMMShellT3FF)

Compute the summary of the nodal normals.

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.

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.

FEMMShellT3FF(
    integdomain::ID,
    mcsys::CSys,
    material::M,
) where {IntegDomain{S} where {S<:FESetT3}, CS<:CSys, M}

Constructor of the T3FF shell FEMM.

FEMMShellT3FF(
    integdomain::ID,
    material::M,
) where {ID<:IntegDomain{S} where {S<:FESetT3}, M}

Constructor of the T3FF shell FEMM.

associategeometry!(self::FEMMShellT3FFComp,  geom::NodalField{FFlt})

Associate geometry with the FEMM.

In this case it means evaluate the nodal normals.

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.

make(integdomain, layup)

Make a T3FFComp FEMM from the integration domain and a composite layup.

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.

num_normals(self::FEMMShellT3FFComp)

Compute the summary of the nodal normals.

stiffness(self::FEMMShellT3FFComp, assembler::ASS, geom0::NodalField{FFlt}, u1::NodalField{TI}, Rfield1::NodalField{TI}, dchi::NodalField{TI}) where {ASS<:AbstractSysmatAssembler, TI<:Number}

Compute the material stiffness matrix.

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.

FEMMShellT3FFComp(
    integdomain::ID,
    layup::CompositeLayup,
)  where {ID<:IntegDomain{S} where {S<:FESetT3}}

Constructor of the T3FFComp shell FEMM. All elements use a single layup.

Formulation for the transverse shear stiffness which averages the strain-displacement matrix.

Formulation for the transverse shear stiffness which averages the stiffness matrix.

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.

mutable struct FEMMPointMass{ID<:IntegDomain} <: AbstractFEMM

Type for linear deformation finite element modeling machine.

stiffness(
    self::FEMMPointGroundedSpring,
    assembler::ASS,
    geom0::NodalField{FFlt},
    u1::NodalField{T},
    Rfield1::NodalField{T},
    dchi::NodalField{TI},
) where {ASS<:AbstractSysmatAssembler,T<:Number,TI<:Number}

Compute the stiffness matrix

mutable struct FEMMPointGroundedSpring{ID<:IntegDomain} <: AbstractFEMM

Type for finite element modeling machine for grounded springs.

initial_Rfield(fens)

Set up initial rotation field (rotation matrices are all identities)

update_rotation_field!(Rfield, dchi)

Update rotation field by exponential incremental rotation.

Layup2ElementAngle{T}

A callable object: computes the cosine and sine of the angle between the element frame and the layup reference direction.

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.

(o::TransformerQtEQ)(E, Q)

Perform the transformation on the matrix E with the transformation matrix Q: Ebar = Q^T * E * Q.

SysmatAssemblerSparseCSRSymm{A<:AbstractSysmatAssembler} <: AbstractSysmatAssembler

Assembler for a symmetric square matrix assembled from symmetric square matrices. The matrix is stored in the Compressed Sparse Row (CSR) format.

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

Module for working with composite layups.

Module for working with cross-section properties of beam elements.

Module for construction of framed structures consisting of beam elements.

Module for a 2-node beam element set.

Module for a 3-node shell element set.

Module for a 4-node shell element set.

Module for construction of the linear algebra matrix and vector quantities for the non-linear co-rotational beam.

Module for construction of the linear algebra matrix and vector quantities for the linear beam with eccentric connections to nodes.

Module for construction of the linear algebra matrix and vector quantities for the linear Timoshenko beam based on reduced integration.

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

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

Module for construction of the linear algebra matrix and vector quantities for the point masses.

Module for construction of the linear algebra matrix and vector quantities for the grounded springs.

Module for utilities working with rotations in 3D space.

Module for geometric transformations of element matrices.

Module for assemblers of system matrices and vectors.