structure grouping operators and data used for calculation of mass (convective) element \ nonlinear_elastic_elem More...

#include "users_modules/basic_finite_elements/src/ConvectiveMassElement.hpp"

Collaboration diagram for ConvectiveMassElement:

[legend]

Classes
struct	BlockData
	data for calculation inertia forces More...

struct	CommonData
	common data used by volume elements More...

struct	CommonFunctions

struct	MatShellCtx

struct	MyVolumeFE
	definition of volume element More...

struct	OpEnergy

struct	OpEshelbyDynamicMaterialMomentumJacobian

struct	OpEshelbyDynamicMaterialMomentumLhs_dv

struct	OpEshelbyDynamicMaterialMomentumLhs_dX

struct	OpEshelbyDynamicMaterialMomentumLhs_dx

struct	OpEshelbyDynamicMaterialMomentumRhs

struct	OpGetCommonDataAtGaussPts

struct	OpGetDataAtGaussPts

struct	OpMassJacobian

struct	OpMassLhs_dM_dv

struct	OpMassLhs_dM_dX

struct	OpMassLhs_dM_dx

struct	OpMassRhs

struct	OpVelocityJacobian

struct	OpVelocityLhs_dV_dv

struct	OpVelocityLhs_dV_dx

struct	OpVelocityLhs_dV_dX

struct	OpVelocityRhs

struct	PCShellCtx

struct	ShellResidualElement

struct	UpdateAndControl
	Set fields DOT_. More...

Public Member Functions
MyVolumeFE &	getLoopFeMassRhs ()
	get rhs volume element

MyVolumeFE &	getLoopFeMassLhs ()
	get lhs volume element

MyVolumeFE &	getLoopFeMassAuxLhs ()
	get lhs volume element for Kuu shell matrix

MyVolumeFE &	getLoopFeVelRhs ()
	get rhs volume element

MyVolumeFE &	getLoopFeVelLhs ()
	get lhs volume element

MyVolumeFE &	getLoopFeTRhs ()
	get rhs volume element

MyVolumeFE &	getLoopFeTLhs ()
	get lhs volume element

MyVolumeFE &	getLoopFeEnergy ()
	get kinetic energy element

MoFEMErrorCode	addHOOps ()

	ConvectiveMassElement (MoFEM::Interface &m_field, short int tag)

MoFEMErrorCode	setBlocks ()

MoFEMErrorCode	addConvectiveMassElement (string element_name, string velocity_field_name, string spatial_position_field_name, string material_position_field_name="MESH_NODE_POSITIONS", bool ale=false, BitRefLevel bit=BitRefLevel())

MoFEMErrorCode	addVelocityElement (string element_name, string velocity_field_name, string spatial_position_field_name, string material_position_field_name="MESH_NODE_POSITIONS", bool ale=false, BitRefLevel bit=BitRefLevel())

MoFEMErrorCode	addEshelbyDynamicMaterialMomentum (string element_name, string velocity_field_name, string spatial_position_field_name, string material_position_field_name="MESH_NODE_POSITIONS", bool ale=false, BitRefLevel bit=BitRefLevel(), Range *intersected=NULL)

MoFEMErrorCode	setConvectiveMassOperators (string velocity_field_name, string spatial_position_field_name, string material_position_field_name="MESH_NODE_POSITIONS", bool ale=false, bool linear=false)

MoFEMErrorCode	setVelocityOperators (string velocity_field_name, string spatial_position_field_name, string material_position_field_name="MESH_NODE_POSITIONS", bool ale=false)

MoFEMErrorCode	setKinematicEshelbyOperators (string velocity_field_name, string spatial_position_field_name, string material_position_field_name="MESH_NODE_POSITIONS", Range *forces_on_entities_ptr=NULL)

MoFEMErrorCode	setShellMatrixMassOperators (string velocity_field_name, string spatial_position_field_name, string material_position_field_name="MESH_NODE_POSITIONS", bool linear=false)

Static Public Member Functions
static MoFEMErrorCode	setBlocks (MoFEM::Interface &m_field, boost::shared_ptr< map< int, BlockData > > &block_sets_ptr)

static MoFEMErrorCode	MultOpA (Mat A, Vec x, Vec f)
	Mult operator for shell matrix.

static MoFEMErrorCode	ZeroEntriesOp (Mat A)

static MoFEMErrorCode	PCShellSetUpOp (PC pc)

static MoFEMErrorCode	PCShellDestroy (PC pc)

static MoFEMErrorCode	PCShellApplyOp (PC pc, Vec f, Vec x)
	apply pre-conditioner for shell matrix

Public Attributes
MyVolumeFE	feMassRhs
	calculate right hand side for tetrahedral elements

MyVolumeFE	feMassLhs

MyVolumeFE	feMassAuxLhs

MyVolumeFE	feVelRhs
	calculate right hand side for tetrahedral elements

MyVolumeFE	feVelLhs
	calculate left hand side for tetrahedral elements

MyVolumeFE	feTRhs
	calculate right hand side for tetrahedral elements

MyVolumeFE	feTLhs
	calculate left hand side for tetrahedral elements

MyVolumeFE	feEnergy
	calculate kinetic energy

MoFEM::Interface &	mField

short int	tAg

std::map< int, BlockData >	setOfBlocks
	maps block set id with appropriate BlockData

CommonData	commonData

boost::ptr_vector< MethodForForceScaling >	methodsOp

Detailed Description

structure grouping operators and data used for calculation of mass (convective) element \ nonlinear_elastic_elem

structure grouping operators and data used for calculation of nonlinear elastic element

In order to assemble matrices and right hand vectors, the loops over elements, entities over that elements and finally loop over integration points are executed.

Following implementation separate those three celeries of loops and to each loop attach operator.

In order to assemble matrices and right hand vectors, the loops over elements, entities over that elements and finally loop over integration points are executed.

Following implementation separate those three categories of loops and to each loop attach operator.

Examples: mofem/users_modules/basic_finite_elements/nonlinear_elasticity/nonlinear_dynamics.cpp, and mofem/users_modules/basic_finite_elements/src/HookeElement.hpp.

