Reference Manual

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.

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.

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

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

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.

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.

thermalstrainloads(
    self::AbstractFEMMDeforLinear,
    assembler::A,
    geom::NodalField{GFT},
    u::NodalField{UFT},
    dT::NodalField{TFT},
) where {A<:AbstractSysvecAssembler,GFT<:Number,UFT<:Number,TFT<:Number}

Compute the thermal-strain load vector.

AbstractFEMMDeforLinear <: AbstractFEMMBase

Abstract type of FEMM for linear deformation.

mutable struct FEMMDeforLinear{
    MR<:AbstractDeforModelRed,
    ID<:IntegDomain,
    CS<:CSys,
    M<:AbstractMatDeforLinearElastic,
} <: AbstractFEMMDeforLinear

Type for linear deformation finite element modeling machine.

FEMMDeforLinear(
    mr::Type{MR},
    integdomain::IntegDomain{S,F},
    material::M,
) where {
    MR<:AbstractDeforModelRed,
    S<:AbstractFESet,
    F<:Function,
    M<:AbstractMatDeforLinearElastic,
}

Constructor of linear deformation finite element modeling machine.

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.

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

Type for normal spring support (Winkler).

dampingABC(
    self::FEMMDeforSurfaceDamping,
    assembler::A,
    geom::NodalField{GFT},
    u::NodalField{UFT},
    impedance::FT,
    surfacenormal::SurfaceNormal,
) where {A<:AbstractSysmatAssembler,GFT<:Number,UFT<:Number,FT<: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.

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

Type for surface damping model.

associategeometry!(
    self::FEMMDeforLinearMSH8,
    geom::NodalField{GFT},
) where {GFT}

Associate geometry field with the FEMM.

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

associategeometry!(
    self::FEMMDeforLinearMST10,
    geom::NodalField{GFT},
) where {GFT}

Associate geometry field with the FEMM.

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

inspectintegpoints(
    self::FEMM,
    geom::NodalField{GFT},
    u::NodalField{UFT},
    dT::NodalField{TFT},
    felist::Vector{IT},
    inspector::F,
    idat,
    quantity = :Cauchy;
    context...,
) where {FEMM<:AbstractFEMMDeforLinearMS,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.

stiffness(
    self::FEMM,
    assembler::A,
    geom::NodalField{GFT},
    u::NodalField{UFT},
) where {FEMM<:AbstractFEMMDeforLinearMS,A<:AbstractSysmatAssembler,GFT<:Number,UFT<:Number}

Compute and assemble stiffness matrix.

infsup_gh(
    self::FEMM,
    assembler::A,
    geom::NodalField{GFT},
    u::NodalField{UFT},
) where {FEMM<:AbstractFEMMDeforLinearMS,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.)

infsup_sh(
    self::FEMM,
    assembler::A,
    geom::NodalField{GFT},
    u::NodalField{UFT},
) where {FEMM<:AbstractFEMMDeforLinearMS,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.)

AbstractFEMMDeforLinearMS <: AbstractFEMMDeforLinear

Abstract type for mean-strain linear deformation FEMM.

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.

FEMMDeforLinearMSH8(
    mr::Type{MR},
    integdomain::ID,
    mcsys::CS,
    material::M,
) where {MR<:AbstractDeforModelRed, ID<:IntegDomain{S} where {S<:FESetH8}, CS<:CSys, M<:AbstractMatDeforLinearElastic}

Constructor.

FEMMDeforLinearMSH8(
    mr::Type{MR},
    integdomain::ID,
    material::M,
) where {MR<:AbstractDeforModelRed, ID<:IntegDomain{S} where {S<:FESetH8}, M<:AbstractMatDeforLinearElastic}

Constructor.

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.

FEMMDeforLinearMST10(
    mr::Type{MR},
    integdomain::ID,
    mcsys::CS,
    material::M,
) where {MR<:AbstractDeforModelRed, ID<:IntegDomain{S} where {S<:FESetT10}, CS<:CSys, M<:AbstractMatDeforLinearElastic}

Constructor.

FEMMDeforLinearMST10(
    mr::Type{MR},
    integdomain::ID,
    material::M,
) where {MR<:AbstractDeforModelRed, ID<:IntegDomain{S} where {S<:FESetT10}, M<:AbstractMatDeforLinearElastic}

Constructor.

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.

stiffness(self::AbstractFEMMDeforLinearNICE,
    assembler::A,
    geom::NodalField{GFT},
    u::NodalField{UFT}) where {A <: AbstractSysmatAssembler, GFT <: Number, UFT <: Number}

Compute and assemble stiffness matrix.

stiffness(self::AbstractFEMMDeforLinearNICE,
    geom::NodalField{GFT},
    u::NodalField{UFT}) where {GFT <: Number, UFT <: Number}

Compute and assemble stiffness matrix.

AbstractFEMMDeforLinearNICE <: AbstractFEMMDeforLinear

Abstract FEMM type for Nodally Integrated Continuum Elements (NICE).

mutable struct FEMMDeforLinearNICEH8{
    MR <: AbstractDeforModelRed,
    S <: FESetH8,
    F <: Function,
    M <: AbstractMatDeforLinearElastic,
} <: AbstractFEMMDeforLinearNICE

FEMM type for Nodally Integrated Continuum Elements (NICE) based on the eight-node hexahedron.

mutable struct FEMMDeforLinearNICET4{
    MR <: AbstractDeforModelRed,
    S <: FESetT4,
    F <: Function,
    M <: AbstractMatDeforLinearElastic,
} <: AbstractFEMMDeforLinearNICE

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

associategeometry!(
    self::FEMM,
    geom::NodalField{GFT},
) where {FEMM<:FEMMDeforLinearESNICEH8,GFT}

Associate geometry field with the FEMM.

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

associategeometry!(
    self::FEMM,
    geom::NodalField{GFT};
    stabilization_parameters = _T4_stabilization_parameters,
) where {FEMM<:FEMMDeforLinearESNICET4,GFT}

Associate geometry field with the FEMM.

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

inspectintegpoints(
    self::FEMM,
    geom::NodalField{GFT},
    u::NodalField{UFT},
    dT::NodalField{TFT},
    felist::Vector{IT},
    inspector::F,
    idat,
    quantity = :Cauchy;
    context...,
) where {FEMM<:AbstractFEMMDeforLinearESNICE,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.

stiffness(
    self::FEMM,
    assembler::A,
    geom::NodalField{GFT},
    u::NodalField{T},
) where {FEMM<:AbstractFEMMDeforLinearESNICE,A<:AbstractSysmatAssembler,GFT<:Number,T<:Number}

Compute and assemble stiffness matrix.

infsup_gh(
    self::FEMM,
    assembler::A,
    geom::NodalField{GFT},
    u::NodalField{UFT},
) where {FEMM<:AbstractFEMMDeforLinearESNICE,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.)

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

AbstractFEMMDeforLinearESNICE <: AbstractFEMMDeforLinear

Abstract FEMM type for Nodally Integrated Continuum Elements (NICE) with energy-sampling stabilization (ESNICE).

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 (ESNICE) based on the 8-node hexahedron.

FEMMDeforLinearESNICEH8(
    mr::Type{MR},
    integdomain::ID,
    mcsys::CS,
    material::M,
) where {
    MR<:AbstractDeforModelRed,
    ID<:IntegDomain{S} where {S<:FESetH8},
    CS<:CSys,
    M<:AbstractMatDeforLinearElastic,
}

Constructor.

FEMMDeforLinearESNICEH8(
    mr::Type{MR},
    integdomain::ID,
    material::M,
) where {
    MR<:AbstractDeforModelRed,
    ID<:IntegDomain{S} where {S<:FESetH8},
    M<:AbstractMatDeforLinearElastic,
}

Constructor.

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 (ESNICE) based on the 4-node tetrahedron.

FEMMDeforLinearESNICET4(
    mr::Type{MR},
    integdomain::ID,
    mcsys::CS,
    material::M,
) where {
    MR<:AbstractDeforModelRed,
    ID<:IntegDomain{S} where {S<:FESetT4},
    CS<:CSys,
    M<:AbstractMatDeforLinearElastic,
}

Constructor.

FEMMDeforLinearESNICET4(
    mr::Type{MR},
    integdomain::ID,
    material::M,
) where {
    MR<:AbstractDeforModelRed,
    ID<:IntegDomain{S} where {S<:FESetT4},
    M<:AbstractMatDeforLinearElastic,
}

Constructor.

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.

stiffness(
    self::FEMMDeforLinearIMH8,
    assembler::A,
    geom::NodalField{GFT},
    u::NodalField{UFT},
) where {A<:AbstractSysmatAssembler,GFT<:Number,UFT<:Number}

Compute and assemble stiffness matrix.

mutable struct FEMMDeforLinearIMH8{
    MR<:AbstractDeforModelRed,
    ID<:IntegDomain{S,F} where {S<:FESetH8,F<:Function},
    CS<:CSys,
    M<:AbstractMatDeforLinearElastic,
} <: AbstractFEMMDeforLinear

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

FEMMDeforLinearIMH8(
    mr::Type{MR},
    integdomain::ID,
    mcsys::CS,
    material::M,
) where {
    MR<:AbstractDeforModelRed,
    ID<:IntegDomain{S,F} where {S<:FESetH8,F<:Function},
    CS<:CSys,
    M<:AbstractMatDeforLinearElastic,
}

Constructor. Default number of incompatible modes.

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.

FEMMDeforLinearIMH8(
    mr::Type{MR},
    integdomain::ID,
    material::M,
) where {
    MR<:AbstractDeforModelRed,
    ID<:IntegDomain{S,F} where {S<:FESetH8,F<:Function},
    M<:AbstractMatDeforLinearElastic,
}

Constructor. Default number of incompatible modes.

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
  • "field" - nodal or elemental field

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

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

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

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
• "work" = work of the applied loads
• "timing" = dictionary with timing results

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.

dett(::Type{DeforModelRed2DStrain},  C::Matrix{T}) where {T}

Compute the determinant of a general square matrix.

dett(::Type{DeforModelRed3D},  C::Matrix{T}) where {T}

Compute the determinant of a general square matrix.

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

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

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

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

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

strainttov!(::Type{DeforModelRed2DStrain}, v::Vector{T}, t::Matrix{T}) where {T}

Convert a symmetric matrix of 2x2 strain components into a 3-component vector.

strainttov!(::Type{DeforModelRed3D}, v::Vector{T}, t::Matrix{T}) where {T}

Convert a symmetric matrix of 3x3 strain components into a 6-component vector.

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.

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.

strainvtot!(::Type{DeforModelRed2DStrain}, t::Matrix{T}, v::Vector{T}) where {T}

Convert a strain 3-vector to a matrix of 2x2 strain components (symmetric tensor).

strainvtot!(::Type{DeforModelRed3D}, t::Matrix{T}, v::Vector{T}) where {T}

Convert a strain 3-vector to a matrix of 2x2 strain components (symmetric tensor).

strainvtr(::Type{DeforModelRed2DStrain},  Cv::Vector{T}) where {T}

Compute the trace of a symmetric strain-like square matrix represented as a vector.

strainvtr(::Type{DeforModelRed3D},  Cv::Vector{T}) where {T}

Compute the trace of a symmetric strain-like square matrix represented as a vector.

stressttov!(::Type{DeforModelRed2DStrain}, v::Vector{T}, t::Matrix{T}) where {T}

Convert a symmetric matrix of 2x2 stress components to a 3-component vector.

stressttov!(::Type{DeforModelRed2DStress}, v::Vector{T}, t::Matrix{T}) where {T}

Convert a symmetric matrix of 2x2 stress components to a 3-component vector.

stressttov!(::Type{DeforModelRed3D}, v::Vector{T}, t::Matrix{T}) where {T}

Convert a symmetric matrix of 3x3 stress components to a 6-component vector.

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.

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.

stressvtot!(::Type{DeforModelRed2DStress}, t::Matrix{T}, v::Vector{T}) where {T}

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

stressvtot!(::Type{DeforModelRed3D}, t::Matrix{T}, v::Vector{T}) where {T}

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

tens4checksymmetry(C4th)

If the fourth-order tensor of material elasticity has the full set of symmetries, return true; otherwise false.

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)

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.

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.

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

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

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)

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

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)

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

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)

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

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

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.

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)

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

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

