GitHub

Reference Manual

Simple FE model (volume)

FinEtools.FEMMBaseModule.inspectintegpoints — Method
inspectintegpoints(self::FEMM, geom::NodalField{GFT},  u::NodalField{UFT}, dT::NodalField{TFT}, felist::AbstractVector{IT}, inspector::F, idat, quantity=:Cauchy; context...) where {FEMM<:AbstractFEMMDeforLinear, GFT<:Number, UFT<:Number, TFT<:Number, IT<:Integer, F<:Function}

Inspect integration point quantities.

  • geom - reference geometry field
  • u - displacement 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 - functionwith 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
FinEtoolsDeforLinear.FEMMDeforLinearBaseModule.infsup_gh — Method
infsup_gh(self::AbstractFEMMDeforLinear, assembler::A, geom::NodalField{GFT}, u::NodalField{UFT}) where {A<:AbstractSysmatAssembler, GFT, UFT}

Compute the matrix to produce the norm of the divergence of the displacement.

This matrix is used in the numerical infsup test (Klaus-Jurgen Bathe, The inf-sup condition and its evaluation for mixed finite element methods, Computers and Structures 79 (2001) 243-252.)

Note

This computation has not been optimized in any way. It can be expected to be inefficient.

source
FinEtoolsDeforLinear.FEMMDeforLinearBaseModule.infsup_sh — Method
infsup_sh(self::AbstractFEMMDeforLinear, assembler::A, geom::NodalField{GFT}, u::NodalField{UFT}) where {A<:AbstractSysmatAssembler, GFT<:Number, UFT<:Number}

Compute the matrix to produce the seminorm of the displacement (square root of the sum of the squares of the derivatives of the components of displacement).

This matrix is used in the numerical infsup test (Klaus-Jurgen Bathe, The inf-sup condition and its evaluation for mixed finite element methods, Computers and Structures 79 (2001) 243-252.)

Note

This computation has not been optimized in any way. It can be expected to be inefficient.

source
FinEtoolsDeforLinear.FEMMDeforLinearBaseModule.mass — Method
mass(self::AbstractFEMMDeforLinear,  assembler::A,  geom::NodalField{GFT}, u::NodalField{UFT}) where {A<:AbstractSysmatAssembler, GFT<:Number, UFT<:Number}

Compute the consistent mass matrix

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

source
FinEtoolsDeforLinear.FEMMDeforLinearBaseModule.stiffness — Method
stiffness(self::FEMM, assembler::A, geom::NodalField{GFT}, u::NodalField{UFT}) where {FEMM<:AbstractFEMMDeforLinear, A<:AbstractSysmatAssembler, GFT<:Number, UFT<:Number}

Compute and assemble stiffness matrix.

Note

The material stiffness matrix is assumed to be the same at all the points of the domain (homogeneous material).

source

Simple FE models (surface)

FinEtoolsDeforLinear.FEMMDeforWinklerModule.surfacenormalspringstiffness — Method
surfacenormalspringstiffness(self::FEMMDeforWinkler, assembler::A, geom::NodalField{GFT}, u::NodalField{UFT}, springconstant::UFT, surfacenormal::SurfaceNormal) where {A<:AbstractSysmatAssembler, GFT<:Number, UFT<:Number}

Compute the stiffness matrix of surface normal spring.

Rationale: consider continuously distributed springs between the surface of the solid body and the 'ground', in the direction normal to the surface. If the spring coefficient becomes large, we have an approximate method of enforcing the normal displacement to the surface.

source
FinEtoolsDeforLinear.FEMMDeforSurfaceDampingModule.dampingABC — Method
dampingABC(self::FEMMDeforSurfaceDamping, assembler::A, geom::NodalField{GFT}, u::NodalField{UFT}, impedance::UFT, surfacenormal::SurfaceNormal) where {A<:AbstractSysmatAssembler, GFT<:Number, UFT<:Number}

Compute the damping matrix associated with absorbing boundary conditions (ABC).

Compute the damping matrix associated with absorbing boundary conditions (ABC) representation of the effect of infinite extent of inviscid fluid next to the surface.

source

Advanced: Mean-strain FEM

FinEtools.FEMMBaseModule.associategeometry! — Method
associategeometry!(self::F,  geom::NodalField{GFT}) where {F<:FEMMDeforLinearMSH8, GFT}

Associate geometry field with the FEMM.

Compute the correction factors to account for the shape of the elements.

