MarmotFiniteElementCore

class BoundaryElement

#include <MarmotFiniteElement.h>

Boundary (surface/edge) element for computing distributed load vectors.

Constructed from a parent element shape and a face number, this class sets up the boundary quadrature points and provides methods for computing scalar (pressure) and vectorial (traction) load vectors together with their derivatives with respect to the parent node coordinates.

Public Functions

BoundaryElement(ElementShapes parentShape, int nDim, int parentFaceNumber, const Eigen::VectorXd &parentCoordinates)

Construct a BoundaryElement from a parent shape and face number.

Parameters:

• parentShape – [in] Shape enum of the parent volume element.

• nDim – [in] Number of spatial dimensions.

• parentFaceNumber – [in] Zero-based index of the boundary face on the parent element.

• parentCoordinates – [in] Flat vector of parent nodal coordinates.

Eigen::VectorXd computeScalarLoadVector()

Compute the scalar (pressure) load vector for a unit pressure.

Eigen::MatrixXd computeDScalarLoadVector_dCoordinates()

Compute the derivative of the scalar load vector with respect to nodal coordinates.

Eigen::VectorXd computeSurfaceNormalVectorialLoadVector()

compute the element load vector for a unit vectorial load normal to the surface.

Eigen::VectorXd computeSurfaceNormalVectorialLoadVectorForAxisymmetricElements()

Compute the normal-traction load vector for axisymmetric elements.

Eigen::MatrixXd computeDSurfaceNormalVectorialLoadVector_dCoordinates()

Compute the derivative of the surface-normal load vector with respect to nodal coordinates.

Eigen::VectorXd computeVectorialLoadVector(const Eigen::VectorXd &direction)

compute the element load vector for a unit vectorial load in a given direction.

Eigen::MatrixXd computeDVectorialLoadVector_dCoordinates(const Eigen::VectorXd &direction)

Compute the derivative of the directional load vector with respect to nodal coordinates.

Eigen::VectorXd condenseParentToBoundaryScalar(const Eigen::VectorXd &parentVector)

Extract the boundary-node entries from a parent scalar vector.

void assembleIntoParentScalar(const Eigen::VectorXd &boundaryVector, Eigen::Ref<Eigen::VectorXd> ParentVector)

Assemble a boundary scalar vector into the parent scalar vector.

void assembleIntoParentStiffnessScalar(const Eigen::MatrixXd &KBoundary, Eigen::Ref<Eigen::MatrixXd> KParent)

Assemble a boundary scalar stiffness matrix into the parent stiffness matrix.

Eigen::VectorXd condenseParentToBoundaryVectorial(const Eigen::VectorXd &parentVector)

Extract the boundary-node entries from a parent vectorial vector.

void assembleIntoParentVectorial(const Eigen::VectorXd &boundaryVector, Eigen::Ref<Eigen::VectorXd> ParentVector)

Assemble a boundary vectorial vector into the parent vectorial vector.

void assembleIntoParentStiffnessVectorial(const Eigen::MatrixXd &KBoundary, Eigen::Ref<Eigen::MatrixXd> KParent)

Assemble a boundary vectorial stiffness matrix into the parent stiffness matrix.

Private Members

const int nDim

Number of spatial dimensions.

ElementShapes boundaryShape

Shape of the boundary (face/edge) element.

int nNodes

Number of nodes on the boundary element.

int nParentCoordinates

Total number of parent nodal coordinates.

std::vector<BoundaryElementQuadraturePoint> quadraturePoints

Quadrature points on the boundary.

Eigen::VectorXi mapBoundaryToParentScalar

Index map: boundary scalar DOFs → parent scalar DOFs.

Eigen::VectorXi mapBoundaryToParentVectorial

Index map: boundary vectorial DOFs → parent vectorial DOFs.

Eigen::VectorXd coordinates

Boundary nodal coordinates (extracted from parent).

struct BoundaryElementQuadraturePoint

Internal data for a single quadrature point on the boundary face.

Public Members

double weight

Quadrature weight.

double JxW

Jacobian determinant times quadrature weight.

Eigen::VectorXd xi

Natural coordinates of the quadrature point.

Eigen::VectorXd N

Shape function values at the quadrature point.

Eigen::MatrixXd dNdXi

Shape function natural derivatives.

Eigen::MatrixXd dx_dXi

Tangent vectors on the boundary (dx/dXi).

Eigen::VectorXd areaVector

Outward-normal area vector at the quadrature point.

struct ElementProperties

#include <MarmotElementProperty.h>

Structure to hold element properties.

This structure is used to define properties of a finite element, allowing for flexible element definitions in finite element analysis.

Public Functions

inline ElementProperties(const double *elementProperties, int nElementProperties)

Construct an ElementProperties object.

Parameters:

• elementProperties – [in] Pointer to the array of element property values.

• nElementProperties – [in] Number of element property values.

Public Members

const double *elementProperties

Pointer to the array of element property values.

int nElementProperties

Number of element property values.

class MarmotElement

#include <MarmotElement.h>

Inheritance diagram for MarmotElement:

Abstract base class for finite elements in the Marmot framework.

This class defines the generic interface for finite elements, including methods for state variable handling, geometry, degrees of freedom, initialization, loading, and numerical integration. Concrete element implementations must override the pure virtual functions.

Subclassed by MarmotElementSpatialWrapper

Public Types

enum StateTypes

Types of element state variables used in initialization and output.

Values:

enumerator Sigma11

Normal stress component σ₁₁.

enumerator Sigma22

Normal stress component σ₂₂.

enumerator Sigma33

Normal stress component σ₃₃.

enumerator HydrostaticStress

Hydrostatic (mean) stress.

enumerator GeostaticStress

Geostatic in-situ stress state.

enumerator MarmotMaterialStateVars

Internal material state variables.

enumerator MarmotMaterialInitialization

Trigger for material model initialization.

enumerator HasEigenDeformation

Flag indicating presence of eigen (initial) deformation.

enum DistributedLoadTypes

Types of distributed loads applicable to element boundaries.

Values:

enumerator Pressure

Pressure load (normal to surface)