AbstractMatDefor

Abstract type that represents deformable materials.

tangentmoduli!(
    self::AbstractMatDeforLinearElastic,
    D::Matrix{FT},
    t::FT,
    dt::FT,
    loc::Matrix{FT},
    label::Int,
) where {FT}

Calculate the material stiffness matrix.

• D = matrix of tangent moduli, supplied as a buffer and overwritten. Returned

as output.

thermalstrain!(
    self::AbstractMatDeforLinearElastic,
    thstrain::Vector{FT},
    dT = 0.0,
) where {FT}

Compute thermal strain from the supplied temperature increment.

• thstrain = thermal strain vector, supplied as buffer, returned as output.

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.

AbstractMatDeforLinearElastic <: AbstractMatDefor

Abstract Linear Elasticity material.

struct MatDeforElastIso{
    MR<:AbstractDeforModelRed,
    FT,
    MTAN<:Function,
    MUPD<:Function,
    MTHS<:Function,
} <: AbstractMatDeforLinearElastic

Linear isotropic elasticity material.

MatDeforElastIso(mr::Type{DeforModelRed1DStrain}, args::NTuple{4, FT}) where FT

Create elastic isotropic material for 1D models.

MatDeforElastIso(mr::Type{DeforModelRed1DStress}, args::NTuple{4, FT}) where FT