Definition at line 28 of file ConvectiveMassElement.hpp.

Constructor & Destructor Documentation

◆ ConvectiveMassElement()

ConvectiveMassElement::ConvectiveMassElement	(	MoFEM::Interface &	m_field,
		short int	tag
	)

Definition at line 74 of file ConvectiveMassElement.cpp.

    : feMassRhs(m_field), feMassLhs(m_field), feMassAuxLhs(m_field),
      feVelRhs(m_field), feVelLhs(m_field), feTRhs(m_field), feTLhs(m_field),
      feEnergy(m_field), mField(m_field), tAg(tag) {}

Member Function Documentation

◆ addConvectiveMassElement()

MoFEMErrorCode ConvectiveMassElement::addConvectiveMassElement	(	string	element_name,
		string	velocity_field_name,
		string	spatial_position_field_name,
		string	material_position_field_name = `"MESH_NODE_POSITIONS"`,
		bool	ale = `false`,
		BitRefLevel	bit = `BitRefLevel()`
	)

Definition at line 1841 of file ConvectiveMassElement.cpp.

                               {
  MoFEMFunctionBeginHot;
 
  //
 
  CHKERR mField.add_finite_element(element_name, MF_ZERO);
  CHKERR mField.modify_finite_element_add_field_row(element_name,
                                                    velocity_field_name);
  CHKERR mField.modify_finite_element_add_field_col(element_name,
                                                    velocity_field_name);
  CHKERR mField.modify_finite_element_add_field_data(element_name,
                                                     velocity_field_name);
  CHKERR mField.modify_finite_element_add_field_row(
      element_name, spatial_position_field_name);
  CHKERR mField.modify_finite_element_add_field_col(
      element_name, spatial_position_field_name);
  CHKERR mField.modify_finite_element_add_field_data(
      element_name, spatial_position_field_name);
  if (mField.check_field(material_position_field_name)) {
    if (ale) {
      CHKERR mField.modify_finite_element_add_field_row(
          element_name, material_position_field_name);
      CHKERR mField.modify_finite_element_add_field_col(
          element_name, material_position_field_name);
      CHKERR mField.modify_finite_element_add_field_data(
          element_name, "DOT_" + material_position_field_name);
    }
    CHKERR mField.modify_finite_element_add_field_data(
        element_name, material_position_field_name);
  }
  CHKERR mField.modify_finite_element_add_field_data(
      element_name, "DOT_" + velocity_field_name);
  CHKERR mField.modify_finite_element_add_field_data(
      element_name, "DOT_" + spatial_position_field_name);
 
  Range tets;
  if (bit.any()) {
    CHKERR mField.getInterface<BitRefManager>()->getEntitiesByTypeAndRefLevel(
        bit, BitRefLevel().set(), MBTET, tets);
  }
 
  std::map<int, BlockData>::iterator sit = setOfBlocks.begin();
  for (; sit != setOfBlocks.end(); sit++) {
    Range add_tets = sit->second.tEts;
    if (!tets.empty()) {
      add_tets = intersect(add_tets, tets);
    }
    CHKERR mField.add_ents_to_finite_element_by_type(add_tets, MBTET,
                                                     element_name);
  }
 
  MoFEMFunctionReturnHot(0);
}

◆ addEshelbyDynamicMaterialMomentum()

MoFEMErrorCode ConvectiveMassElement::addEshelbyDynamicMaterialMomentum	(	string	element_name,
		string	velocity_field_name,
		string	spatial_position_field_name,
		string	material_position_field_name = `"MESH_NODE_POSITIONS"`,
		bool	ale = `false`,
		BitRefLevel	bit = `BitRefLevel()`,
		Range *	intersected = `NULL`
	)

Definition at line 1951 of file ConvectiveMassElement.cpp.

                                                   {
  MoFEMFunctionBeginHot;
 
  //
 
  CHKERR mField.add_finite_element(element_name, MF_ZERO);
  CHKERR mField.modify_finite_element_add_field_col(element_name,
                                                    velocity_field_name);
  CHKERR mField.modify_finite_element_add_field_data(element_name,
                                                     velocity_field_name);
  CHKERR mField.modify_finite_element_add_field_col(
      element_name, spatial_position_field_name);
  CHKERR mField.modify_finite_element_add_field_data(
      element_name, spatial_position_field_name);
  if (mField.check_field(material_position_field_name)) {
    if (ale) {
      CHKERR mField.modify_finite_element_add_field_row(
          element_name, material_position_field_name);
      CHKERR mField.modify_finite_element_add_field_col(
          element_name, material_position_field_name);
      CHKERR mField.modify_finite_element_add_field_data(
          element_name, "DOT_" + material_position_field_name);
    }
    CHKERR mField.modify_finite_element_add_field_data(
        element_name, material_position_field_name);
  }
  CHKERR mField.modify_finite_element_add_field_data(
      element_name, "DOT_" + velocity_field_name);
  CHKERR mField.modify_finite_element_add_field_data(
      element_name, "DOT_" + spatial_position_field_name);
 
  Range tets;
  if (bit.any()) {
    CHKERR mField.getInterface<BitRefManager>()->getEntitiesByTypeAndRefLevel(
        bit, BitRefLevel().set(), MBTET, tets);
  }
  if (intersected != NULL) {
    if (tets.empty()) {
      tets = *intersected;
    } else {
      tets = intersect(*intersected, tets);
    }
  }
 
  std::map<int, BlockData>::iterator sit = setOfBlocks.begin();
  for (; sit != setOfBlocks.end(); sit++) {
    Range add_tets = sit->second.tEts;
    if (!tets.empty()) {
      add_tets = intersect(add_tets, tets);
    }
    CHKERR mField.add_ents_to_finite_element_by_type(add_tets, MBTET,
                                                     element_name);
  }
 
  MoFEMFunctionReturnHot(0);
}

◆ addHOOps()

MoFEMErrorCode ConvectiveMassElement::addHOOps ( )