source
FinEtools.FEMMBaseModule.associategeometry! — Method
associategeometry!(self::F,  geom::NodalField{GFT}) where {F<:FEMMDeforLinearMST10, GFT}

Associate geometry field with the FEMM.

Compute the correction factors to account for the shape of the elements.

source
FinEtools.FEMMBaseModule.inspectintegpoints — Method
inspectintegpoints(
    self::AbstractFEMMDeforLinearMS,
    geom::NodalField{GFT},
    u::NodalField{UFT},
    dT::NodalField{TFT},
    felist::Vector{IT},
    inspector::F,
    idat,
    quantity = :Cauchy;
    context...,
) where {GFT<:Number,UFT<:Number,TFT<:Number,IT,F<:Function}

Inspect integration point quantities.

Arguments

  • geom - reference geometry field
  • u - displacement 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 - functionwith 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
FinEtoolsDeforLinear.FEMMDeforLinearMSModule.infsup_gh — Method
infsup_gh(self::AbstractFEMMDeforLinearMS, assembler::A, geom::NodalField{GFT}, u::NodalField{UFT}) where {A<:AbstractSysmatAssembler, GFT<:Number, UFT<:Number}

Compute the matrix to produce the norm of the divergence of the displacement.

This matrix is used in the numerical infsup test (Klaus-Jurgen Bathe, The inf-sup condition and its evaluation for mixed finite element methods, Computers and Structures 79 (2001) 243-252.)

Note

This computation has not been optimized in any way. It can be expected to be inefficient.

source
FinEtoolsDeforLinear.FEMMDeforLinearMSModule.infsup_sh — Method
infsup_sh(self::AbstractFEMMDeforLinearMS, assembler::A, geom::NodalField{GFT}, u::NodalField{UFT}) where {A<:AbstractSysmatAssembler, GFT<:Number, UFT<:Number}

Compute the matrix to produce the seminorm of the displacement (square root of the sum of the squares of the derivatives of the components of displacement).

This matrix is used in the numerical infsup test (Klaus-Jurgen Bathe, The inf-sup condition and its evaluation for mixed finite element methods, Computers and Structures 79 (2001) 243-252.)

Note

This computation has not been optimized in any way. It can be expected to be inefficient.

source
FinEtoolsDeforLinear.FEMMDeforLinearMSModule.FEMMDeforLinearMSH8 — Type
mutable struct FEMMDeforLinearMSH8{
    MR<:AbstractDeforModelRed,
    ID<:IntegDomain{S,F} where {S<:FESetH8,F<:Function},
    CS<:CSys,
    M<:AbstractMatDeforLinearElastic,
    MS<:MatDeforElastIso,
} <: AbstractFEMMDeforLinearMS

Type for mean-strain linear deformation FEMM based on eight-node hexahedral elements.

source
FinEtoolsDeforLinear.FEMMDeforLinearMSModule.FEMMDeforLinearMST10 — Type
mutable struct FEMMDeforLinearMST10{
    MR<:AbstractDeforModelRed,
    ID<:IntegDomain{S,F} where {S<:FESetT10,F<:Function},
    CS<:CSys,
    M<:AbstractMatDeforLinearElastic,
    MS<:MatDeforElastIso,
} <: AbstractFEMMDeforLinearMS

Type for mean-strain linear deformation FEMM based on 10-node tetrahedral elements.

source

Advanced: Nodal integration

FinEtools.FEMMBaseModule.associategeometry! — Method
associategeometry!(self::F,
    geom::NodalField{GFT}) where {F <: AbstractFEMMDeforLinearNICE, GFT}

Associate geometry field with the FEMM.

Compute the correction factors to account for the shape of the elements.

source
FinEtools.FEMMBaseModule.associategeometry! — Method
associategeometry!(self::F,  geom::NodalField{GFT}) where {F<:FEMMDeforLinearESNICEH8, GFT}

Associate geometry field with the FEMM.

Compute the correction factors to account for the shape of the elements.

source
FinEtools.FEMMBaseModule.associategeometry! — Method
associategeometry!(self::F,  geom::NodalField{GFT}; stabilization_parameters = _T4_stabilization_parameters) where {F<:FEMMDeforLinearESNICET4, GFT}

Associate geometry field with the FEMM.

Compute the correction factors to account for the shape of the elements.

source
FinEtools.FEMMBaseModule.inspectintegpoints — Method

inspectintegpoints(self::AbstractFEMMDeforLinearESNICE, geom::NodalField{GFT}, u::NodalField{UFT}, dT::NodalField{TFT}, felist::Vector{IT}, inspector::F, idat, quantity=:Cauchy; context...) where {GFT<:Number, UFT<:Number, TFT<:Number, IT<:Integer, F<:Function}