enumerator SurfaceTorsion

Surface torsional load.

enumerator SurfaceTraction

Surface traction vector.

Public Functions

virtual ~MarmotElement()

Virtual destructor for safe polymorphic cleanup.

virtual int getNumberOfRequiredStateVars() = 0

Returns:

Number of state variables required by the element.

virtual std::vector<std::vector<std::string>> getNodeFields() = 0

Get the nodal field names (e.g. displacement, rotation).

Returns:

A 2D vector of strings representing the fields per node.

virtual std::vector<int> getDofIndicesPermutationPattern() = 0

Get permutation pattern for degrees of freedom.

Returns:

Vector of indices describing the permutation.

virtual int getNNodes() = 0

Returns:

Number of nodes in the element.

virtual int getNSpatialDimensions() = 0

Returns:

Number of spatial dimensions (2D/3D).

virtual int getNDofPerElement() = 0

Returns:

Number of degrees of freedom per element.

virtual std::string getElementShape() = 0

Returns:

String describing the element shape in Ensight Gold notation (e.g. “quad4”, “hexa8”).

virtual void assignStateVars(double *stateVars, int nStateVars) = 0

Assign state variable array to element.

Parameters:

• stateVars – [inout] Pointer to state variable array.

• nStateVars – [in] Number of state variables.

virtual void assignProperty(const ElementProperties &property)

Assign element property set.

Parameters:

property – [in] Element property object containing material, geometry, etc.

virtual void assignProperty(const MarmotMaterialSection &property)

Assign material section property.

Parameters:

property – [in] Material section definition (e.g. cross-sectional data).

virtual void assignNodeCoordinates(const double *coordinates) = 0

Assign nodal coordinates to element.

Parameters:

coordinates – [in] Pointer to array of nodal coordinates.

virtual void initializeYourself() = 0

Initialize element state and internal variables.

virtual void setInitialConditions(StateTypes state, const double *values) = 0

Apply initial conditions to the element.

Parameters:

• state – [in] State type to be set.

• values – [in] Array of initial values.

virtual void computeYourself(const double *QTotal, const double *dQ, double *Pint, double *K, const double *time, double dT, double &pNewdT) = 0

Perform element computations (stiffness, residual, etc.).

Parameters:

• QTotal – [in] Total dof vector.

• dQ – [in] Incremental dof vector.

• Pint – [out] Internal force vector.

• K – [out] Stiffness matrix.

• time – [in] Current time.

• dT – [in] Time step size.

• pNewdT – [out] Suggested new time step size.

inline virtual void computeYourselfExplicit(const double *QTotal, const double *dQ, double *Pint, const double *time, double dT, double &pNewdT)

Perform element computations for explicit time integration.

Note

Default implementation throws an exception.

Parameters:

• QTotal – [in] Total dof vector.

• dQ – [in] Incremental dof vector.

• Pint – [out] Internal force vector.

• time – [in] Current time.

• dT – [in] Time step size.

• pNewdT – [out] Suggested new time step size.

virtual void computeDistributedLoad(DistributedLoadTypes loadType, double *Pext, double *K, int elementFace, const double *load, const double *QTotal, const double *time, double dT) = 0

Compute contribution from distributed surface loads.

Parameters:

• loadType – [in] Type of load.

• Pext – [out] External load vector.

• K – [out] Stiffness matrix.

• elementFace – [in] Index of element face.

• load – [in] Applied load values.

• QTotal – [in] Total dof vector.

• time – [in] Current time.

• dT – [in] Time step size.

virtual void computeBodyForce(double *Pext, double *K, const double *load, const double *QTotal, const double *time, double dT) = 0

Compute contribution from body forces.

Parameters:

• Pext – [out] External load vector.

• K – [out] Stiffness matrix.

• load – [in] Body force vector.

• QTotal – [in] Total displacement vector.

• time – [in] Current time.

• dT – [in] Time step size.

inline virtual void computeLumpedInertia(double *I)

Compute lumped inertia matrix.

Note

Default implementation throws an exception.

Parameters:

I – [out] Inertia matrix.

inline virtual void computeConsistentInertia(double *I)

Compute consistent inertia matrix.

Note

Default implementation throws an exception.

Parameters:

I – [out] Inertia matrix.

inline virtual void computeCriticalTimeStepForExplicitDynamics(double &criticalTimeStep, const double *QTotal)

Compute critical time step for explicit dynamics.

Note

Default implementation throws an exception.

Parameters:

• criticalTimeStep – [out] Suggested critical time step size.

• QTotal – [in] Total dof vector.

inline virtual void computeInternalEnergy(double &internalEnergy)

Compute internal energy of the element.

Note

Default implementation throws an exception.

Parameters:

internalEnergy – [out] Computed internal energy.

virtual StateView getStateView(const std::string &stateName, int quadraturePoint) = 0

Access element state at a quadrature point.

Parameters:

• stateName – [in] Name of the state variable.

• quadraturePoint – [in] Index of quadrature point.

Returns:

View into state variable.

virtual std::vector<double> getCoordinatesAtCenter() = 0

Get coordinates of element center.

Returns:

Vector of coordinates at element centroid.

virtual std::vector<std::vector<double>> getCoordinatesAtQuadraturePoints() = 0

Get coordinates of quadrature points.

Returns:

2D vector of coordinates at quadrature points.

virtual int getNumberOfQuadraturePoints() = 0

Returns:

Number of quadrature points used by the element.

class MarmotElementFactory

#include <MarmotElementFactory.h>

Factory class for creating element instances. This class provides a mechanism to register elements by their code and name, and to create element instances based on their properties.

Public Types

using elementFactoryFunction = MarmotElement *(*)(int elementNumber)

Factory function pointer type: takes an element number and returns a new MarmotElement.

Public Functions

MarmotElementFactory() = delete

Public Static Functions

static inline MarmotElement *createElement(const std::string &elementName, int elementNumber)

Create an element instance based on its name and number.

Parameters:

• elementName – [in] Registered name of the element type.

• elementNumber – [in] Unique identifier for the element instance.

Throws:

std::invalid_argument – if elementName is not registered.