inline

Definition at line 92 of file ConvectiveMassElement.hpp.

                            {
    MoFEMFunctionBegin;
    auto add_ops = [&](auto &fe) {
      return MoFEM::AddHOOps<3, 3, 3>::add(
          fe.getOpPtrVector(), {H1}, "MESH_NODE_POSITIONS");
    };
    CHKERR add_ops(feMassRhs);
    CHKERR add_ops(feMassLhs);
    CHKERR add_ops(feMassAuxLhs);
    CHKERR add_ops(feVelRhs);
    CHKERR add_ops(feTRhs);
    CHKERR add_ops(feTLhs);
    CHKERR add_ops(feEnergy);
    MoFEMFunctionReturn(0);
  }

◆ addVelocityElement()

MoFEMErrorCode ConvectiveMassElement::addVelocityElement	(	string	element_name,
		string	velocity_field_name,
		string	spatial_position_field_name,
		string	material_position_field_name = `"MESH_NODE_POSITIONS"`,
		bool	ale = `false`,
		BitRefLevel	bit = `BitRefLevel()`
	)

Definition at line 1898 of file ConvectiveMassElement.cpp.

                               {
  MoFEMFunctionBeginHot;
 
  //
 
  CHKERR mField.add_finite_element(element_name, MF_ZERO);
  CHKERR mField.modify_finite_element_add_field_row(element_name,
                                                    velocity_field_name);
  CHKERR mField.modify_finite_element_add_field_col(element_name,
                                                    velocity_field_name);
  CHKERR mField.modify_finite_element_add_field_data(element_name,
                                                     velocity_field_name);
  CHKERR mField.modify_finite_element_add_field_col(
      element_name, spatial_position_field_name);
  CHKERR mField.modify_finite_element_add_field_data(
      element_name, spatial_position_field_name);
  if (mField.check_field(material_position_field_name)) {
    if (ale) {
      CHKERR mField.modify_finite_element_add_field_col(
          element_name, material_position_field_name);
      CHKERR mField.modify_finite_element_add_field_data(
          element_name, "DOT_" + material_position_field_name);
    }
    CHKERR mField.modify_finite_element_add_field_data(
        element_name, material_position_field_name);
  }
  CHKERR mField.modify_finite_element_add_field_data(
      element_name, "DOT_" + velocity_field_name);
  CHKERR mField.modify_finite_element_add_field_data(
      element_name, "DOT_" + spatial_position_field_name);
 
  Range tets;
  if (bit.any()) {
    CHKERR mField.getInterface<BitRefManager>()->getEntitiesByTypeAndRefLevel(
        bit, BitRefLevel().set(), MBTET, tets);
  }
 
  std::map<int, BlockData>::iterator sit = setOfBlocks.begin();
  for (; sit != setOfBlocks.end(); sit++) {
    Range add_tets = sit->second.tEts;
    if (!tets.empty()) {
      add_tets = intersect(add_tets, tets);
    }
    CHKERR mField.add_ents_to_finite_element_by_type(add_tets, MBTET,
                                                     element_name);
  }
 
  MoFEMFunctionReturnHot(0);
}

◆ getLoopFeEnergy()

MyVolumeFE & ConvectiveMassElement::getLoopFeEnergy ( )

inline

get kinetic energy element

Definition at line 88 of file ConvectiveMassElement.hpp.

◆ getLoopFeMassAuxLhs()

MyVolumeFE & ConvectiveMassElement::getLoopFeMassAuxLhs ( )

inline

get lhs volume element for Kuu shell matrix

Definition at line 73 of file ConvectiveMassElement.hpp.

◆ getLoopFeMassLhs()

MyVolumeFE & ConvectiveMassElement::getLoopFeMassLhs ( )

inline

get lhs volume element

Definition at line 68 of file ConvectiveMassElement.hpp.

◆ getLoopFeMassRhs()

MyVolumeFE & ConvectiveMassElement::getLoopFeMassRhs ( )

inline

get rhs volume element

Definition at line 63 of file ConvectiveMassElement.hpp.

◆ getLoopFeTLhs()

MyVolumeFE & ConvectiveMassElement::getLoopFeTLhs ( )

inline

get lhs volume element

Definition at line 85 of file ConvectiveMassElement.hpp.

◆ getLoopFeTRhs()

MyVolumeFE & ConvectiveMassElement::getLoopFeTRhs ( )

inline

get rhs volume element

Definition at line 83 of file ConvectiveMassElement.hpp.

◆ getLoopFeVelLhs()

MyVolumeFE & ConvectiveMassElement::getLoopFeVelLhs ( )

inline

get lhs volume element

Definition at line 80 of file ConvectiveMassElement.hpp.

◆ getLoopFeVelRhs()

MyVolumeFE & ConvectiveMassElement::getLoopFeVelRhs ( )

inline

get rhs volume element

Definition at line 78 of file ConvectiveMassElement.hpp.

◆ MultOpA()

static MoFEMErrorCode ConvectiveMassElement::MultOpA	(	Mat	A,
		Vec	x,
		Vec	f
	)

inlinestatic

Mult operator for shell matrix.

\[ \left[ \begin{array}{cc} \mathbf{M} & \mathbf{K} \\ \mathbf{I} & -\mathbf{I}a \end{array} \right] \left[ \begin{array}{c} \mathbf{v} \\ \mathbf{u} \end{array} \right] = \left[ \begin{array}{c} \mathbf{r}_u \\ \mathbf{r}_v \end{array} \right] \]

Examples: mofem/users_modules/basic_finite_elements/nonlinear_elasticity/nonlinear_dynamics.cpp.