Inspect integration point quantities.

Arguments

  • geom - reference geometry field
  • u - displacement 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 - functionwith 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
FinEtoolsDeforLinear.FEMMDeforLinearESNICEModule.infsup_gh — Method
infsup_gh(self::AbstractFEMMDeforLinearESNICE, assembler::A, geom::NodalField{GFT}, u::NodalField{UFT}) where {A<:AbstractSysmatAssembler, GFT<:Number, UFT<:Number}

Compute the matrix to produce the norm of the divergence of the displacement.

This matrix is used in the numerical infsup test (Klaus-Jurgen Bathe, The inf-sup condition and its evaluation for mixed finite element methods, Computers and Structures 79 (2001) 243-252.)

Note

This computation has not been optimized in any way. It can be expected to be inefficient.

source
FinEtoolsDeforLinear.FEMMDeforLinearESNICEModule.infsup_sh — Method
infsup_sh(self::AbstractFEMMDeforLinearESNICE, assembler::A, geom::NodalField{GFT}, u::NodalField{UFT}) where {A<:AbstractSysmatAssembler, GFT<:Number, UFT<:Number}

Compute the matrix to produce the seminorm of the displacement (square root of the sum of the squares of the derivatives of the components of displacement).

This matrix is used in the numerical infsup test (Klaus-Jurgen Bathe, The inf-sup condition and its evaluation for mixed finite element methods, Computers and Structures 79 (2001) 243-252.)

Note

This computation has not been optimized in any way. It can be expected to be inefficient.

source
FinEtoolsDeforLinear.FEMMDeforLinearESNICEModule.FEMMDeforLinearESNICEH8 — Type
mutable struct FEMMDeforLinearESNICEH8{
    MR<:AbstractDeforModelRed,
    ID<:IntegDomain{S} where {S<:FESetH8},
    CS<:CSys,
    M<:AbstractMatDeforLinearElastic,
    MS<:MatDeforElastIso,
} <: AbstractFEMMDeforLinearESNICE

FEMM type for Energy-sampling Stabilized Nodally Integrated Continuum Elements (NICE) based on the p-node hexahedron.

source
FinEtoolsDeforLinear.FEMMDeforLinearESNICEModule.FEMMDeforLinearESNICET4 — Type
mutable struct FEMMDeforLinearESNICET4{
    MR<:AbstractDeforModelRed,
    ID<:IntegDomain{S} where {S<:FESetT4},
    CS<:CSys,
    M<:AbstractMatDeforLinearElastic,
    MS<:MatDeforElastIso,
} <: AbstractFEMMDeforLinearESNICE

FEMM type for Energy-sampling Stabilized Nodally Integrated Continuum Elements (NICE) based on the 4-node tetrahedron.

source

Advanced: Incompatible modes

FinEtools.FEMMBaseModule.associategeometry! — Method
associategeometry!(self::F,  geom::NodalField{GFT}) where {F<:FEMMDeforLinearIMH8, GFT}

Associate geometry field with the FEMM.

Compute the correction factors to account for the shape of the elements.

source
FinEtoolsDeforLinear.FEMMDeforLinearIMModule.FEMMDeforLinearIMH8 — Type
FEMMDeforLinearIMH8{MR<:AbstractDeforModelRed, S<:FESetH8, F<:Function, M<:AbstractMatDeforLinearElastic}

Type for mean-strain linear deformation FEMM based on eight-node hexahedral elements with incompatible modes.

Default number of incompatible modes is 12 (Simo formulation). Alternative is 9 incompatible modes (Wilson formulation).

source
FinEtoolsDeforLinear.FEMMDeforLinearIMModule.FEMMDeforLinearIMH8 — Method
FEMMDeforLinearIMH8(
    mr::Type{MR},
    integdomain::ID,
    material::M,
    nmodes::Int64,
) where {MR<:AbstractDeforModelRed, ID<:IntegDomain{S,F} where {S<:FESetH8,F<:Function}, M<:AbstractMatDeforLinearElastic}

Constructor, with optional configuration of the number of incompatible modes.

source

Algorithms

Linear deformation

FinEtoolsDeforLinear.AlgoDeforLinearModule.exportdeformation — Method
AlgoDeforLinearModule.exportdeformation(modeldata::FDataDict)

Algorithm for exporting of the deformation for visualization in Paraview.

Argument