Returns:

Pointer to the created MarmotElement instance.

static inline bool registerElement(const std::string &elementName, elementFactoryFunction factoryFunction)

Register an element with its name.

Parameters:

• elementName – [in] Name of the element type to register.

• factoryFunction – [in] Factory function pointer that creates the element.

Returns:

True if registration was successful.

Private Types

using ElementFactoryMap = std::unordered_map<std::string, elementFactoryFunction>

Private Static Functions

static ElementFactoryMap &elementFactoryFunctionByName()

class MarmotElementSpatialWrapper : public MarmotElement

#include <MarmotFiniteElementSpatialWrapper.h>

Inheritance diagram for MarmotElementSpatialWrapper:

Collaboration diagram for MarmotElementSpatialWrapper:

Wrapper that embeds a lower-dimensional child element (e.g. a truss) into a higher-dimensional ambient space (2-D or 3-D).

The projection transformation is constructed automatically from the supplied nodal coordinates. The child element is created via a user-provided factory functor so that the wrapper remains independent of the concrete child type.

Public Functions

MarmotElementSpatialWrapper(int nDim, int nChildDim, int nNodes, int sizeRhsChild, const int rhsIndicesToBeWrapped_[], int nRhsIndicesToBeWrapped, std::unique_ptr<MarmotElement> childElement)

Construct the spatial wrapper.

Parameters:

• nDim – [in] Number of spatial dimensions of the ambient space.

• nChildDim – [in] Number of spatial dimensions of the child element.

• nNodes – [in] Number of nodes.

• sizeRhsChild – [in] Size of the child element’s right-hand-side vector.

• rhsIndicesToBeWrapped_ – [in] Array of child-RHS indices to be projected.

• nRhsIndicesToBeWrapped – [in] Length of rhsIndicesToBeWrapped_.

• childElement – [in] Owning pointer to the child element instance.

virtual int getNumberOfRequiredStateVars()

Returns:

Number of state variables required by the element.

virtual std::vector<std::vector<std::string>> getNodeFields()

Get the nodal field names (e.g. displacement, rotation).

Returns:

A 2D vector of strings representing the fields per node.

virtual std::vector<int> getDofIndicesPermutationPattern()

Get permutation pattern for degrees of freedom.

Returns:

Vector of indices describing the permutation.

virtual int getNNodes()

Returns:

Number of nodes in the element.

virtual int getNSpatialDimensions()

Returns:

Number of spatial dimensions (2D/3D).

virtual int getNDofPerElement()

Returns:

Number of degrees of freedom per element.

virtual std::string getElementShape()

Returns:

String describing the element shape in Ensight Gold notation (e.g. “quad4”, “hexa8”).

virtual void assignStateVars(double *stateVars, int nStateVars)

Assign state variable array to element.

Parameters:

• stateVars – [inout] Pointer to state variable array.

• nStateVars – [in] Number of state variables.

virtual void assignProperty(const ElementProperties &property)

Assign element property set.

Parameters:

property – [in] Element property object containing material, geometry, etc.

virtual void assignProperty(const MarmotMaterialSection &property)

Assign material section property.

Parameters:

property – [in] Material section definition (e.g. cross-sectional data).

virtual void assignNodeCoordinates(const double *coordinates)

Assign nodal coordinates to element.

Parameters:

coordinates – [in] Pointer to array of nodal coordinates.

virtual void initializeYourself()

Initialize element state and internal variables.

virtual void computeYourself(const double *QTotal, const double *dQ, double *Pe, double *Ke, const double *time, double dT, double &pNewdT)

Perform element computations with coordinate transformation.

Parameters:

• QTotal – [in] Total dof vector in the ambient (parent) space.

• dQ – [in] Incremental dof vector in the ambient space.

• Pe – [out] Internal force vector in the ambient space.

• Ke – [out] Stiffness matrix in the ambient space.

• time – [in] Current time.

• dT – [in] Time step size.

• pNewdT – [out] Suggested new time step size.

virtual void setInitialConditions(StateTypes state, const double *values)

Apply initial conditions to the element.

Parameters:

• state – [in] State type to be set.

• values – [in] Array of initial values.

virtual void computeDistributedLoad(DistributedLoadTypes loadType, double *P, double *K, int elementFace, const double *load, const double *QTotal, const double *time, double dT)

Compute contribution from distributed surface loads with coordinate transformation.

Parameters:

• loadType – [in] Type of distributed load.

• P – [out] External load vector in the ambient space.

• K – [out] Load stiffness matrix in the ambient space.

• elementFace – [in] Index of element face.

• load – [in] Applied load values.

• QTotal – [in] Total dof vector.

• time – [in] Current time.

• dT – [in] Time step size.

virtual void computeBodyForce(double *P, double *K, const double *load, const double *QTotal, const double *time, double dT)

Compute body force contribution with coordinate transformation.

Parameters:

• P – [out] External load vector in the ambient space.

• K – [out] Load stiffness matrix in the ambient space.

• load – [in] Applied body force values.

• QTotal – [in] Total dof vector.

• time – [in] Current time.

• dT – [in] Time step size.

virtual StateView getStateView(const std::string &stateName, int quadraturePoint)

Access element state at a quadrature point.

Parameters:

• stateName – [in] Name of the state variable.

• quadraturePoint – [in] Index of quadrature point.

Returns:

View into state variable.

virtual std::vector<double> getCoordinatesAtCenter()

Get coordinates of element center.

Returns:

Vector of coordinates at element centroid.

virtual std::vector<std::vector<double>> getCoordinatesAtQuadraturePoints()

Get coordinates of quadrature points.

Returns:

2D vector of coordinates at quadrature points.

virtual int getNumberOfQuadraturePoints()

Returns:

Number of quadrature points used by the element.

Public Members

const int nDim

Number of spatial dimensions of the ambient space.

const int nDimChild

Number of spatial dimensions of the child element.

const int nNodes

Number of nodes shared by parent and child element.

const int nRhsChild

Size of the child element’s right-hand-side vector.

const Eigen::Map<const Eigen::VectorXi> rhsIndicesToBeProjected