Definition at line 546 of file ConvectiveMassElement.hpp.

                                                     {
    MoFEMFunctionBeginHot;
 
    void *void_ctx;
    CHKERR MatShellGetContext(A, &void_ctx);
    MatShellCtx *ctx = (MatShellCtx *)void_ctx;
    if (!ctx->iNitialized) {
      CHKERR ctx->iNit();
    }
    CHKERR VecZeroEntries(f);
    // Mult Ku
    CHKERR VecScatterBegin(ctx->scatterU, x, ctx->u, INSERT_VALUES,
                           SCATTER_FORWARD);
    CHKERR VecScatterEnd(ctx->scatterU, x, ctx->u, INSERT_VALUES,
                         SCATTER_FORWARD);
    CHKERR MatMult(ctx->K, ctx->u, ctx->Ku);
    CHKERR VecScatterBegin(ctx->scatterU, ctx->Ku, f, INSERT_VALUES,
                           SCATTER_REVERSE);
    CHKERR VecScatterEnd(ctx->scatterU, ctx->Ku, f, INSERT_VALUES,
                         SCATTER_REVERSE);
    // Mult Mv
    CHKERR VecScatterBegin(ctx->scatterV, x, ctx->v, INSERT_VALUES,
                           SCATTER_FORWARD);
    CHKERR VecScatterEnd(ctx->scatterV, x, ctx->v, INSERT_VALUES,
                         SCATTER_FORWARD);
    CHKERR MatMult(ctx->M, ctx->v, ctx->Mv);
    CHKERR VecScatterBegin(ctx->scatterU, ctx->Mv, f, ADD_VALUES,
                           SCATTER_REVERSE);
    CHKERR VecScatterEnd(ctx->scatterU, ctx->Mv, f, ADD_VALUES,
                         SCATTER_REVERSE);
    // Velocities
    CHKERR VecAXPY(ctx->v, -ctx->ts_a, ctx->u);
    // CHKERR VecScale(ctx->v,ctx->scale);
    CHKERR VecScatterBegin(ctx->scatterV, ctx->v, f, INSERT_VALUES,
                           SCATTER_REVERSE);
    CHKERR VecScatterEnd(ctx->scatterV, ctx->v, f, INSERT_VALUES,
                         SCATTER_REVERSE);
    // Assemble
    CHKERR VecAssemblyBegin(f);
    CHKERR VecAssemblyEnd(f);
    MoFEMFunctionReturnHot(0);
  }

◆ PCShellApplyOp()

static MoFEMErrorCode ConvectiveMassElement::PCShellApplyOp	(	PC	pc,
		Vec	f,
		Vec	x
	)

inlinestatic

apply pre-conditioner for shell matrix

\[ \left[ \begin{array}{cc} \mathbf{M} & \mathbf{K} \\ \mathbf{I} & -\mathbf{I}a \end{array} \right] \left[ \begin{array}{c} \mathbf{v} \\ \mathbf{u} \end{array} \right] = \left[ \begin{array}{c} \mathbf{r}_u \\ \mathbf{r}_v \end{array} \right] \]