modeldata = dictionary with values for keys

  • "fens" = finite element node set

  • "regions" = array of region dictionaries

  • "geom" = geometry field

  • "u" = displacement field, or

  • "us" = array of tuples (name, displacement field)

  • "postprocessing" = dictionary with values for keys

    • "boundary_only" = should only the boundary of the regions be rendered? Default is render the interior.
    • "file" = name of the postprocessing file

For each region (connected piece of the domain made of a particular material), mandatory, the region dictionary contains values for keys:

  • "femm" = finite element mmodel machine (mandatory);

Output

modeldata updated with

  • modeldata["postprocessing"]["exported"] = array of data dictionaries, one for each exported file. The data is stored with the keys:

    • "file" - names of exported file # Defaults
    • "field" - nodal or elemental field
source
FinEtoolsDeforLinear.AlgoDeforLinearModule.exportmode — Method
AlgoDeforLinearModule.exportmode(modeldata::FDataDict)

Algorithm for exporting of the mmode shape for visualization in Paraview.

Argument

modeldata = dictionary with values for keys

  • "fens" = finite element node set

  • "regions" = array of region dictionaries

  • "geom" = geometry field

  • "u" = displacement field

  • "W" = Computed free-vibration eigenvectors, neigvs columns

  • "omega" = Computed free-vibration angular frequencies, array of length neigvs

  • "postprocessing" = dictionary with values for keys

    • "boundary_only" = should only the boundary of the regions be rendered? Default is render the interior.
    • "file" = name of the postprocessing file
    • "mode" = which mode should be visualized?
    • "component" = which component of the quantity?
    • "outputcsys" = output coordinate system

For each region (connected piece of the domain made of a particular material), mandatory, the region dictionary contains values for keys:

  • "femm" = finite element mmodel machine (mandatory);

Output

modeldata updated with

  • modeldata["postprocessing"]["exported"] = see exportdeformation()
source
FinEtoolsDeforLinear.AlgoDeforLinearModule.exportstress — Method
AlgoDeforLinearModule.exportstress(modeldata::FDataDict)

Algorithm for exporting of the stress for visualization in Paraview.

Argument

modeldata = dictionary with values for keys

  • "fens" = finite element node set

  • "regions" = array of region dictionaries

  • "geom" = geometry field

  • "u" = displacement field

  • "postprocessing" = dictionary with values for keys

    • "boundary_only" = should only the boundary of the regions be rendered? Default is render the interior.
    • "file" = name of the postprocessing file
    • "quantity" = quantity to be exported (default :Cauchy)
    • "component" = which component of the quantity?
    • "outputcsys" = output coordinate system
    • "inspectormeth" = inspector method to pass to inspectintegpoints()
    • "extrap" = method for extrapolating from the quadrature points to the nodes within one element

For each region (connected piece of the domain made of a particular material), mandatory, the region dictionary contains values for keys:

  • "femm" = finite element mmodel machine (mandatory);

Output

modeldata updated with

  • modeldata["postprocessing"]["exported"] = array of data dictionaries, one for each exported file. The data is stored with the keys:

    • "file" - name of exported file
    • "field" - nodal field
source
FinEtoolsDeforLinear.AlgoDeforLinearModule.exportstresselementwise — Method
AlgoDeforLinearModule.exportstresselementwise(modeldata::FDataDict)

Algorithm for exporting of the elementwise stress for visualization in Paraview.

Argument

modeldata = dictionary with values for keys

  • "fens" = finite element node set

  • "regions" = array of region dictionaries

  • "geom" = geometry field

  • "u" = displacement field

  • "postprocessing" = dictionary with values for keys

    • "boundary_only" = should only the boundary of the regions be rendered? Default is render the interior.
    • "file" = name of the postprocessing file
    • "quantity" = quantity to be exported (default :Cauchy)
    • "component" = which component of the quantity?
    • "outputcsys" = output coordinate system

For each region (connected piece of the domain made of a particular material), mandatory, the region dictionary contains values for keys:

  • "femm" = finite element mmodel machine (mandatory);

Output

modeldata updated with

  • modeldata["postprocessing"]["exported"] = array of data dictionaries, one for each exported file. The data is stored with the keys:

    • "file" - name of exported file
    • "field" - elemental field
source
FinEtoolsDeforLinear.AlgoDeforLinearModule.linearstatics — Method
AlgoDeforLinearModule.linearstatics(modeldata::FDataDict)

Algorithm for static linear deformation (stress) analysis.

Argument