Indices in the child RHS vector that need projection.

const int projectedSize

Number of projected DOFs (child-element dimension).

const int unprojectedSize

Number of unprojected DOFs (ambient-space dimension).

std::unique_ptr<MarmotElement> childElement

Owned child element instance.

Eigen::MatrixXd T

Coordinate transformation matrix from child to parent space.

Eigen::MatrixXd P

Projection matrix mapping parent DOFs to child DOFs.

Eigen::MatrixXd projectedCoordinates

Nodal coordinates expressed in the child (local) frame.

template<int nDim, int nNodes>
class MarmotGeometryElement

#include <MarmotGeometryElement.h>

Statically-sized geometry base class for all isoparametric Marmot elements.

Provides shape functions N, their natural-coordinate derivatives dNdXi, the B-operator B, and the element Jacobian. The element shape is determined automatically from the template parameters.

Concrete MarmotElement classes inherit from this class to access the geometric infrastructure without code duplication.

Template Parameters:

• nDim – Number of spatial dimensions (1, 2 or 3).

• nNodes – Number of element nodes.

Public Types

typedef Eigen::Matrix<double, nDim, 1> XiSized

Natural-coordinate vector.

typedef Eigen::Matrix<double, nDim * nNodes, 1> CoordinateVector

Flat nodal-coordinate vector.

typedef Eigen::Matrix<double, nDim, nDim> JacobianSized

Square Jacobian matrix.

typedef Eigen::Matrix<double, 1, nNodes> NSized

Row vector of shape function values.

typedef Eigen::Matrix<double, nDim, nNodes * nDim> NBSized

Expanded interpolation operator N_B.

typedef Eigen::Matrix<double, nDim, nNodes> dNdXiSized

Matrix of shape function natural derivatives.

typedef Eigen::Matrix<double, voigtSize, nNodes * nDim> BSized

Standard B-operator matrix.

typedef Eigen::Matrix<double, 4, nNodes * nDim> BSizedAxisymmetric

Axisymmetric B-operator matrix (4 Voigt components).

Public Functions

inline MarmotGeometryElement()

Default constructor. Initialises the coordinate map to nullptr and deduces the element shape.

inline std::string getElementShape() const

Returns an Ensight Gold shape string (e.g. quad4, hexa8) for this element.

inline void assignNodeCoordinates(const double *coords)

Maps the externally-owned coordinate array into the coordinates member.

Parameters:

coords – [in] Pointer to the flat nodal-coordinate array.

NSized N(const XiSized &xi) const

Evaluate the shape function row vector at natural coordinates xi.

dNdXiSized dNdXi(const XiSized &xi) const

Evaluate the matrix of shape function natural derivatives at xi.

BSized B(const dNdXiSized &dNdX) const

Compute the standard B-operator from physical derivatives dNdX.

BSizedAxisymmetric B_axisymmetric(const dNdXiSized &dNdX, const NSized &N, const XiSized &x_gauss) const

Compute the axisymmetric B-operator (4 components).

BSized B_bar(const dNdXiSized &dNdX, const dNdXiSized &dNdX0) const

Compute the B̄-operator using the B-bar selective-reduced-integration method.

BSized BGreen(const dNdXiSized &dNdX, const JacobianSized &F) const

Compute the Green–Lagrange strain operator for deformation gradient F.

inline NBSized NB(const NSized &N) const

Compute the expanded interpolation operator N_B from shape function values N.

inline JacobianSized Jacobian(const dNdXiSized &dNdXi) const

Compute the element Jacobian from natural derivatives dNdXi and the stored nodal coordinates.

inline dNdXiSized dNdX(const dNdXiSized &dNdXi, const JacobianSized &JacobianInverse) const

Compute physical derivatives dN/dX from natural derivatives and the inverse Jacobian.

Parameters:

• dNdXi – [in] Natural-coordinate derivatives.

• JacobianInverse – [in] Inverse of the element Jacobian.

inline JacobianSized F(const dNdXiSized &dNdX, const CoordinateVector &Q) const

Compute the deformation gradient \(\mathbf{F}\) from physical derivatives and displacements Q.

Parameters:

• dNdX – [in] Physical shape function derivatives.

• Q – [in] Element displacement vector.

Public Members

Eigen::Map<const CoordinateVector> coordinates

Map into the externally-owned nodal-coordinate array.

const Marmot::FiniteElement::ElementShapes shape

Element shape determined from nDim and nNodes.

Public Static Attributes

static Marmot::ContinuumMechanics::VoigtNotation::VoigtSize voigtSize = Marmot::ContinuumMechanics::VoigtNotation::voigtSizeFromDimension(nDim)

Voigt notation size for nDim spatial dimensions.

struct MarmotMaterialSection

#include <MarmotElementProperty.h>

Structure to hold material section properties.

This structure is used to define a material section with its code and properties, allowing for flexible material definitions in finite element analysis.

Public Functions

inline MarmotMaterialSection(const std::string materialName, const double *materialProperties, int nMaterialProperties)

Construct a MarmotMaterialSection.

Parameters:

• materialName – [in] Name identifying the material model.

• materialProperties – [in] Pointer to the array of material property values.

• nMaterialProperties – [in] Number of material property values.

Public Members

const std::string materialName

Name identifying the material model.

const double *materialProperties

Pointer to the array of material property values.

int nMaterialProperties

Number of material property values.

struct QuadraturePointInfo

#include <MarmotFiniteElement.h>

Natural coordinates and weight for one Gauss quadrature point.

Public Members

Eigen::VectorXd xi

Natural coordinates of the quadrature point.

double weight

Quadrature weight.

namespace Marmot

namespace FiniteElement

Utilities for constructing DOF-layout structures in finite element assemblies.

Enums

enum ElementShapes

Supported isoparametric element shapes.

Values:

enumerator Bar2

1-D 2-node bar

enumerator Bar3

1-D 3-node bar

enumerator Quad4

2-D 4-node quadrilateral

enumerator Quad8

2-D 8-node serendipity quadrilateral

enumerator Quad9

2-D 9-node quadrilateral