where \(\mathbf{v} = \mathbf{r}_v + a\mathbf{u}\) and \(\mathbf{u}=(a\mathbf{M}+\mathbf{K})^{-1}(\mathbf{r}_u - \mathbf{M}\mathbf{r}_v\).

Examples: mofem/users_modules/basic_finite_elements/nonlinear_elasticity/nonlinear_dynamics.cpp.

Definition at line 671 of file ConvectiveMassElement.hpp.

                                                            {
    MoFEMFunctionBeginHot;
 
    void *void_ctx;
    CHKERR PCShellGetContext(pc, &void_ctx);
    PCShellCtx *ctx = (PCShellCtx *)void_ctx;
    MatShellCtx *shell_mat_ctx;
    CHKERR MatShellGetContext(ctx->shellMat, &shell_mat_ctx);
    // forward
    CHKERR VecScatterBegin(shell_mat_ctx->scatterU, f, shell_mat_ctx->Ku,
                           INSERT_VALUES, SCATTER_FORWARD);
    CHKERR VecScatterEnd(shell_mat_ctx->scatterU, f, shell_mat_ctx->Ku,
                         INSERT_VALUES, SCATTER_FORWARD);
    CHKERR VecScatterBegin(shell_mat_ctx->scatterV, f, shell_mat_ctx->v,
                           INSERT_VALUES, SCATTER_FORWARD);
    CHKERR VecScatterEnd(shell_mat_ctx->scatterV, f, shell_mat_ctx->v,
                         INSERT_VALUES, SCATTER_FORWARD);
    // CHKERR VecScale(shell_mat_ctx->v,1/shell_mat_ctx->scale);
    // apply pre-conditioner and calculate u
    CHKERR MatMult(shell_mat_ctx->M, shell_mat_ctx->v,
                   shell_mat_ctx->Mv);                        // Mrv
    CHKERR VecAXPY(shell_mat_ctx->Ku, -1, shell_mat_ctx->Mv); // f-Mrv
    CHKERR PCApply(ctx->pC, shell_mat_ctx->Ku,
                   shell_mat_ctx->u); // u = (aM+K)^(-1)(ru-Mrv)
    // VecView(shell_mat_ctx->u,PETSC_VIEWER_STDOUT_WORLD);
    // calculate velocities
    CHKERR VecAXPY(shell_mat_ctx->v, shell_mat_ctx->ts_a,
                   shell_mat_ctx->u); // v = v + a*u
    // VecView(shell_mat_ctx->v,PETSC_VIEWER_STDOUT_WORLD);
    // reverse
    CHKERR VecZeroEntries(x);
    CHKERR VecScatterBegin(shell_mat_ctx->scatterU, shell_mat_ctx->u, x,
                           INSERT_VALUES, SCATTER_REVERSE);
    CHKERR VecScatterEnd(shell_mat_ctx->scatterU, shell_mat_ctx->u, x,
                         INSERT_VALUES, SCATTER_REVERSE);
    CHKERR VecScatterBegin(shell_mat_ctx->scatterV, shell_mat_ctx->v, x,
                           INSERT_VALUES, SCATTER_REVERSE);
    CHKERR VecScatterEnd(shell_mat_ctx->scatterV, shell_mat_ctx->v, x,
                         INSERT_VALUES, SCATTER_REVERSE);
    CHKERR VecAssemblyBegin(x);
    CHKERR VecAssemblyEnd(x);
    MoFEMFunctionReturnHot(0);
  }

◆ PCShellDestroy()

static MoFEMErrorCode ConvectiveMassElement::PCShellDestroy ( PC pc )

inlinestatic

Examples: mofem/users_modules/basic_finite_elements/nonlinear_elasticity/nonlinear_dynamics.cpp.

Definition at line 633 of file ConvectiveMassElement.hpp.

                                              {
    MoFEMFunctionBeginHot;
 
    void *void_ctx;
    CHKERR PCShellGetContext(pc, &void_ctx);
    PCShellCtx *ctx = (PCShellCtx *)void_ctx;
    CHKERR ctx->dEstroy();
    MoFEMFunctionReturnHot(0);
  }

◆ PCShellSetUpOp()

static MoFEMErrorCode ConvectiveMassElement::PCShellSetUpOp ( PC pc )

inlinestatic

Examples: mofem/users_modules/basic_finite_elements/nonlinear_elasticity/nonlinear_dynamics.cpp.

Definition at line 618 of file ConvectiveMassElement.hpp.

                                              {
    MoFEMFunctionBeginHot;
 
    void *void_ctx;
    CHKERR PCShellGetContext(pc, &void_ctx);
    PCShellCtx *ctx = (PCShellCtx *)void_ctx;
    CHKERR ctx->iNit();
    MatShellCtx *shell_mat_ctx;
    CHKERR MatShellGetContext(ctx->shellMat, &shell_mat_ctx);
    CHKERR PCSetFromOptions(ctx->pC);
    CHKERR PCSetOperators(ctx->pC, shell_mat_ctx->barK, shell_mat_ctx->barK);
    CHKERR PCSetUp(ctx->pC);
    MoFEMFunctionReturnHot(0);
  }

◆ setBlocks() [1/2]

MoFEMErrorCode ConvectiveMassElement::setBlocks ( )

Examples: mofem/users_modules/basic_finite_elements/elasticity/elasticity.cpp.

Definition at line 1767 of file ConvectiveMassElement.cpp.

                                                {
  MoFEMFunctionBeginHot;
 
  Range added_tets;
  for (_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(
           mField, BLOCKSET | BODYFORCESSET, it)) {
    int id = it->getMeshsetId();
    EntityHandle meshset = it->getMeshset();
    CHKERR mField.get_moab().get_entities_by_type(meshset, MBTET,
                                                  setOfBlocks[id].tEts, true);
    added_tets.merge(setOfBlocks[id].tEts);
    Block_BodyForces mydata;
    CHKERR it->getAttributeDataStructure(mydata);
    setOfBlocks[id].rho0 = mydata.data.density;
    setOfBlocks[id].a0.resize(3);
    setOfBlocks[id].a0[0] = mydata.data.acceleration_x;
    setOfBlocks[id].a0[1] = mydata.data.acceleration_y;
    setOfBlocks[id].a0[2] = mydata.data.acceleration_z;
    // std::cerr << setOfBlocks[id].tEts << std::endl;
  }
 
  for (_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(
           mField, BLOCKSET | MAT_ELASTICSET, it)) {
    Mat_Elastic mydata;
    CHKERR it->getAttributeDataStructure(mydata);
    if (mydata.data.User1 == 0)
      continue;
    Range tets;
    EntityHandle meshset = it->getMeshset();
    CHKERR mField.get_moab().get_entities_by_type(meshset, MBTET, tets, true);
    tets = subtract(tets, added_tets);
    if (tets.empty())
      continue;
    int id = it->getMeshsetId();
    setOfBlocks[-id].tEts = tets;
    setOfBlocks[-id].rho0 = mydata.data.User1;
    setOfBlocks[-id].a0.resize(3);
    setOfBlocks[-id].a0[0] = mydata.data.User2;
    setOfBlocks[-id].a0[1] = mydata.data.User3;
    setOfBlocks[-id].a0[2] = mydata.data.User4;
    // std::cerr << setOfBlocks[id].tEts << std::endl;
  }
 
  MoFEMFunctionReturnHot(0);
}

◆ setBlocks() [2/2]

MoFEMErrorCode ConvectiveMassElement::setBlocks	(	MoFEM::Interface &	m_field,
		boost::shared_ptr< map< int, BlockData > > &	block_sets_ptr
	)

static

Definition at line 1813 of file ConvectiveMassElement.cpp.

                                                          {
  MoFEMFunctionBegin;
 
  if (!block_sets_ptr)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "Pointer to block of sets is null");
 
  for (_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(
           m_field, BLOCKSET | BODYFORCESSET, it)) {
    Block_BodyForces mydata;
    CHKERR it->getAttributeDataStructure(mydata);
    int id = it->getMeshsetId();
    auto &block_data = (*block_sets_ptr)[id];
    EntityHandle meshset = it->getMeshset();
    CHKERR m_field.get_moab().get_entities_by_dimension(meshset, 3,
                                                        block_data.tEts, true);
    block_data.rho0 = mydata.data.density;
    block_data.a0.resize(3);
    block_data.a0[0] = mydata.data.acceleration_x;
    block_data.a0[1] = mydata.data.acceleration_y;
    block_data.a0[2] = mydata.data.acceleration_z;
  }
 
  MoFEMFunctionReturn(0);
}

◆ setConvectiveMassOperators()

MoFEMErrorCode ConvectiveMassElement::setConvectiveMassOperators	(	string	velocity_field_name,
		string	spatial_position_field_name,
		string	material_position_field_name = `"MESH_NODE_POSITIONS"`,
		bool	ale = `false`,
		bool	linear = `false`
	)