modeldata = dictionary with values for keys

  • "fens" = finite element node set
  • "regions" = array of region dictionaries
  • "essential_bcs" = array of essential boundary condition dictionaries
  • "traction_bcs" = array of traction boundary condition dictionaries
  • "temperature_change" = dictionary of data for temperature change

For each region (connected piece of the domain made of a particular material), mandatory, the region dictionary contains values for keys:

  • "femm" = finite element model machine (mandatory);

For essential boundary conditions (optional) each dictionary would hold

  • "displacement" = fixed (prescribed) displacement (scalar), or a function with signature function w = f(x). If this value is not given, zero displacement is assumed.
  • "component" = which component is prescribed (1, 2, 3)?
  • "node_list" = list of nodes on the boundary to which the condition applies (mandatory)

For traction boundary conditions (optional) each dictionary would hold key-value pairs

  • "femm" = finite element model machine (mandatory);
  • "traction_vector" = traction vector, either a constant numerical vector, or a function to be used to construct a ForceIntensity object, or it could be the ForceIntensity object itself.

Output

modeldata = the dictionary on input is augmented with the keys

  • "geom" = the nodal field that is the geometry
  • "u" = the nodal field that is the computed displacement
  • "temp" = the nodal field that is the temperature change # For body loads (optional):
  • "work" = work of the applied loads # modeldata.bodyload = cell array of struct,
  • "timing" = dictionary with timing results # each piece of the domain can have each its own body load
source
FinEtoolsDeforLinear.AlgoDeforLinearModule.modal — Method
AlgoDeforLinearModule.modal(modeldata::FDataDict)

Modal (free-vibration) analysis solver.

Argument

modeldata = dictionary with values for keys

  • "fens" = finite element node set
  • "regions" = array of region dictionaries
  • "essential_bcs" = array of essential boundary condition dictionaries

For each region (connected piece of the domain made of a particular material), mandatory, the region dictionary contains values for keys:

  • "femm" = finite element mmodel machine (mandatory);

For essential boundary conditions (optional) each dictionary would hold

  • "displacement" = fixed (prescribed) displacement (scalar): only zero displacement is allowed for modal analysis.
  • "component" = which component is prescribed (1, 2, 3)?
  • "node_list" = list of nodes on the boundary to which the condition applies (mandatory)

Control parameters:

  • "neigvs" = number of eigenvalues/eigenvectors to compute
  • "omega_shift"= angular frequency shift for mass shifting
  • "use_lumped_mass" = true or false? (Default is false: consistent mass)

Output

modeldata= the dictionary on input is augmented with

  • "geom" = the nodal field that is the geometry
  • "u" = the nodal field that is the computed displacement
  • "neigvs" = Number of computed eigenvectors
  • "W" = Computed eigenvectors, neigvs columns
  • "omega" = Computed angular frequencies, array of length neigvs # For multi point constraints (MPC) (optional):
  • "raw_eigenvalues" = Raw computed eigenvalues # model_data.mpc= cell array of structs, each for one MPC.
source

Material models

Material for deformation, base functionality

FinEtoolsDeforLinear.MatDeforModule.rotstressvec! — Method
rotstressvec!(::Type{DeforModelRed1D},  outstress::Vector{T},  instress::Vector{T},  Rm::_RotationMatrix) where {T}

Rotate the stress vector by the supplied rotation matrix.

Calculate the rotation of the stress vector to the 'bar' coordinate system given by the columns of the rotation matrix Rm.

  • outstress = output stress vector, overwritten inside
  • instress = input stress vector
  • Rm = columns are components of 'bar' basis vectors on the 'plain' basis vectors
source
FinEtoolsDeforLinear.MatDeforModule.rotstressvec! — Method
rotstressvec!(::Type{DeforModelRed2DAxisymm},  outstress::Vector{T},  instress::Vector{T},  Rm::_RotationMatrix) where {T}

Rotate the stress vector by the supplied rotation matrix.

Calculate the rotation of the stress vector to the 'bar' coordinate system given by the columns of the rotation matrix Rm.

  • outstress = output stress vector, overwritten inside
  • instress = input stress vector
  • Rm = columns are components of 'bar' basis vectors on the 'plain' basis vectors
source
FinEtoolsDeforLinear.MatDeforModule.rotstressvec! — Method
rotstressvec!(::Type{DeforModelRed2DStrain},  outstress::Vector{T},  instress::Vector{T},  Rm::_RotationMatrix) where {T}

Rotate the stress vector by the supplied rotation matrix.

