MarmotFiniteElementCore

class BoundaryElement

Public Functions

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

Eigen::VectorXd computeScalarLoadVector()

Eigen::MatrixXd computeDScalarLoadVector_dCoordinates()

Eigen::VectorXd computeSurfaceNormalVectorialLoadVector(): compute the element load vector for a unit vectorial load normal to the surface.

Eigen::VectorXd computeSurfaceNormalVectorialLoadVectorForAxisymmetricElements()

Eigen::MatrixXd computeDSurfaceNormalVectorialLoadVector_dCoordinates()

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

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

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

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

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

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

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

Private Members

const int nDim

ElementShapes boundaryShape

int nNodes

int nParentCoordinates

std::vector<BoundaryElementQuadraturePoint> quadraturePoints

Eigen::VectorXi mapBoundaryToParentScalar

Eigen::VectorXi mapBoundaryToParentVectorial

Eigen::VectorXd coordinates

struct BoundaryElementQuadraturePoint

Public Members

double weight

double JxW

Eigen::VectorXd xi

Eigen::VectorXd N

Eigen::MatrixXd dNdXi

Eigen::MatrixXd dx_dXi

Eigen::VectorXd areaVector

class MarmotElementSpatialWrapper : public MarmotElement 

Inheritance diagram for MarmotElementSpatialWrapper:

digraph {
graph [bgcolor="#00000000"]
node [shape=rectangle style=filled fillcolor="#FFFFFF" font=Helvetica padding=2]
edge [color="#1414CE"]
"2" [label="MarmotElement" tooltip="MarmotElement"]
"1" [label="MarmotElementSpatialWrapper" tooltip="MarmotElementSpatialWrapper" fillcolor="#BFBFBF"]
"1" -> "2" [dir=forward tooltip="public-inheritance"]
}

Collaboration diagram for MarmotElementSpatialWrapper:

Public Functions

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

int getNumberOfRequiredStateVars()

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

std::vector<int> getDofIndicesPermutationPattern()

int getNNodes()

int getNSpatialDimensions()

int getNDofPerElement()

std::string getElementShape()

void assignStateVars(double *stateVars, int nStateVars)

void assignProperty(const ElementProperties &property)

void assignProperty(const MarmotMaterialSection &property)

void assignNodeCoordinates(const double *coordinates)

void initializeYourself()

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

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

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

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

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

std::vector<double> getCoordinatesAtCenter()

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

int getNumberOfQuadraturePoints()

Public Members

const int nDim

const int nDimChild

const int nNodes

const int nRhsChild

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

const int projectedSize

const int unprojectedSize

std::unique_ptr<MarmotElement> childElement

Eigen::MatrixXd T

Eigen::MatrixXd P

Eigen::MatrixXd projectedCoordinates

template<int nDim, int nNodes> class MarmotGeometryElement

Public Types

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

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

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

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

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

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

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

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

Public Functions

inline MarmotGeometryElement()

inline std::string getElementShape() const

inline void assignNodeCoordinates(const double *coords)

NSized N(const XiSized &xi) const

dNdXiSized dNdXi(const XiSized &xi) const

BSized B(const dNdXiSized &dNdX) const

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

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

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

inline NBSized NB(const NSized &N) const

inline JacobianSized Jacobian(const dNdXiSized &dNdXi) const

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

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

Public Members

Eigen::Map<const CoordinateVector> coordinates

const Marmot::FiniteElement::ElementShapes shape

Public Static Attributes

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

struct QuadraturePointInfo

Public Members

Eigen::VectorXd xi

double weight

namespace Marmot

namespace FiniteElement

Enums

enum ElementShapes

Values:

enumerator Bar2

enumerator Bar3

enumerator Quad4

enumerator Quad8

enumerator Quad9

enumerator Quad16

enumerator Tetra4

enumerator Tetra10

enumerator Hexa8

enumerator Hexa20

enumerator Hexa27

enumerator Hexa64

Functions

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

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

ElementShapes getElementShapeByMetric(int nDim, int nNodes)

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

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

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

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

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

namespace EAS

Enums

enum EASType

Values:

enumerator DeBorstEAS2

enumerator DeBorstEAS2_P2