Definition at line 2011 of file ConvectiveMassElement.cpp.

                                                                {
  MoFEMFunctionBeginHot;
 
  commonData.spatialPositions = spatial_position_field_name;
  commonData.meshPositions = material_position_field_name;
  commonData.spatialVelocities = velocity_field_name;
  commonData.lInear = linear;
 
  // Rhs
  feMassRhs.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts(velocity_field_name, commonData));
  feMassRhs.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts(spatial_position_field_name, commonData));
  feMassRhs.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts("DOT_" + velocity_field_name, commonData));
  feMassRhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
      "DOT_" + spatial_position_field_name, commonData));
  if (mField.check_field(material_position_field_name)) {
    feMassRhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
        material_position_field_name, commonData));
    if (ale) {
      feMassRhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
          "DOT_" + material_position_field_name, commonData));
    } else {
      feMassRhs.meshPositionsFieldName = material_position_field_name;
    }
  }
  std::map<int, BlockData>::iterator sit = setOfBlocks.begin();
  for (; sit != setOfBlocks.end(); sit++) {
    feMassRhs.getOpPtrVector().push_back(
        new OpMassJacobian(spatial_position_field_name, sit->second, commonData,
                           methodsOp, tAg, false));
    feMassRhs.getOpPtrVector().push_back(
        new OpMassRhs(spatial_position_field_name, sit->second, commonData));
  }
 
  // Lhs
  feMassLhs.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts(velocity_field_name, commonData));
  feMassLhs.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts(spatial_position_field_name, commonData));
  feMassLhs.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts("DOT_" + velocity_field_name, commonData));
  feMassLhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
      "DOT_" + spatial_position_field_name, commonData));
  if (mField.check_field(material_position_field_name)) {
    feMassLhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
        material_position_field_name, commonData));
    if (ale) {
      feMassLhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
          "DOT_" + material_position_field_name, commonData));
    } else {
      feMassLhs.meshPositionsFieldName = material_position_field_name;
    }
  }
  sit = setOfBlocks.begin();
  for (; sit != setOfBlocks.end(); sit++) {
    feMassLhs.getOpPtrVector().push_back(
        new OpMassJacobian(spatial_position_field_name, sit->second, commonData,
                           methodsOp, tAg, true));
    feMassLhs.getOpPtrVector().push_back(
        new OpMassLhs_dM_dv(spatial_position_field_name, velocity_field_name,
                            sit->second, commonData));
    feMassLhs.getOpPtrVector().push_back(new OpMassLhs_dM_dx(
        spatial_position_field_name, spatial_position_field_name, sit->second,
        commonData));
    if (mField.check_field(material_position_field_name)) {
      if (ale) {
        feMassLhs.getOpPtrVector().push_back(new OpMassLhs_dM_dX(
            spatial_position_field_name, material_position_field_name,
            sit->second, commonData));
      } else {
        feMassLhs.meshPositionsFieldName = material_position_field_name;
      }
    }
  }
 
  // Energy
  feEnergy.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts(velocity_field_name, commonData));
  feEnergy.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts(spatial_position_field_name, commonData));
  if (mField.check_field(material_position_field_name)) {
    feEnergy.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
        material_position_field_name, commonData));
    feEnergy.meshPositionsFieldName = material_position_field_name;
  }
  sit = setOfBlocks.begin();
  for (; sit != setOfBlocks.end(); sit++) {
    feEnergy.getOpPtrVector().push_back(new OpEnergy(
        spatial_position_field_name, sit->second, commonData, feEnergy.V));
  }
 
  MoFEMFunctionReturnHot(0);
}

◆ setKinematicEshelbyOperators()

MoFEMErrorCode ConvectiveMassElement::setKinematicEshelbyOperators	(	string	velocity_field_name,
		string	spatial_position_field_name,
		string	material_position_field_name = `"MESH_NODE_POSITIONS"`,
		Range *	forces_on_entities_ptr = `NULL`
	)

Definition at line 2187 of file ConvectiveMassElement.cpp.

                                                                        {
  MoFEMFunctionBeginHot;
 
  commonData.spatialPositions = spatial_position_field_name;
  commonData.meshPositions = material_position_field_name;
  commonData.spatialVelocities = velocity_field_name;
 
  // Rhs
  feTRhs.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts(velocity_field_name, commonData));
  feTRhs.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts(spatial_position_field_name, commonData));
  feTRhs.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts(material_position_field_name, commonData));
  feTRhs.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts("DOT_" + velocity_field_name, commonData));
 
  std::map<int, BlockData>::iterator sit = setOfBlocks.begin();
  for (; sit != setOfBlocks.end(); sit++) {
    feTRhs.getOpPtrVector().push_back(
        new OpEshelbyDynamicMaterialMomentumJacobian(
            material_position_field_name, sit->second, commonData, tAg, false));
    feTRhs.getOpPtrVector().push_back(new OpEshelbyDynamicMaterialMomentumRhs(
        material_position_field_name, sit->second, commonData,
        forces_on_entities_ptr));
  }
 
  // Lhs
  feTLhs.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts(velocity_field_name, commonData));
  feTLhs.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts(spatial_position_field_name, commonData));
  feTLhs.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts("DOT_" + velocity_field_name, commonData));
  if (mField.check_field(material_position_field_name)) {
    feTLhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
        material_position_field_name, commonData));
  }
  sit = setOfBlocks.begin();
  for (; sit != setOfBlocks.end(); sit++) {
    feTLhs.getOpPtrVector().push_back(
        new OpEshelbyDynamicMaterialMomentumJacobian(
            material_position_field_name, sit->second, commonData, tAg));
    feTLhs.getOpPtrVector().push_back(
        new OpEshelbyDynamicMaterialMomentumLhs_dv(
            material_position_field_name, velocity_field_name, sit->second,
            commonData, forces_on_entities_ptr));
    feTLhs.getOpPtrVector().push_back(
        new OpEshelbyDynamicMaterialMomentumLhs_dx(
            material_position_field_name, spatial_position_field_name,
            sit->second, commonData, forces_on_entities_ptr));
    feTLhs.getOpPtrVector().push_back(
        new OpEshelbyDynamicMaterialMomentumLhs_dX(
            material_position_field_name, material_position_field_name,
            sit->second, commonData, forces_on_entities_ptr));
  }
 
  MoFEMFunctionReturnHot(0);
}

◆ setShellMatrixMassOperators()