enumerator Quad16

2-D 16-node quadrilateral

enumerator Tetra4

3-D 4-node tetrahedron

enumerator Tetra10

3-D 10-node tetrahedron

enumerator Hexa8

3-D 8-node hexahedron

enumerator Hexa20

3-D 20-node serendipity hexahedron

enumerator Hexa27

3-D 27-node hexahedron

enumerator Hexa64

3-D 64-node hexahedron

Functions

const std::vector<std::vector<std::string>> makeNodeFieldLayout(const std::map<std::string, std::pair<int, int>> &fieldSizes)

Builds a node-field layout from a map of field names to their DOF dimensions.

Parameters:

fieldSizes – Map from field name to a pair (nodesPerElement, dofsPerNode).

Returns:

A 2-D vector where each row corresponds to a node and each entry is a field name.

std::vector<int> makeBlockedLayoutPermutationPattern(const std::vector<std::vector<std::string>> &nodeFields, const std::map<std::string, std::pair<int, int>> &fieldSizes)

Computes the DOF permutation pattern for a blocked (field-major) layout.

Parameters:

• nodeFields – Node-field layout as returned by makeNodeFieldLayout.

• fieldSizes – Map from field name to a pair (nodesPerElement, dofsPerNode).

Returns:

Integer permutation vector that reorders DOFs from node-major to field-major order.

ElementShapes getElementShapeByMetric(int nDim, int nNodes)

Determine the element shape from spatial dimension and node count.

Parameters:

• nDim – [in] Number of spatial dimensions.

• nNodes – [in] Number of element nodes.

Returns:

Matching ElementShapes enumerator.

Eigen::MatrixXd NB(const Eigen::VectorXd &N, const int nDoFPerNode)

Compute the expanded interpolation operator N_B (dynamic version).

Parameters:

• N – [in] Shape function row vector.

• nDoFPerNode – [in] Number of degrees of freedom per node.

Returns:

Expanded matrix of size nDoFPerNode × (nNodes * nDoFPerNode).

template<int nDim, int nNodes>
Eigen::Matrix<double, nDim, nDim * nNodes> NB(const Eigen::Matrix<double, 1, nNodes> &N)

Compute the expanded interpolation operator N_B (compile-time size version).

Template Parameters:

• nDim – Number of spatial dimensions.

• nNodes – Number of element nodes.

Parameters:

N – [in] Shape function row vector.

Returns:

Expanded matrix of size nDim × (nDim * nNodes).

Eigen::MatrixXd Jacobian(const Eigen::MatrixXd &dN_dXi, const Eigen::VectorXd &coordinates)

Compute the element Jacobian matrix (dynamic version).

Parameters:

• dN_dXi – [in] Matrix of shape function natural derivatives.

• coordinates – [in] Flat vector of nodal coordinates.

Returns:

Jacobian matrix.

template<int nDim, int nNodes>
Eigen::Matrix<double, nDim, nDim> Jacobian(const Eigen::Matrix<double, nDim, nNodes> &dNdXi, const Eigen::Matrix<double, nDim * nNodes, 1> &coordinates)

Compute the element Jacobian matrix (compile-time size version).

Template Parameters:

• nDim – Number of spatial dimensions.

• nNodes – Number of element nodes.

Parameters:

• dNdXi – [in] Matrix of shape function natural derivatives.

• coordinates – [in] Flat nodal-coordinate vector.

Returns:

Square Jacobian matrix of size nDim × nDim.

Eigen::VectorXi expandNodeIndicesToCoordinateIndices(const Eigen::VectorXi &nodeIndices, int nDim)

Expand scalar node indices to coordinate (DOF) indices.

Parameters:

• nodeIndices – [in] Vector of node indices.

• nDim – [in] Number of spatial dimensions (DOFs per node).

Returns:

Vector of coordinate indices.

namespace EAS

Enhanced Assumed Strain (EAS) element enrichment utilities.

Functions and enumerations for constructing the EAS interpolation matrices used in incompatible-mode and enhanced assumed strain finite element formulations (de Borst, Simo & Rifai variants).

Enums

enum EASType

Supported EAS enrichment types.

Values:

enumerator DeBorstEAS2

De Borst 2-parameter EAS.

enumerator DeBorstEAS2_P2

De Borst 2-parameter EAS, variant P2.

enumerator EAS3

3-parameter EAS

enumerator DeBorstEAS6b

De Borst 6-parameter EAS, variant b.

enumerator DeBorstEAS9

De Borst 9-parameter EAS.

enumerator SimoRifaiEAS5

Simo–Rifai 5-parameter EAS.

enumerator SimoRifaiEAS4

Simo–Rifai 4-parameter EAS.

Functions

Eigen::MatrixXd F(const Eigen::MatrixXd &J)

Computes the EAS transformation matrix from the element Jacobian.

Parameters:

J – Element Jacobian matrix at the reference point.

Returns:

Transformation matrix \(\mathbf{F}\) for mapping EAS modes.

Eigen::MatrixXd EASInterpolation(EASType type, const Eigen::VectorXd &xi)

Evaluates the EAS interpolation matrix at a given natural coordinate.

Parameters:

• type – EAS enrichment type.

• xi – Natural coordinates of the integration point.

Returns:

EAS interpolation matrix \(\mathbf{M}\).

namespace Quadrature

Enums

enum IntegrationTypes

Gauss quadrature integration order options.

Values:

enumerator FullIntegration

Full (exact) Gauss integration.

enumerator ReducedIntegration

Reduced integration (one order lower).

Functions

const std::vector<QuadraturePointInfo> &getGaussPointInfo(Marmot::FiniteElement::ElementShapes shape, IntegrationTypes integrationType)

Return the predefined Gauss point list for a given element shape and integration type.

Parameters:

• shape – [in] Element shape enumerator.

• integrationType – [in] Full or reduced integration.

Returns:

Const reference to the corresponding vector of Marmot::FiniteElement::Quadrature::QuadraturePointInfo entries.

int getNumGaussPoints(Marmot::FiniteElement::ElementShapes shape, IntegrationTypes integrationType)