Create elastic isotropic material for 1D models.

MatDeforElastIso(mr::Type{DeforModelRed2DAxisymm}, args::NTuple{4, FT}) where FT

Create elastic isotropic material for 2D axially symmetric models.

MatDeforElastIso(mr::Type{DeforModelRed2DStrain}, args::NTuple{4, FT}) where FT

Create elastic isotropic material for 2D plane strain models.

MatDeforElastIso(mr::Type{DeforModelRed2DStress}, args::NTuple{4, FT}) where FT

Create elastic isotropic material for 2D plane stress models.

MatDeforElastIso(mr::Type{DeforModelRed3D}, args::NTuple{4, FT}) where FT

Create elastic isotropic material for 3D stress models.

MatDeforElastIso(
    mr::Type{MR},
    E::N,
    nu::N,
) where {MR<:AbstractDeforModelRed,N<:Number}

Create isotropic elastic material with default mass density and thermal expansion.

MatDeforElastIso(
    mr::Type{MR},
    mass_density::N,
    E::N,
    nu::N,
    CTE::N,
) where {MR<:AbstractDeforModelRed,N<:Number}

Create an isotropic elastic material providing all material parameters.

Arguments

• mr::Type{MR}: The type of the deformation model.
• mass_density::N: The mass density of the material.
• E::N: The Young's modulus of the material.
• nu::N: The Poisson's ratio of the material.
• CTE::N: The coefficient of thermal expansion of the material.