MoFEMErrorCode ConvectiveMassElement::setShellMatrixMassOperators	(	string	velocity_field_name,
		string	spatial_position_field_name,
		string	material_position_field_name = `"MESH_NODE_POSITIONS"`,
		bool	linear = `false`
	)

Definition at line 2249 of file ConvectiveMassElement.cpp.

                                                      {
  MoFEMFunctionBeginHot;
 
  commonData.spatialPositions = spatial_position_field_name;
  commonData.meshPositions = material_position_field_name;
  commonData.spatialVelocities = velocity_field_name;
  commonData.lInear = linear;
 
  // Rhs
  feMassRhs.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts(velocity_field_name, commonData));
  feMassRhs.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts(spatial_position_field_name, commonData));
  feMassRhs.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts("DOT_" + velocity_field_name, commonData));
  if (mField.check_field(material_position_field_name)) {
    feMassRhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
        material_position_field_name, commonData));
    feMassRhs.meshPositionsFieldName = material_position_field_name;
  }
  std::map<int, BlockData>::iterator sit = setOfBlocks.begin();
  for (; sit != setOfBlocks.end(); sit++) {
    feMassRhs.getOpPtrVector().push_back(
        new OpMassJacobian(spatial_position_field_name, sit->second, commonData,
                           methodsOp, tAg, false));
    feMassRhs.getOpPtrVector().push_back(
        new OpMassRhs(spatial_position_field_name, sit->second, commonData));
  }
 
  // Lhs
  feMassLhs.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts(velocity_field_name, commonData));
  feMassLhs.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts(spatial_position_field_name, commonData));
  feMassLhs.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts("DOT_" + velocity_field_name, commonData));
  if (mField.check_field(material_position_field_name)) {
    feMassLhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
        material_position_field_name, commonData));
    feMassLhs.meshPositionsFieldName = material_position_field_name;
  }
  sit = setOfBlocks.begin();
  for (; sit != setOfBlocks.end(); sit++) {
    feMassLhs.getOpPtrVector().push_back(
        new OpMassJacobian(spatial_position_field_name, sit->second, commonData,
                           methodsOp, tAg, true));
    feMassLhs.getOpPtrVector().push_back(new OpMassLhs_dM_dv(
        spatial_position_field_name, spatial_position_field_name, sit->second,
        commonData));
    if (mField.check_field(material_position_field_name)) {
      feMassLhs.meshPositionsFieldName = material_position_field_name;
    }
  }
 
  // Aux Lhs
  feMassAuxLhs.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts(velocity_field_name, commonData));
  feMassAuxLhs.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts(spatial_position_field_name, commonData));
  feMassAuxLhs.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts("DOT_" + velocity_field_name, commonData));
  if (mField.check_field(material_position_field_name)) {
    feMassAuxLhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
        material_position_field_name, commonData));
    feMassAuxLhs.meshPositionsFieldName = material_position_field_name;
  }
  sit = setOfBlocks.begin();
  for (; sit != setOfBlocks.end(); sit++) {
    feMassAuxLhs.getOpPtrVector().push_back(
        new OpMassJacobian(spatial_position_field_name, sit->second, commonData,
                           methodsOp, tAg, true));
    feMassAuxLhs.getOpPtrVector().push_back(new OpMassLhs_dM_dx(
        spatial_position_field_name, spatial_position_field_name, sit->second,
        commonData));
    if (mField.check_field(material_position_field_name)) {
      feMassAuxLhs.meshPositionsFieldName = material_position_field_name;
    }
  }
 
  // Energy E=0.5*rho*v*v
  feEnergy.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts(velocity_field_name, commonData));
  feEnergy.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts(spatial_position_field_name, commonData));
  if (mField.check_field(material_position_field_name)) {
    feEnergy.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
        material_position_field_name, commonData));
    feEnergy.meshPositionsFieldName = material_position_field_name;
  }
  sit = setOfBlocks.begin();
  for (; sit != setOfBlocks.end(); sit++) {
    feEnergy.getOpPtrVector().push_back(new OpEnergy(
        spatial_position_field_name, sit->second, commonData, feEnergy.V));
  }
 
  MoFEMFunctionReturnHot(0);
}

◆ setVelocityOperators()

MoFEMErrorCode ConvectiveMassElement::setVelocityOperators	(	string	velocity_field_name,
		string	spatial_position_field_name,
		string	material_position_field_name = `"MESH_NODE_POSITIONS"`,
		bool	ale = `false`
	)

Definition at line 2109 of file ConvectiveMassElement.cpp.

                                                   {
  MoFEMFunctionBeginHot;
 
  commonData.spatialPositions = spatial_position_field_name;
  commonData.meshPositions = material_position_field_name;
  commonData.spatialVelocities = velocity_field_name;
 
  // Rhs
  feVelRhs.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts(velocity_field_name, commonData));
  feVelRhs.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts(spatial_position_field_name, commonData));
  feVelRhs.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts("DOT_" + velocity_field_name, commonData));
  if (mField.check_field(material_position_field_name)) {
    feVelRhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
        "DOT_" + spatial_position_field_name, commonData));
    feVelRhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
        material_position_field_name, commonData));
    if (ale) {
      feVelRhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
          "DOT_" + material_position_field_name, commonData));
    } else {
      feVelRhs.meshPositionsFieldName = material_position_field_name;
    }
  }
  std::map<int, BlockData>::iterator sit = setOfBlocks.begin();
  for (; sit != setOfBlocks.end(); sit++) {
    feVelRhs.getOpPtrVector().push_back(new OpVelocityJacobian(
        velocity_field_name, sit->second, commonData, tAg, false));
    feVelRhs.getOpPtrVector().push_back(
        new OpVelocityRhs(velocity_field_name, sit->second, commonData));
  }
 
  // Lhs
  feVelLhs.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts(velocity_field_name, commonData));
  feVelLhs.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts(spatial_position_field_name, commonData));
  feVelLhs.getOpPtrVector().push_back(
      new OpGetCommonDataAtGaussPts("DOT_" + velocity_field_name, commonData));
  if (mField.check_field(material_position_field_name)) {
    feVelLhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
        "DOT_" + spatial_position_field_name, commonData));
    feVelLhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
        material_position_field_name, commonData));
    if (ale) {
      feVelLhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
          "DOT_" + material_position_field_name, commonData));
    } else {
      feVelLhs.meshPositionsFieldName = material_position_field_name;
    }
  }
  sit = setOfBlocks.begin();
  for (; sit != setOfBlocks.end(); sit++) {
    feVelLhs.getOpPtrVector().push_back(new OpVelocityJacobian(
        velocity_field_name, sit->second, commonData, tAg));
    feVelLhs.getOpPtrVector().push_back(new OpVelocityLhs_dV_dv(
        velocity_field_name, velocity_field_name, sit->second, commonData));
    feVelLhs.getOpPtrVector().push_back(new OpVelocityLhs_dV_dx(
        velocity_field_name, spatial_position_field_name, sit->second,
        commonData));
    if (mField.check_field(material_position_field_name)) {
      if (ale) {
        feVelLhs.getOpPtrVector().push_back(new OpVelocityLhs_dV_dX(
            velocity_field_name, material_position_field_name, sit->second,
            commonData));
      } else {
        feVelLhs.meshPositionsFieldName = material_position_field_name;
      }
    }
  }
 
  MoFEMFunctionReturnHot(0);
}