Return the number of Gauss points for a given element shape and integration type.

Parameters:

• shape – [in] Element shape enumerator.

• integrationType – [in] Full or reduced integration.

Returns:

Number of quadrature points.

Variables

double gp2 = 0.577350269189625764509

Gauss point abscissa for 2-point rule: \(1/\sqrt{3}\).

double gp3 = 0.774596669241483

Gauss point abscissa for 3-point rule: \(\sqrt{3/5}\).

namespace Spatial1D

Variables

int nDim = 1

Number of spatial dimensions for 1-D quadrature.

const std::vector<QuadraturePointInfo> gaussPointList1 = {{(Eigen::VectorXd(1) << 0).finished(), 2.0}}

1-point Gauss rule for 1-D elements.

const std::vector<QuadraturePointInfo> gaussPointList2 = {{(Eigen::VectorXd(1) << -gp2).finished(), 1.0}, {(Eigen::VectorXd(1) << +gp2).finished(), 1.0}}

2-point Gauss rule for 1-D elements.

const std::vector<QuadraturePointInfo> gaussPointList3 = {{(Eigen::VectorXd(1) << -gp3).finished(), 5. / 9}, {(Eigen::VectorXd(1) << 0.).finished(), 8. / 9}, {(Eigen::VectorXd(1) << +gp3).finished(), 5. / 9}}

3-point Gauss rule for 1-D elements.

namespace Spatial2D

Functions

void modifyCharElemLengthAbaqusLike(double &charElemLength, int intPoint)

Scale the characteristic element length in an ABAQUS-like manner.

Parameters:

• charElemLength – [inout] Characteristic element length to be modified.

• intPoint – [in] Integration point index.

Variables

int nDim = 2

Number of spatial dimensions for 2-D quadrature.

const std::vector<QuadraturePointInfo> gaussPointList1x1 = {{Eigen::Vector2d::Zero(), 4.}}

1×1 Gauss rule for 2-D quadrilateral elements.

const std::vector<QuadraturePointInfo> gaussPointList2x2 = {{(Eigen::Vector2d() << +gp2, +gp2).finished(), 1.0}, {(Eigen::Vector2d() << -gp2, +gp2).finished(), 1.0}, {(Eigen::Vector2d() << -gp2, -gp2).finished(), 1.0}, {(Eigen::Vector2d() << +gp2, -gp2).finished(), 1.0}}

2×2 Gauss rule for 2-D quadrilateral elements.

const std::vector<QuadraturePointInfo> gaussPointList3x3 = {{(Eigen::Vector2d() << 0, 0.).finished(), 64. / 81}, {(Eigen::Vector2d() << -gp3, -gp3).finished(), 25. / 81}, {(Eigen::Vector2d() << +gp3, -gp3).finished(), 25. / 81}, {(Eigen::Vector2d() << +gp3, +gp3).finished(), 25. / 81}, {(Eigen::Vector2d() << -gp3, +gp3).finished(), 25. / 81}, {(Eigen::Vector2d() << 0, -gp3).finished(), 40. / 81}, {(Eigen::Vector2d() << gp3, 0.).finished(), 40. / 81}, {(Eigen::Vector2d() << 0, +gp3).finished(), 40. / 81}, {(Eigen::Vector2d() << -gp3, 0.).finished(), 40. / 81},}

3×3 Gauss rule for 2-D quadrilateral elements.

namespace Spatial3D

Variables

int nDim = 3

Number of spatial dimensions for 3-D quadrature.

const std::vector<QuadraturePointInfo> gaussPointList1x1x1 = {{Eigen::Vector3d::Zero(), 8.0}}

1×1×1 Gauss rule for 3-D hexahedral elements.

const std::vector<QuadraturePointInfo> gaussPointListTetra4 = {{(Eigen::Vector3d() << 1. / 4, 1. / 4, 1. / 4).finished(), 1. / 6}}

1-point rule for Tetra4 elements.

const std::vector<QuadraturePointInfo> gaussPointListTetra10 = {{(Eigen::Vector3d() << (5 - std::sqrt(5)) / 20, (5 - std::sqrt(5)) / 20, (5 - std::sqrt(5)) / 20).finished(), 1. / 24}, {(Eigen::Vector3d() << (5 - std::sqrt(5)) / 20, (5 - std::sqrt(5)) / 20, (5 + 3 * std::sqrt(5)) / 20).finished(), 1. / 24}, {(Eigen::Vector3d() << (5 - std::sqrt(5)) / 20, (5 + 3 * std::sqrt(5)) / 20, (5 - std::sqrt(5)) / 20).finished(), 1. / 24}, {(Eigen::Vector3d() << (5 + 3 * std::sqrt(5)) / 20, (5 - std::sqrt(5)) / 20, (5 - std::sqrt(5)) / 20).finished(), 1. / 24},}

4-point rule for Tetra10 elements.

const std::vector<QuadraturePointInfo> gaussPointList2x2x2 = {{(Eigen::Vector3d() << -gp2, -gp2, -gp2).finished(), 1.0}, {(Eigen::Vector3d() << +gp2, -gp2, -gp2).finished(), 1.0}, {(Eigen::Vector3d() << +gp2, +gp2, -gp2).finished(), 1.0}, {(Eigen::Vector3d() << -gp2, +gp2, -gp2).finished(), 1.0}, {(Eigen::Vector3d() << -gp2, -gp2, +gp2).finished(), 1.0}, {(Eigen::Vector3d() << +gp2, -gp2, +gp2).finished(), 1.0}, {(Eigen::Vector3d() << +gp2, +gp2, +gp2).finished(), 1.0}, {(Eigen::Vector3d() << -gp2, +gp2, +gp2).finished(), 1.0},}

2×2×2 Gauss rule for 3-D hexahedral elements.

const std::vector<QuadraturePointInfo> gaussPointList3x3x3

3×3×3 Gauss rule for 3-D hexahedral elements.

namespace Spatial1D

namespace Bar2

Typedefs

using NSized = Eigen::Matrix<double, 1, nNodes>

Row vector of shape function values.

using dNdXiSized = Eigen::Matrix<double, 1, nNodes>