struct MatDeforElastOrtho{
    MR<:AbstractDeforModelRed,
    FT,
    MTAN<:Function,
    MUPD<:Function,
    MTHS<:Function,
} <: AbstractMatDeforLinearElastic

Linear orthotropic elasticity material.

MatDeforElastOrtho(mr::Type{DeforModelRed2DAxisymm}, args::NTuple{13, FT}) where FT

Create elastic orthotropic material for 2D axially symmetric models.

MatDeforElastOrtho(mr::Type{DeforModelRed2DStrain}, args::NTuple{13, FT}) where FT

Create elastic orthotropic material for 2D plane strain models.

MatDeforElastOrtho(mr::Type{DeforModelRed2DStress}, args::NTuple{13, FT}) where FT

Create elastic orthotropic material for 2D plane stress models.

MatDeforElastOrtho(mr::Type{DeforModelRed3D}, args::NTuple{13, FT}) where FT

Create elastic orthotropic material for 3D models.

MatDeforElastOrtho(
    mr::Type{MR},
    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.

MatDeforElastOrtho(
    mr::Type{MR},
    E::N,
    nu::N,
) where {MR<:AbstractDeforModelRed,N<:Number}

Create elastic orthotropic material which is really isotropic.

Convenience version with only the specification of the elastic properties.

MatDeforElastOrtho(
    mr::Type{MR},
    mass_density::N,
    E1::N,
    E2::N,
    E3::N,
    nu12::N,
    nu13::N,
    nu23::N,
    G12::N,
    G13::N,
    G23::N,
    CTE1::N,
    CTE2::N,
    CTE3::N,
) where {MR<:AbstractDeforModelRed,N<:Number}

Create elastic orthotropic material.

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 mass density, and the elastic and thermal expansion properties.

MatDeforElastOrtho(
    mr::Type{MR},
    E1::N,
    E2::N,
    E3::N,
    nu12::N,
    nu13::N,
    nu23::N,
    G12::N,
    G13::N,
    G23::N,
) where {MR<:AbstractDeforModelRed,N<:Number}

Create elastic orthotropic material.

Convenience version with only the specification of the elastic properties.

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

Base module for operations on interiors of domains to construct system matrices and system vectors for linear deformation models.

FinEtoolsDeforLinear (C) 2017-2024, Petr Krysl

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

Module for operations on interiors of domains to construct system matrices and system vectors for linear deformation models: mean-strain formulation.

For the hexahedron, the references are

@article{https://doi.org/10.1002/nme.4721, author = {Krysl, Petr}, title = {Mean-strain eight-node hexahedron with stabilization by energy sampling}, journal = {International Journal for Numerical Methods in Engineering}, volume = {102}, number = {3-4}, pages = {437-449}, keywords = {anisotropic, elasticity, nearly incompressible, mean-strain hexahedron, uniform strain hexahedron, finite element}, doi = {https://doi.org/10.1002/nme.4721}, url = {https://onlinelibrary.wiley.com/doi/abs/10.1002/nme.4721}, eprint = {https://onlinelibrary.wiley.com/doi/pdf/10.1002/nme.4721}, year = {2015} }

@article{https://doi.org/10.1002/nme.4907, author = {Krysl, P.}, title = {Mean-strain eight-node hexahedron with optimized energy-sampling stabilization for large-strain deformation}, journal = {International Journal for Numerical Methods in Engineering}, volume = {103}, number = {9}, pages = {650-670}, keywords = {anisotropic, hyperelasticity, nearly incompressible, mean-strain hexahedron, uniform strain hexahedron, finite element, shell}, doi = {https://doi.org/10.1002/nme.4907}, url = {https://onlinelibrary.wiley.com/doi/abs/10.1002/nme.4907}, eprint = {https://onlinelibrary.wiley.com/doi/pdf/10.1002/nme.4907}, year = {2015} }

@article{KRYSL201641, title = {Mean-strain 8-node hexahedron with optimized energy-sampling stabilization}, journal = {Finite Elements in Analysis and Design}, volume = {108}, pages = {41-53}, year = {2016}, issn = {0168-874X}, doi = {https://doi.org/10.1016/j.finel.2015.09.008}, url = {https://www.sciencedirect.com/science/article/pii/S0168874X15001432}, author = {P. Krysl}, keywords = {Anisotropic elasticity, Nearly incompressible, Mean-strain hexahedron, Uniform strain hexahedron, Finite element}, abstract = {A method for stabilizing the mean-strain hexahedron was described by Krysl (in IJNME 2014). The technique relied on a sampling of the stabilization energy using the mean-strain quadrature and the full Gaussian integration rule, which was shown to guarantee consistency and stability. The stabilization energy was assumed to be generated by a modified constitutive matrix based on the spectral decomposition. The stabilization required user-selected values of the stabilization parameters. In the present work we eliminate the arbitrariness of the stabilization parameters. We formulate the technique more precisely as an assumed-strain method, and we express the stabilization energy in terms of input parameters of the real material. Finally, we fix the value of the stabilization parameters in a quasi-optimal manner by linking the stabilization to the bending behavior of the hexahedral element. For simplicity the developments are limited to linear elasticity, but with an arbitrarily anisotropic elasticity matrix. The accuracy and convergence characteristics of the present formulations compare favorably with the capabilities of mean-strain and other high-performance hexahedral elements as implemented in Abaqus and with a number of successful hexahedral and shell elements and we demonstrate that the present element performs very well when used with large aspect ratios for thin structures such as plates or shells.} }

For the quadratic tetrahedron, the reference is

@article{https://doi.org/10.1002/nme.5757, author = {Nguyen, P. and Doškář, M. and Pakravan, A. and Krysl, P.}, title = {Modification of the quadratic 10-node tetrahedron for thin structures and stiff materials under large-strain hyperelastic deformation}, journal = {International Journal for Numerical Methods in Engineering}, volume = {114}, number = {6}, pages = {619-636}, keywords = {anisotropic, finite element, hyperelasticity, mean-strain tetrahedron, nearly incompressible, shell}, doi = {https://doi.org/10.1002/nme.5757}, url = {https://onlinelibrary.wiley.com/doi/abs/10.1002/nme.5757}, eprint = {https://onlinelibrary.wiley.com/doi/pdf/10.1002/nme.5757}, abstract = {Summary The concept of energy-sampling stabilization is used to develop a mean-strain quadratic 10-node tetrahedral element for the solution of geometrically nonlinear solid mechanics problems. The development parallels recent developments of a “composite” uniform-strain 10-node tetrahedron for applications to linear elasticity and nonlinear deformation. The technique relies on stabilization by energy sampling with a mean-strain quadrature and proposes to choose the stabilization parameters as a quasi-optimal solution to a set of linear elastic benchmark problems. The accuracy and convergence characteristics of the present formulation are tested on linear and nonlinear benchmarks and compare favorably with the capabilities of other mean-strain and high-performance tetrahedral and hexahedral elements for solids, thin-walled structures (shells), and nearly incompressible structures.}, year = {2018} }

MatDeforModule

Module to support general operations for deformation material models.

Module for operations on interiors of domains to construct system matrices and system vectors for linear deformation models.

Module for algorithms used in linear deformation models.

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.

This formulation is at this point obsolete (replaced with ESNICE).

Module for operations on the damping associated with absorbing boundary conditions (ABC) representation of the effect of infinite extent of inviscid fluid next to the surface.

Module for linear isotropic elastic response.

Basic functionality for linearly elastic materials.

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

Module for linear orthotropic elastic response.

Module for operations on interiors of domains to construct system matrices and system vectors for linear deformation models: incompatible-mode formulation.