◆ ZeroEntriesOp()

static MoFEMErrorCode ConvectiveMassElement::ZeroEntriesOp ( Mat A )

inlinestatic

Examples: mofem/users_modules/basic_finite_elements/nonlinear_elasticity/nonlinear_dynamics.cpp.

Definition at line 589 of file ConvectiveMassElement.hpp.

                                             {
    MoFEMFunctionBeginHot;
 
    void *void_ctx;
    CHKERR MatShellGetContext(A, &void_ctx);
    MatShellCtx *ctx = (MatShellCtx *)void_ctx;
    CHKERR MatZeroEntries(ctx->K);
    CHKERR MatZeroEntries(ctx->M);
    MoFEMFunctionReturnHot(0);
  }

Member Data Documentation

◆ commonData

CommonData ConvectiveMassElement::commonData

Definition at line 148 of file ConvectiveMassElement.hpp.

◆ feEnergy

MyVolumeFE ConvectiveMassElement::feEnergy

calculate kinetic energy

Definition at line 87 of file ConvectiveMassElement.hpp.

◆ feMassAuxLhs

MyVolumeFE ConvectiveMassElement::feMassAuxLhs

calculate left hand side for tetrahedral elements for Kuu shell matrix

Definition at line 71 of file ConvectiveMassElement.hpp.

◆ feMassLhs

MyVolumeFE ConvectiveMassElement::feMassLhs

calculate left hand side for tetrahedral elements,i.e. mass element

Definition at line 66 of file ConvectiveMassElement.hpp.

◆ feMassRhs

MyVolumeFE ConvectiveMassElement::feMassRhs

calculate right hand side for tetrahedral elements

Definition at line 62 of file ConvectiveMassElement.hpp.

◆ feTLhs

MyVolumeFE ConvectiveMassElement::feTLhs

calculate left hand side for tetrahedral elements

Definition at line 84 of file ConvectiveMassElement.hpp.

◆ feTRhs

MyVolumeFE ConvectiveMassElement::feTRhs

calculate right hand side for tetrahedral elements

Definition at line 82 of file ConvectiveMassElement.hpp.

◆ feVelLhs

MyVolumeFE ConvectiveMassElement::feVelLhs

calculate left hand side for tetrahedral elements

Definition at line 79 of file ConvectiveMassElement.hpp.

◆ feVelRhs

MyVolumeFE ConvectiveMassElement::feVelRhs

calculate right hand side for tetrahedral elements

Definition at line 77 of file ConvectiveMassElement.hpp.

◆ methodsOp

boost::ptr_vector<MethodForForceScaling> ConvectiveMassElement::methodsOp

Definition at line 150 of file ConvectiveMassElement.hpp.

◆ mField

MoFEM::Interface& ConvectiveMassElement::mField

Definition at line 108 of file ConvectiveMassElement.hpp.

◆ setOfBlocks

std::map<int, BlockData> ConvectiveMassElement::setOfBlocks

maps block set id with appropriate BlockData

Definition at line 122 of file ConvectiveMassElement.hpp.

◆ tAg

short int ConvectiveMassElement::tAg

Definition at line 109 of file ConvectiveMassElement.hpp.

The documentation for this struct was generated from the following files:

users_modules/basic_finite_elements/src/ConvectiveMassElement.hpp
users_modules/basic_finite_elements/src/impl/ConvectiveMassElement.cpp

Classes

Public Member Functions

Static Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ConvectiveMassElement()

Member Function Documentation

◆ addConvectiveMassElement()

◆ addEshelbyDynamicMaterialMomentum()

◆ addHOOps()

◆ addVelocityElement()

◆ getLoopFeEnergy()

◆ getLoopFeMassAuxLhs()

◆ getLoopFeMassLhs()

◆ getLoopFeMassRhs()

◆ getLoopFeTLhs()

◆ getLoopFeTRhs()

◆ getLoopFeVelLhs()

◆ getLoopFeVelRhs()

◆ MultOpA()

◆ PCShellApplyOp()

◆ PCShellDestroy()

◆ PCShellSetUpOp()

◆ setBlocks() [1/2]

◆ setBlocks() [2/2]

◆ setConvectiveMassOperators()

◆ setKinematicEshelbyOperators()

◆ setShellMatrixMassOperators()

◆ setVelocityOperators()

◆ ZeroEntriesOp()

Member Data Documentation

◆ commonData

◆ feEnergy

◆ feMassAuxLhs

◆ feMassLhs

◆ feMassRhs

◆ feTLhs

◆ feTRhs

◆ feVelLhs

◆ feVelRhs

◆ methodsOp

◆ mField

◆ setOfBlocks

◆ tAg