enumerator EAS3

enumerator DeBorstEAS6b

enumerator DeBorstEAS9

enumerator SimoRifaiEAS5

enumerator SimoRifaiEAS4

Functions

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

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

namespace Quadrature

Enums

enum IntegrationTypes

Values:

enumerator FullIntegration

enumerator ReducedIntegration

Functions

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

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

Variables

double gp2 = 0.577350269189625764509

double gp3 = 0.774596669241483

namespace Spatial1D

Variables

int nDim = 1

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

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

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

namespace Spatial2D

Functions

void modifyCharElemLengthAbaqusLike(double &charElemLength, int intPoint)

Variables

int nDim = 2

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

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

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

namespace Spatial3D

Variables

int nDim = 3

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

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

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

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

const std::vector<QuadraturePointInfo> gaussPointList3x3x3

namespace Spatial1D

namespace Bar2

Typedefs

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

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

Functions

NSized N(double xi)

dNdXiSized dNdXi(double xi)

Variables

int nNodes = 2

namespace Bar3

Typedefs

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

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

Functions

NSized N(double xi)

dNdXiSized dNdXi(double xi)

Variables

int nNodes = 3

namespace Spatial2D

Functions

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

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

Variables

int nDim = 2

int voigtSize = 3

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

Variables

int voigtSize = 4

namespace Quad4

Typedefs

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

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

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

Functions

NSized N(const Eigen::Vector2d &xi)

dNdXiSized dNdXi(const Eigen::Vector2d &xi)

Eigen::Vector2i getBoundaryElementIndices(int faceID)

Variables

int nNodes = 4

namespace Quad8

Typedefs

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

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

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

Functions

NSized N(const Eigen::Vector2d &xi)

dNdXiSized dNdXi(const Eigen::Vector2d &xi)

Eigen::Vector3i getBoundaryElementIndices(int faceID)

Variables

int nNodes = 8

namespace Spatial3D

Functions

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

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

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

Variables

int nDim = 3

int voigtSize = 6

namespace Hexa20

Typedefs

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

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

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

Functions

NSized N(const Eigen::Vector3d &xi)

dNdXiSized dNdXi(const Eigen::Vector3d &xi)

Marmot::Vector8i getBoundaryElementIndices(int faceID)

Variables

int nNodes = 20

namespace Hexa8

Typedefs

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

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

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

Functions

NSized N(const Eigen::Vector3d &xi)

dNdXiSized dNdXi(const Eigen::Vector3d &xi)

Eigen::Vector4i getBoundaryElementIndices(int faceID)

Variables

int nNodes = 8

namespace Tetra10

Typedefs

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

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

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

Functions

NSized N(const Eigen::Vector3d &xi)

dNdXiSized dNdXi(const Eigen::Vector3d &xi)

Eigen::Vector3i getBoundaryElementIndices(int faceID)

Variables

int nNodes = 10

namespace Tetra4

Typedefs

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

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

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

Functions

NSized N(const Eigen::Vector3d &xi)

dNdXiSized dNdXi(const Eigen::Vector3d &xi)

Eigen::Vector3i getBoundaryElementIndices(int faceID)

Variables

int nNodes = 4

file MarmotDofLayoutTools.h: #include “Marmot/MarmotTypedefs.h”

#include <map>

#include <vector>

Include dependency graph for MarmotDofLayoutTools.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:

digraph {
graph [bgcolor="#00000000"]
node [shape=rectangle style=filled fillcolor="#FFFFFF" font=Helvetica padding=2]
edge [color="#1414CE"]
"1" [label="/home/runner/work/Marmot/Marmot/modules/core/MarmotFiniteElementCore/include/Marmot/MarmotFiniteElement.h" tooltip="/home/runner/work/Marmot/Marmot/modules/core/MarmotFiniteElementCore/include/Marmot/MarmotFiniteElement.h" fillcolor="#BFBFBF"]
"2" [label="Marmot/MarmotTypedefs.h" tooltip="Marmot/MarmotTypedefs.h"]
"3" [label="vector" tooltip="vector"]
"1" -> "2" [dir=forward tooltip="include"]
"1" -> "3" [dir=forward tooltip="include"]
}

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

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