Row vector of shape function natural derivatives.

Functions

NSized N(double xi)

Evaluate Bar2 shape functions at natural coordinate xi.

dNdXiSized dNdXi(double xi)

Evaluate Bar2 shape function derivatives at natural coordinate xi.

Variables

int nNodes = 2

Number of nodes for a Bar2 element.

namespace Bar3

Typedefs

using NSized = Eigen::Matrix<double, 1, nNodes>

Row vector of shape function values.

using dNdXiSized = Eigen::Matrix<double, 1, nNodes>

Row vector of shape function natural derivatives.

Functions

NSized N(double xi)

Evaluate Bar3 shape functions at natural coordinate xi.

dNdXiSized dNdXi(double xi)

Evaluate Bar3 shape function derivatives at natural coordinate xi.

Variables

int nNodes = 3

Number of nodes for a Bar3 element.

namespace Spatial2D

Functions

template<int nNodes>
Eigen::Matrix<double, voigtSize, nNodes * nDim> B(const Eigen::Matrix<double, nDim, nNodes> &dNdX)

Compute the 2-D linear B-operator from physical derivatives.

Template Parameters:

nNodes – Number of element nodes.

Parameters:

dNdX – [in] Physical shape function derivatives (2 × nNodes).

Returns:

B-operator matrix of size 3 × (2 * nNodes).

template<int nNodes>
Eigen::Matrix<double, voigtSize, nNodes * nDim> BGreen(const Eigen::Matrix<double, nDim, nNodes> &dNdX, const Eigen::Matrix2d &F)

Compute the 2-D Green–Lagrange B-operator.

Template Parameters:

nNodes – Number of element nodes.

Parameters:

• dNdX – [in] Physical shape function derivatives (2 × nNodes).

• F – [in] 2×2 deformation gradient.

Returns:

Green–Lagrange B-operator of size 3 × (2 * nNodes).

Variables

int nDim = 2

Number of spatial dimensions for 2-D elements.

int voigtSize = 3

Voigt vector size for 2-D plane elements (σ₁₁, σ₂₂, σ₁₂).

namespace axisymmetric

Functions

template<int nNodes>
Eigen::Matrix<double, voigtSize, nNodes * nDim> B(const Eigen::Matrix<double, nDim, nNodes> &dNdX, const Eigen::Matrix<double, 1, nNodes> &N, const Eigen::Matrix<double, nDim, 1> &x_gauss)

Compute the axisymmetric B-operator from physical derivatives.

Template Parameters:

nNodes – Number of element nodes.

Parameters:

• dNdX – [in] Physical shape function derivatives (2 × nNodes).

• N – [in] Shape function values (1 × nNodes).

• x_gauss – [in] Physical coordinates of the Gauss point (r, z).

Returns:

B-operator matrix of size 4 × (2 * nNodes).

Variables

int voigtSize = 4

Voigt vector size for axisymmetric elements (σ_rr, σ_zz, σ_θθ, σ_rz).

namespace Quad4

Typedefs

using CoordinateSized = Eigen::Matrix<double, nNodes * nDim, 1>

Flat vector of nodal coordinates.

using NSized = Eigen::Matrix<double, 1, nNodes>

Row vector of shape function values.

using dNdXiSized = Eigen::Matrix<double, nDim, nNodes>

Matrix of shape function natural derivatives.

Functions

NSized N(const Eigen::Vector2d &xi)

Evaluate Quad4 shape functions at natural coordinates xi.

dNdXiSized dNdXi(const Eigen::Vector2d &xi)

Evaluate Quad4 shape function natural derivatives at xi.

Eigen::Vector2i getBoundaryElementIndices(int faceID)

Return the local node indices for boundary face faceID.

Variables

int nNodes = 4

Number of nodes for a Quad4 element.

namespace Quad8

Typedefs

using CoordinateSized = Eigen::Matrix<double, nNodes * nDim, 1>

Flat vector of nodal coordinates.

using NSized = Eigen::Matrix<double, 1, nNodes>

Row vector of shape function values.

using dNdXiSized = Eigen::Matrix<double, nDim, nNodes>

Matrix of shape function natural derivatives.

Functions

NSized N(const Eigen::Vector2d &xi)

Evaluate Quad8 shape functions at natural coordinates xi.

dNdXiSized dNdXi(const Eigen::Vector2d &xi)

Evaluate Quad8 shape function natural derivatives at xi.

Eigen::Vector3i getBoundaryElementIndices(int faceID)

Return the local node indices for boundary face faceID.

Variables

int nNodes = 8

Number of nodes for a Quad8 element.

namespace Spatial3D

Functions

template<int nNodes>
Eigen::Matrix<double, voigtSize, nNodes * nDim> B(const Eigen::Matrix<double, nDim, nNodes> &dNdX)

Compute the 3-D linear B-operator from physical derivatives.

Template Parameters:

nNodes – Number of element nodes.

Parameters:

dNdX – [in] Physical shape function derivatives (3 × nNodes).

Returns:

B-operator matrix of size 6 × (3 * nNodes).

template<int nNodes>
Eigen::Matrix<double, voigtSize, nNodes * nDim> B_bar(const Eigen::Matrix<double, nDim, nNodes> &dNdX, const Eigen::Matrix<double, nDim, nNodes> &dNdX0)

Compute the 3-D B̄-operator using the B-bar method (Hughes, 1980).

Template Parameters:

nNodes – Number of element nodes.

Parameters:

• dNdX – [in] Physical shape function derivatives at the integration point.

• dNdX0 – [in] Physical shape function derivatives at the element centre.

Returns:

Modified B-operator matrix of size 6 × (3 * nNodes).

template<int nNodes>
Eigen::Matrix<double, voigtSize, nNodes * nDim> BGreen(const Eigen::Matrix<double, nDim, nNodes> &dNdX, const Eigen::Matrix3d &F)

Compute the 3-D Green–Lagrange B-operator.

Template Parameters:

nNodes – Number of element nodes.

Parameters:

• dNdX – [in] Physical shape function derivatives (3 × nNodes).

• F – [in] 3×3 deformation gradient.