Calculate the rotation of the stress vector to the 'bar' coordinate system given by the columns of the rotation matrix Rm.

  • outstress = output stress vector, overwritten inside
  • instress = input stress vector
  • Rm = columns are components of 'bar' basis vectors on the 'plain' basis vectors
source
FinEtoolsDeforLinear.MatDeforModule.rotstressvec! — Method
rotstressvec!(::Type{DeforModelRed2DStress},  outstress::Vector{T},  instress::Vector{T},  Rm::_RotationMatrix) where {T}

Rotate the stress vector by the supplied rotation matrix.

Calculate the rotation of the stress vector to the 'bar' coordinate system given by the columns of the rotation matrix Rm.

  • outstress = output stress vector, overwritten inside
  • instress = input stress vector
  • Rm = columns are components of 'bar' basis vectors on the 'plain' basis vectors
source
FinEtoolsDeforLinear.MatDeforModule.rotstressvec! — Method
rotstressvec!(::Type{DeforModelRed3D},  outstress::Vector{T},  instress::Vector{T}, Rm::_RotationMatrix) where {T}

Rotate the stress vector by the supplied rotation matrix.

Calculate the rotation of the stress vector to the 'bar' coordinate system given by the columns of the rotation matrix Rm.

  • outstress = output stress vector, overwritten inside
  • instress = input stress vector
  • Rm = columns are components of 'bar' basis vectors on the 'plain' basis vectors
source
FinEtoolsDeforLinear.MatDeforModule.strainvdet — Method
strainvdet(::Type{DeforModelRed2DStrain},  Cv::Vector{T}) where {T}

Compute the determinant of a symmetric strain-like square matrix represented as a vector. Remember that the shear strain components are twice the entries of the matrix representation.

source
FinEtoolsDeforLinear.MatDeforModule.strainvdet — Method
strainvdet(::Type{DeforModelRed3D},  Cv::Vector{T}) where {T}

Compute the determinant of a symmetric strain-like square matrix represented as a vector. Remember that the shear strain components are twice the entries of the matrix representation.

source
FinEtoolsDeforLinear.MatDeforModule.stressvtot! — Method
stressvtot!(::Type{DeforModelRed2DAxisymm}, t::Matrix{T}, v::Vector{T}) where {T}

Convert a 4-vector to a matrix of 3x3 stress components (tensor).

Convert a 4-vector to a symmetric matrix of 3x3 stress components (tensor).

The stress vector components need to be ordered as: sigmax, sigmay, sigmaz, tauxy.

source
FinEtoolsDeforLinear.MatDeforModule.stressvtot! — Method
stressvtot!(::Type{DeforModelRed2DStrain}, t::Matrix{T}, v::Vector{T}) where {T}

Convert a vector to a matrix of 2x2 stress components (symmetric tensor).

If v has 4 entries, also the t[3,3] matrix entry is set.

The stress vector components need to be ordered as: sigmax, sigmay, tauxy, sigmaz, which is the ordering used for the plane-strain model reduction.

source
FinEtoolsDeforLinear.MatDeforModule.tens4deviator! — Method
tens4deviator!(t::Array{T, 4}) where {T}

Compute 4th-order deviator tensor.

Double contraction of a second order tensor with this fourth-order tensor produces the deviator part of the second order tensor.

Example

The product of the deviator tensor with the second-order tensor S is 

t = fill(0.0, 3, 3, 3, 3)
tens4deviator!(t)
S = rand(3, 3)
tS = fill(0.0, 3, 3)
tens4dot2!(tS, t, S)
@show tr((S - tr(S)/3*I) ), tr(tS)
source
FinEtoolsDeforLinear.MatDeforModule.tens4dot2! — Method
tens4dot2!(R::Array{T, 2}, F::Array{T, 4}, S::Array{T, 2}) where {T}

Compute the double contraction of a 4th-order and a 2nd-order tensors.

Note