Returns:

Green–Lagrange B-operator of size 6 × (3 * nNodes).

Variables

int nDim = 3

Number of spatial dimensions for 3-D elements.

int voigtSize = 6

Voigt vector size for 3-D elements (σ₁₁, σ₂₂, σ₃₃, σ₁₂, σ₁₃, σ₂₃).

namespace Hexa20

Typedefs

using CoordinateSized = Eigen::Matrix<double, nNodes * nDim, 1>

Flat vector of nodal coordinates.

using NSized = Eigen::Matrix<double, 1, nNodes>

Row vector of shape function values.

using dNdXiSized = Eigen::Matrix<double, nDim, nNodes>

Matrix of shape function natural derivatives.

Functions

NSized N(const Eigen::Vector3d &xi)

Evaluate Hexa20 shape functions at natural coordinates xi.

dNdXiSized dNdXi(const Eigen::Vector3d &xi)

Evaluate Hexa20 shape function natural derivatives at xi.

Marmot::Vector8i getBoundaryElementIndices(int faceID)

Return the local node indices for boundary face faceID.

Variables

int nNodes = 20

Number of nodes for a Hexa20 element.

namespace Hexa8

Typedefs

using CoordinateSized = Eigen::Matrix<double, nNodes * nDim, 1>

Flat vector of nodal coordinates.

using NSized = Eigen::Matrix<double, 1, nNodes>

Row vector of shape function values.

using dNdXiSized = Eigen::Matrix<double, nDim, nNodes>

Matrix of shape function natural derivatives.

Functions

NSized N(const Eigen::Vector3d &xi)

Evaluate Hexa8 shape functions at natural coordinates xi.

dNdXiSized dNdXi(const Eigen::Vector3d &xi)

Evaluate Hexa8 shape function natural derivatives at xi.

Eigen::Vector4i getBoundaryElementIndices(int faceID)

Return the local node indices for boundary face faceID.

Variables

int nNodes = 8

Number of nodes for a Hexa8 element.

namespace Tetra10

Typedefs

using CoordinateSized = Eigen::Matrix<double, nNodes * nDim, 1>

Flat vector of nodal coordinates.

using NSized = Eigen::Matrix<double, 1, nNodes>

Row vector of shape function values.

using dNdXiSized = Eigen::Matrix<double, nDim, nNodes>

Matrix of shape function natural derivatives.

Functions

NSized N(const Eigen::Vector3d &xi)

Evaluate Tetra10 shape functions at natural coordinates xi.

dNdXiSized dNdXi(const Eigen::Vector3d &xi)

Evaluate Tetra10 shape function natural derivatives at xi.

Eigen::Vector3i getBoundaryElementIndices(int faceID)

Return the local node indices for boundary face faceID.

Variables

int nNodes = 10

Number of nodes for a Tetra10 element.

namespace Tetra4

Typedefs

using CoordinateSized = Eigen::Matrix<double, nNodes * nDim, 1>

Flat vector of nodal coordinates.

using NSized = Eigen::Matrix<double, 1, nNodes>

Row vector of shape function values.

using dNdXiSized = Eigen::Matrix<double, nDim, nNodes>

Matrix of shape function natural derivatives.

Functions

NSized N(const Eigen::Vector3d &xi)

Evaluate Tetra4 shape functions at natural coordinates xi.

dNdXiSized dNdXi(const Eigen::Vector3d &xi)

Evaluate Tetra4 shape function natural derivatives at xi.

Eigen::Vector3i getBoundaryElementIndices(int faceID)

Return the local node indices for boundary face faceID.

Variables

int nNodes = 4

Number of nodes for a Tetra4 element.

namespace MarmotLibrary

file MarmotDofLayoutTools.h

#include “Marmot/MarmotTypedefs.h”

#include <map>

#include <vector>

Include dependency graph for MarmotDofLayoutTools.h:

file MarmotElement.h

#include “Marmot/MarmotElementProperty.h”

#include “Marmot/MarmotJournal.h”

#include “Marmot/MarmotUtils.h”

#include <stdexcept>

#include <string>

#include <vector>

Include dependency graph for MarmotElement.h:

This graph shows which files directly or indirectly include MarmotElement.h:

file MarmotElementFactory.h

#include “Marmot/MarmotElement.h”

#include <cassert>

#include <string>

#include <unordered_map>

Include dependency graph for MarmotElementFactory.h:

file MarmotElementProperty.h

#include <string>

Include dependency graph for MarmotElementProperty.h:

This graph shows which files directly or indirectly include MarmotElementProperty.h:

file MarmotEnhancedAssumedStrain.h

#include “Marmot/MarmotTypedefs.h”

Include dependency graph for MarmotEnhancedAssumedStrain.h:

file MarmotFiniteElement.h

#include “Marmot/MarmotTypedefs.h”

#include <vector>

Include dependency graph for MarmotFiniteElement.h:

This graph shows which files directly or indirectly include MarmotFiniteElement.h:

Core finite element utilities: element shapes, shape functions, Jacobian, and B-operator for 1-D, 2-D and 3-D isoparametric elements.

file MarmotFiniteElementSpatialWrapper.h

#include “Eigen/Sparse”

#include “Marmot/MarmotElement.h”

#include “Marmot/MarmotElementProperty.h”

#include <functional>

#include <memory>

Include dependency graph for MarmotFiniteElementSpatialWrapper.h:

file MarmotGeometryElement.h

#include “Marmot/MarmotFiniteElement.h”

#include “Marmot/MarmotTypedefs.h”

#include “Marmot/MarmotVoigt.h”

#include <iostream>

#include <map>

Include dependency graph for MarmotGeometryElement.h:

dir /home/runner/work/Marmot/Marmot/modules/core

dir /home/runner/work/Marmot/Marmot/modules/core/MarmotFiniteElementCore/include

dir /home/runner/work/Marmot/Marmot/modules/core/MarmotFiniteElementCore/include/Marmot

dir /home/runner/work/Marmot/Marmot/modules/core/MarmotFiniteElementCore

dir /home/runner/work/Marmot/Marmot/modules