The double contraction of two second-order sensors is defined as A:B = tr(A'*B) = A_ij B_ij

The resulting second-order tensor is first zeroed out, and then the result is accumulated.

source
FinEtoolsDeforLinear.MatDeforModule.tens4identity! — Method
tens4identity!(t::Array{T, 4}) where {T}

Compute 4th-order identity tensor.

Example

The product of the identity tensor with the second-order tensor S is 

t = fill(0.0, 3, 3, 3, 3)
tens4identity!(t)
S = rand(3, 3)
tS = fill(0.0, 3, 3)
tens4dot2!(tS, t, S)
@show S - tS
source
FinEtoolsDeforLinear.MatDeforModule.tens4ijkl! — Method
tens4ijkl!(t::Array{T, 4}, A::FA, B::FB, op = :+) where {T, FA, FB}

Fill a 4th-order tensor as a dyadic product of two 2nd-order tensors.

The i,j,k,l component is given as t[i,j,k,l]=A(i,j)*B(k,l).

Note

The tensor is accumulated to. It needs to be initialized to zero, if that is desired as the initial state.

Example

t = fill(0.0, 3, 3, 3, 3)
delta = (I, J) -> I == J ? 1.0 : 0.0
tens4ijkl!(t, delta, delta)
S = rand(3, 3)
@show tr(S) * I
tS = fill(0.0, 3, 3)
@show tens4dot2!(tS, t, S)
source
FinEtoolsDeforLinear.MatDeforModule.tens4ikjl! — Method
tens4ikjl!(t::Array{T, 4}, A::FA, B::FB) where {T, FA, FB}

Fill a 4th-order tensor as a dyadic product of two 2nd-order tensors.

The i,j,k,l component is given as t[i,j,k,l]=A(i,k)*B(j,l).

Note

The tensor is accumulated to. It needs to be initialized to zero, if that is desired as the initial state.

Example

t = fill(0.0, 3, 3, 3, 3)
delta = (I, J) -> I == J ? 1.0 : 0.0
tens4ikjl!(t, delta, delta)
S = rand(3, 3)
@show transpose(S) 
tS = fill(0.0, 3, 3)
@show transpose(S) - tens4dot2!(tS, t, S)
source
FinEtoolsDeforLinear.MatDeforModule.tens4iljk! — Method
tens4iljk!(t::Array{T, 4}, A::FA, B::FB) where {T, FA, FB}

Fill a 4th-order tensor as a dyadic product of two 2nd-order tensors.

The i,j,k,l component is given as t[i,j,k,l]=A(i,l)*B(j,k).

Note

The tensor is accumulated to. It needs to be initialized to zero, if that is desired as the initial state.

Example

t = fill(0.0, 3, 3, 3, 3)
delta = (I, J) -> I == J ? 1.0 : 0.0
tens4iljk!(t, delta, delta)
S = rand(3, 3)
tS = fill(0.0, 3, 3)
@show S - tens4dot2!(tS, t, S)
source
FinEtoolsDeforLinear.MatDeforModule.tens4skewor! — Method
tens4skewor!(t::Array{T, 4}) where {T}

Compute 4th-order skewor tensor.

Double contraction of a second order tensor with this fourth-order tensor produces the skew part of the second order tensor.

Example

The product of the skewor tensor with the second-order tensor S is 

t = fill(0.0, 3, 3, 3, 3)
tens4skewor!(t)
S = rand(3, 3)
tS = fill(0.0, 3, 3)
tens4dot2!(tS, t, S)
@show (S - S')/2 * I - tS
source
FinEtoolsDeforLinear.MatDeforModule.tens4symmetrizor! — Method
tens4symmetrizor!(t::Array{T, 4}) where {T}

Compute 4th-order symmetrizor tensor.

Double contraction of a second order tensor with this fourth-order tensor produces the symmetric part of the second order tensor.

Example

The product of the symmetrizor tensor with the second-order tensor S is 

t = fill(0.0, 3, 3, 3, 3)
tens4symmetrizor!(t)
S = rand(3, 3)
tS = fill(0.0, 3, 3)
tens4dot2!(tS, t, S)
@show (S + S')/2 * I - tS
source
FinEtoolsDeforLinear.MatDeforModule.tens4symmt6x6tot! — Method
tens4symmt6x6tot!(ST::Array{T, 4}, M::Matrix{T}) where {T}

Convert a symmetric 6 x 6 matrix to a symmetric 4th-order tensor.

!!! Note The order corresponds to the arrangement of the components of stress (or strain) tensor, symmetric, three-dimensional, into a 6-component vector.

source
FinEtoolsDeforLinear.MatDeforModule.tens4symmtto6x6t! — Method
tens4symmtto6x6t!(M::Matrix{T}, ST::Array{T, 4}) where {T}

Convert a symmetric 4th-order tensor to a 6 x 6 matrix.

!!! Note The order corresponds to the arrangement of the components of stress (or strain) tensor, symmetric, three-dimensional, into a 6-component vector.

Example

J=tens4_ijkl(eye(3),eye(3))
produces the tracor:
T=rand(3); 
sum(diag(T))*eye(3)
t= tens4_dot_2(J,T)
M= tens4_symm_to_6(ST)
source
FinEtoolsDeforLinear.MatDeforModule.tens4tracor! — Method
tens4tracor!(t::Array{T, 4}) where {T}

Compute 4th-order tracor tensor.

Double contraction of a second order tensor with this fourth-order tensor produces the spherical part of the second order tensor.

Example

The product of the tracor tensor with the second-order tensor S is 

t = fill(0.0, 3, 3, 3, 3)
tens4tracor!(t)
S = rand(3, 3)
tS = fill(0.0, 3, 3)
tens4dot2!(tS, t, S)
@show tr(S) * I - tS
source
FinEtoolsDeforLinear.MatDeforModule.tens4transposor! — Method
tens4transposor!(t::Array{T, 4}) where {T}

Compute 4th-order transposor tensor.

Example

The product of the transposor tensor with the second-order tensor S is 

t = fill(0.0, 3, 3, 3, 3)
tens4transposor!(t)
S = rand(3, 3)
tS = fill(0.0, 3, 3)
tens4dot2!(tS, t, S)
@show S' - tS
source

Elasticity

FinEtoolsDeforLinear.MatDeforLinearElasticModule.update! — Method
update!(self::AbstractMatDeforLinearElastic,  stress::Vector{FT}, output::Vector{FT},  strain::Vector{FT}, thstrain::Vector{FT}=zeros(6), t::FT= 0.0, dt::FT= 0.0,  loc::Matrix{FT}=zeros(3,1), label::Int=0, quantity=:nothing) where {FT}

Update material state.

  • strain = strain vector,
  • thstrain = thermal strain vector,
  • t = current time,
  • dt = current time step,
  • loc = location of the quadrature point in global Cartesian coordinates,
  • label = label of the finite element in which the quadrature point is found.

Output

  • stress = stress vector, allocated by the caller with a size of the number of stress and

strain components, nstressstrain. The components of the stress vector are calculated and stored in the stress vector.

  • output = array which is (if necessary) allocated in an appropriate size, filled with the output quantity, and returned.
source

Isotropic elasticity

Orthotropic elasticity

FinEtoolsDeforLinear.MatDeforElastOrthoModule.MatDeforElastOrtho — Method
MatDeforElastOrtho(
    mr::Type{MR},
    mass_density::N,
    E::N,
    nu::N,
    CTE::N,
) where {MR<:AbstractDeforModelRed,N<:Number}

Create elastic orthotropic material which is really isotropic.

Convenience version with only the specification of the elastic and thermal expansion properties.

source

Modules

FinEtoolsDeforLinear.FEMMDeforLinearESNICEModule — Module
FEMMDeforLinearESNICEModule

Formulation for the small displacement, small strain deformation model for Nodally-Integrated Continuum Elements (NICE).

The approximation is originally from Dohrmann et al IJNME 47 (2000). The formulation was subsequently developed in Krysl, P. and Zhu, B. Locking-free continuum displacement finite elements with nodal integration, International Journal for Numerical Methods in Engineering, 76,7,1020-1043,2008.

The stabilization scheme comes from papers on energy-sampling stabilization for mean-strain elements (Krysl).

source
FinEtoolsDeforLinear.FinEtoolsDeforLinear — Module

FinEtoolsDeforLinear (C) 2017-2024, Petr Krysl

Finite Element tools. Julia implementation of the finite element method for continuum mechanics. Package for linear stress analysis problems.

source
FinEtoolsDeforLinear.FEMMDeforLinearNICEModule — Module
FEMMDeforLinearNICEModule

Formulation for the small displacement, small strain deformation model for Nodally-Integrated Continuum Elements (NICE).

The approximation is originally from Dohrmann et al IJNME 47 (2000). The formulation was subsequently developed in Krysl, P. and Zhu, B. Locking-free continuum displacement finite elements with nodal integration, International Journal for Numerical Methods in Engineering, 76,7,1020-1043,2008.

source
Missing docstring.

Missing docstring for FinEtoolsDeforLinear.MatDeforElastIsoModule. Check Documenter's build log for details.

Missing docstring.

Missing docstring for FinEtoolsDeforLinear.MatDeforLinearElasticModule. Check Documenter's build log for details.

FinEtoolsDeforLinear.FEMMDeforWinklerModule — Module
FEMMDeforWinklerModule

Module for operations on boundaries of domains to construct system matrices and system vectors for linear deformation models with distributed-spring supports (Winkler foundation model).

source