v0.14.0
Loading...
Searching...
No Matches
Classes | Public Member Functions | Static Public Member Functions | Public Attributes | List of all members
ConvectiveMassElement Struct Reference

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

MyVolumeFEgetLoopFeMassRhs ()
 get rhs volume element More...
 
MyVolumeFEgetLoopFeMassLhs ()
 get lhs volume element More...
 
MyVolumeFEgetLoopFeMassAuxLhs ()
 get lhs volume element for Kuu shell matrix More...
 
MyVolumeFEgetLoopFeVelRhs ()
 get rhs volume element More...
 
MyVolumeFEgetLoopFeVelLhs ()
 get lhs volume element More...
 
MyVolumeFEgetLoopFeTRhs ()
 get rhs volume element More...
 
MyVolumeFEgetLoopFeTLhs ()
 get lhs volume element More...
 
MyVolumeFEgetLoopFeEnergy ()
 get kinetic energy element More...
 
MoFEMErrorCode addHOOpsVol ()
 
 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. More...
 
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 More...
 

Public Attributes

MyVolumeFE feMassRhs
 calculate right hand side for tetrahedral elements More...
 
MyVolumeFE feMassLhs
 
MyVolumeFE feMassAuxLhs
 
MyVolumeFE feVelRhs
 calculate right hand side for tetrahedral elements More...
 
MyVolumeFE feVelLhs
 calculate left hand side for tetrahedral elements More...
 
MyVolumeFE feTRhs
 calculate right hand side for tetrahedral elements More...
 
MyVolumeFE feTLhs
 calculate left hand side for tetrahedral elements More...
 
MyVolumeFE feEnergy
 calculate kinetic energy More...
 
MoFEM::InterfacemField
 
short int tAg
 
std::map< int, BlockDatasetOfBlocks
 maps block set id with appropriate BlockData More...
 
CommonData commonData
 
boost::ptr_vector< MethodForForceScalingmethodsOp
 

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
HookeElement.hpp, and nonlinear_dynamics.cpp.

Definition at line 28 of file ConvectiveMassElement.hpp.

Constructor & Destructor Documentation

◆ ConvectiveMassElement()

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

Definition at line 75 of file ConvectiveMassElement.cpp.

77 : feMassRhs(m_field), feMassLhs(m_field), feMassAuxLhs(m_field),
78 feVelRhs(m_field), feVelLhs(m_field), feTRhs(m_field), feTLhs(m_field),
79 feEnergy(m_field), mField(m_field), tAg(tag) {}
MyVolumeFE feEnergy
calculate kinetic energy
MyVolumeFE feVelRhs
calculate right hand side for tetrahedral elements
MyVolumeFE feTRhs
calculate right hand side for tetrahedral elements
MyVolumeFE feMassRhs
calculate right hand side for tetrahedral elements
MyVolumeFE feTLhs
calculate left hand side for tetrahedral elements
MyVolumeFE feVelLhs
calculate left hand side for tetrahedral elements

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 1835 of file ConvectiveMassElement.cpp.

1838 {
1840
1841 //
1842
1843 CHKERR mField.add_finite_element(element_name, MF_ZERO);
1845 velocity_field_name);
1847 velocity_field_name);
1849 velocity_field_name);
1851 element_name, spatial_position_field_name);
1853 element_name, spatial_position_field_name);
1855 element_name, spatial_position_field_name);
1856 if (mField.check_field(material_position_field_name)) {
1857 if (ale) {
1859 element_name, material_position_field_name);
1861 element_name, material_position_field_name);
1863 element_name, "DOT_" + material_position_field_name);
1864 }
1866 element_name, material_position_field_name);
1867 }
1869 element_name, "DOT_" + velocity_field_name);
1871 element_name, "DOT_" + spatial_position_field_name);
1872
1873 Range tets;
1874 if (bit.any()) {
1875 CHKERR mField.getInterface<BitRefManager>()->getEntitiesByTypeAndRefLevel(
1876 bit, BitRefLevel().set(), MBTET, tets);
1877 }
1878
1879 std::map<int, BlockData>::iterator sit = setOfBlocks.begin();
1880 for (; sit != setOfBlocks.end(); sit++) {
1881 Range add_tets = sit->second.tEts;
1882 if (!tets.empty()) {
1883 add_tets = intersect(add_tets, tets);
1884 }
1886 element_name);
1887 }
1888
1890}
@ MF_ZERO
Definition: definitions.h:98
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:447
#define CHKERR
Inline error check.
Definition: definitions.h:535
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:440
virtual MoFEMErrorCode add_finite_element(const std::string &fe_name, enum MoFEMTypes bh=MF_EXCL, int verb=DEFAULT_VERBOSITY)=0
add finite element
virtual MoFEMErrorCode modify_finite_element_add_field_col(const std::string &fe_name, const std::string name_row)=0
set field col which finite element use
virtual MoFEMErrorCode add_ents_to_finite_element_by_type(const EntityHandle entities, const EntityType type, const std::string &name, const bool recursive=true)=0
add entities to finite element
virtual MoFEMErrorCode modify_finite_element_add_field_data(const std::string &fe_name, const std::string name_filed)=0
set finite element field data
virtual MoFEMErrorCode modify_finite_element_add_field_row(const std::string &fe_name, const std::string name_row)=0
set field row which finite element use
virtual bool check_field(const std::string &name) const =0
check if field is in database
auto bit
set bit
std::bitset< BITREFLEVEL_SIZE > BitRefLevel
Bit structure attached to each entity identifying to what mesh entity is attached.
Definition: Types.hpp:40
std::map< int, BlockData > setOfBlocks
maps block set id with appropriate BlockData
Managing BitRefLevels.
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface refernce to pointer of interface.

◆ 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 1945 of file ConvectiveMassElement.cpp.

1948 {
1950
1951 //
1952
1953 CHKERR mField.add_finite_element(element_name, MF_ZERO);
1955 velocity_field_name);
1957 velocity_field_name);
1959 element_name, spatial_position_field_name);
1961 element_name, spatial_position_field_name);
1962 if (mField.check_field(material_position_field_name)) {
1963 if (ale) {
1965 element_name, material_position_field_name);
1967 element_name, material_position_field_name);
1969 element_name, "DOT_" + material_position_field_name);
1970 }
1972 element_name, material_position_field_name);
1973 }
1975 element_name, "DOT_" + velocity_field_name);
1977 element_name, "DOT_" + spatial_position_field_name);
1978
1979 Range tets;
1980 if (bit.any()) {
1981 CHKERR mField.getInterface<BitRefManager>()->getEntitiesByTypeAndRefLevel(
1982 bit, BitRefLevel().set(), MBTET, tets);
1983 }
1984 if (intersected != NULL) {
1985 if (tets.empty()) {
1986 tets = *intersected;
1987 } else {
1988 tets = intersect(*intersected, tets);
1989 }
1990 }
1991
1992 std::map<int, BlockData>::iterator sit = setOfBlocks.begin();
1993 for (; sit != setOfBlocks.end(); sit++) {
1994 Range add_tets = sit->second.tEts;
1995 if (!tets.empty()) {
1996 add_tets = intersect(add_tets, tets);
1997 }
1999 element_name);
2000 }
2001
2003}

◆ addHOOpsVol()

MoFEMErrorCode ConvectiveMassElement::addHOOpsVol ( )
inline

Definition at line 92 of file ConvectiveMassElement.hpp.

92 {
94 auto add_ops = [&](auto &fe) {
95 return MoFEM::addHOOpsVol("MESH_NODE_POSITIONS", fe, true, false, false,
96 false);
97 };
98 CHKERR add_ops(feMassRhs);
99 CHKERR add_ops(feMassLhs);
100 CHKERR add_ops(feMassAuxLhs);
101 CHKERR add_ops(feVelRhs);
102 CHKERR add_ops(feTRhs);
103 CHKERR add_ops(feTLhs);
104 CHKERR add_ops(feEnergy);
106 }
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:346
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:416
MoFEMErrorCode addHOOpsVol(const std::string field, E &e, bool h1, bool hcurl, bool hdiv, bool l2)

◆ 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 1892 of file ConvectiveMassElement.cpp.

1895 {
1897
1898 //
1899
1900 CHKERR mField.add_finite_element(element_name, MF_ZERO);
1902 velocity_field_name);
1904 velocity_field_name);
1906 velocity_field_name);
1908 element_name, spatial_position_field_name);
1910 element_name, spatial_position_field_name);
1911 if (mField.check_field(material_position_field_name)) {
1912 if (ale) {
1914 element_name, material_position_field_name);
1916 element_name, "DOT_" + material_position_field_name);
1917 }
1919 element_name, material_position_field_name);
1920 }
1922 element_name, "DOT_" + velocity_field_name);
1924 element_name, "DOT_" + spatial_position_field_name);
1925
1926 Range tets;
1927 if (bit.any()) {
1928 CHKERR mField.getInterface<BitRefManager>()->getEntitiesByTypeAndRefLevel(
1929 bit, BitRefLevel().set(), MBTET, tets);
1930 }
1931
1932 std::map<int, BlockData>::iterator sit = setOfBlocks.begin();
1933 for (; sit != setOfBlocks.end(); sit++) {
1934 Range add_tets = sit->second.tEts;
1935 if (!tets.empty()) {
1936 add_tets = intersect(add_tets, tets);
1937 }
1939 element_name);
1940 }
1941
1943}

◆ 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
nonlinear_dynamics.cpp.

Definition at line 546 of file ConvectiveMassElement.hpp.

546 {
548
549 void *void_ctx;
550 CHKERR MatShellGetContext(A, &void_ctx);
551 MatShellCtx *ctx = (MatShellCtx *)void_ctx;
552 if (!ctx->iNitialized) {
553 CHKERR ctx->iNit();
554 }
555 CHKERR VecZeroEntries(f);
556 // Mult Ku
557 CHKERR VecScatterBegin(ctx->scatterU, x, ctx->u, INSERT_VALUES,
558 SCATTER_FORWARD);
559 CHKERR VecScatterEnd(ctx->scatterU, x, ctx->u, INSERT_VALUES,
560 SCATTER_FORWARD);
561 CHKERR MatMult(ctx->K, ctx->u, ctx->Ku);
562 CHKERR VecScatterBegin(ctx->scatterU, ctx->Ku, f, INSERT_VALUES,
563 SCATTER_REVERSE);
564 CHKERR VecScatterEnd(ctx->scatterU, ctx->Ku, f, INSERT_VALUES,
565 SCATTER_REVERSE);
566 // Mult Mv
567 CHKERR VecScatterBegin(ctx->scatterV, x, ctx->v, INSERT_VALUES,
568 SCATTER_FORWARD);
569 CHKERR VecScatterEnd(ctx->scatterV, x, ctx->v, INSERT_VALUES,
570 SCATTER_FORWARD);
571 CHKERR MatMult(ctx->M, ctx->v, ctx->Mv);
572 CHKERR VecScatterBegin(ctx->scatterU, ctx->Mv, f, ADD_VALUES,
573 SCATTER_REVERSE);
574 CHKERR VecScatterEnd(ctx->scatterU, ctx->Mv, f, ADD_VALUES,
575 SCATTER_REVERSE);
576 // Velocities
577 CHKERR VecAXPY(ctx->v, -ctx->ts_a, ctx->u);
578 // CHKERR VecScale(ctx->v,ctx->scale);
579 CHKERR VecScatterBegin(ctx->scatterV, ctx->v, f, INSERT_VALUES,
580 SCATTER_REVERSE);
581 CHKERR VecScatterEnd(ctx->scatterV, ctx->v, f, INSERT_VALUES,
582 SCATTER_REVERSE);
583 // Assemble
584 CHKERR VecAssemblyBegin(f);
585 CHKERR VecAssemblyEnd(f);
587 }
constexpr AssemblyType A

◆ 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
nonlinear_dynamics.cpp.

Definition at line 671 of file ConvectiveMassElement.hpp.

671 {
673
674 void *void_ctx;
675 CHKERR PCShellGetContext(pc, &void_ctx);
676 PCShellCtx *ctx = (PCShellCtx *)void_ctx;
677 MatShellCtx *shell_mat_ctx;
678 CHKERR MatShellGetContext(ctx->shellMat, &shell_mat_ctx);
679 // forward
680 CHKERR VecScatterBegin(shell_mat_ctx->scatterU, f, shell_mat_ctx->Ku,
681 INSERT_VALUES, SCATTER_FORWARD);
682 CHKERR VecScatterEnd(shell_mat_ctx->scatterU, f, shell_mat_ctx->Ku,
683 INSERT_VALUES, SCATTER_FORWARD);
684 CHKERR VecScatterBegin(shell_mat_ctx->scatterV, f, shell_mat_ctx->v,
685 INSERT_VALUES, SCATTER_FORWARD);
686 CHKERR VecScatterEnd(shell_mat_ctx->scatterV, f, shell_mat_ctx->v,
687 INSERT_VALUES, SCATTER_FORWARD);
688 // CHKERR VecScale(shell_mat_ctx->v,1/shell_mat_ctx->scale);
689 // apply pre-conditioner and calculate u
690 CHKERR MatMult(shell_mat_ctx->M, shell_mat_ctx->v,
691 shell_mat_ctx->Mv); // Mrv
692 CHKERR VecAXPY(shell_mat_ctx->Ku, -1, shell_mat_ctx->Mv); // f-Mrv
693 CHKERR PCApply(ctx->pC, shell_mat_ctx->Ku,
694 shell_mat_ctx->u); // u = (aM+K)^(-1)(ru-Mrv)
695 // VecView(shell_mat_ctx->u,PETSC_VIEWER_STDOUT_WORLD);
696 // calculate velocities
697 CHKERR VecAXPY(shell_mat_ctx->v, shell_mat_ctx->ts_a,
698 shell_mat_ctx->u); // v = v + a*u
699 // VecView(shell_mat_ctx->v,PETSC_VIEWER_STDOUT_WORLD);
700 // reverse
701 CHKERR VecZeroEntries(x);
702 CHKERR VecScatterBegin(shell_mat_ctx->scatterU, shell_mat_ctx->u, x,
703 INSERT_VALUES, SCATTER_REVERSE);
704 CHKERR VecScatterEnd(shell_mat_ctx->scatterU, shell_mat_ctx->u, x,
705 INSERT_VALUES, SCATTER_REVERSE);
706 CHKERR VecScatterBegin(shell_mat_ctx->scatterV, shell_mat_ctx->v, x,
707 INSERT_VALUES, SCATTER_REVERSE);
708 CHKERR VecScatterEnd(shell_mat_ctx->scatterV, shell_mat_ctx->v, x,
709 INSERT_VALUES, SCATTER_REVERSE);
710 CHKERR VecAssemblyBegin(x);
711 CHKERR VecAssemblyEnd(x);
713 }

◆ PCShellDestroy()

static MoFEMErrorCode ConvectiveMassElement::PCShellDestroy ( PC  pc)
inlinestatic
Examples
nonlinear_dynamics.cpp.

Definition at line 633 of file ConvectiveMassElement.hpp.

633 {
635
636 void *void_ctx;
637 CHKERR PCShellGetContext(pc, &void_ctx);
638 PCShellCtx *ctx = (PCShellCtx *)void_ctx;
639 CHKERR ctx->dEstroy();
641 }

◆ PCShellSetUpOp()

static MoFEMErrorCode ConvectiveMassElement::PCShellSetUpOp ( PC  pc)
inlinestatic
Examples
nonlinear_dynamics.cpp.

Definition at line 618 of file ConvectiveMassElement.hpp.

618 {
620
621 void *void_ctx;
622 CHKERR PCShellGetContext(pc, &void_ctx);
623 PCShellCtx *ctx = (PCShellCtx *)void_ctx;
624 CHKERR ctx->iNit();
625 MatShellCtx *shell_mat_ctx;
626 CHKERR MatShellGetContext(ctx->shellMat, &shell_mat_ctx);
627 CHKERR PCSetFromOptions(ctx->pC);
628 CHKERR PCSetOperators(ctx->pC, shell_mat_ctx->barK, shell_mat_ctx->barK);
629 CHKERR PCSetUp(ctx->pC);
631 }

◆ setBlocks() [1/2]

MoFEMErrorCode ConvectiveMassElement::setBlocks ( )
Examples
elasticity.cpp.

Definition at line 1761 of file ConvectiveMassElement.cpp.

1761 {
1763
1764 Range added_tets;
1766 mField, BLOCKSET | BODYFORCESSET, it)) {
1767 int id = it->getMeshsetId();
1768 EntityHandle meshset = it->getMeshset();
1769 CHKERR mField.get_moab().get_entities_by_type(meshset, MBTET,
1770 setOfBlocks[id].tEts, true);
1771 added_tets.merge(setOfBlocks[id].tEts);
1772 Block_BodyForces mydata;
1773 CHKERR it->getAttributeDataStructure(mydata);
1774 setOfBlocks[id].rho0 = mydata.data.density;
1775 setOfBlocks[id].a0.resize(3);
1776 setOfBlocks[id].a0[0] = mydata.data.acceleration_x;
1777 setOfBlocks[id].a0[1] = mydata.data.acceleration_y;
1778 setOfBlocks[id].a0[2] = mydata.data.acceleration_z;
1779 // std::cerr << setOfBlocks[id].tEts << std::endl;
1780 }
1781
1783 mField, BLOCKSET | MAT_ELASTICSET, it)) {
1784 Mat_Elastic mydata;
1785 CHKERR it->getAttributeDataStructure(mydata);
1786 if (mydata.data.User1 == 0)
1787 continue;
1788 Range tets;
1789 EntityHandle meshset = it->getMeshset();
1790 CHKERR mField.get_moab().get_entities_by_type(meshset, MBTET, tets, true);
1791 tets = subtract(tets, added_tets);
1792 if (tets.empty())
1793 continue;
1794 int id = it->getMeshsetId();
1795 setOfBlocks[-id].tEts = tets;
1796 setOfBlocks[-id].rho0 = mydata.data.User1;
1797 setOfBlocks[-id].a0.resize(3);
1798 setOfBlocks[-id].a0[0] = mydata.data.User2;
1799 setOfBlocks[-id].a0[1] = mydata.data.User3;
1800 setOfBlocks[-id].a0[2] = mydata.data.User4;
1801 // std::cerr << setOfBlocks[id].tEts << std::endl;
1802 }
1803
1805}
@ BODYFORCESSET
block name is "BODY_FORCES"
Definition: definitions.h:162
@ MAT_ELASTICSET
block name is "MAT_ELASTIC"
Definition: definitions.h:159
@ BLOCKSET
Definition: definitions.h:148
#define _IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(MESHSET_MANAGER, CUBITBCTYPE, IT)
Iterator that loops over a specific Cubit MeshSet in a moFEM field.
Body force data structure.
virtual moab::Interface & get_moab()=0
Elastic material data structure.

◆ setBlocks() [2/2]

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

Definition at line 1807 of file ConvectiveMassElement.cpp.

1809 {
1811
1812 if (!block_sets_ptr)
1813 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
1814 "Pointer to block of sets is null");
1815
1817 m_field, BLOCKSET | BODYFORCESSET, it)) {
1818 Block_BodyForces mydata;
1819 CHKERR it->getAttributeDataStructure(mydata);
1820 int id = it->getMeshsetId();
1821 auto &block_data = (*block_sets_ptr)[id];
1822 EntityHandle meshset = it->getMeshset();
1823 CHKERR m_field.get_moab().get_entities_by_dimension(meshset, 3,
1824 block_data.tEts, true);
1825 block_data.rho0 = mydata.data.density;
1826 block_data.a0.resize(3);
1827 block_data.a0[0] = mydata.data.acceleration_x;
1828 block_data.a0[1] = mydata.data.acceleration_y;
1829 block_data.a0[2] = mydata.data.acceleration_z;
1830 }
1831
1833}
@ MOFEM_DATA_INCONSISTENCY
Definition: definitions.h:31

◆ 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 2005 of file ConvectiveMassElement.cpp.

2007 {
2009
2010 commonData.spatialPositions = spatial_position_field_name;
2011 commonData.meshPositions = material_position_field_name;
2012 commonData.spatialVelocities = velocity_field_name;
2013 commonData.lInear = linear;
2014
2015 // Rhs
2016 feMassRhs.getOpPtrVector().push_back(
2017 new OpGetCommonDataAtGaussPts(velocity_field_name, commonData));
2018 feMassRhs.getOpPtrVector().push_back(
2019 new OpGetCommonDataAtGaussPts(spatial_position_field_name, commonData));
2020 feMassRhs.getOpPtrVector().push_back(
2021 new OpGetCommonDataAtGaussPts("DOT_" + velocity_field_name, commonData));
2022 feMassRhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
2023 "DOT_" + spatial_position_field_name, commonData));
2024 if (mField.check_field(material_position_field_name)) {
2025 feMassRhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
2026 material_position_field_name, commonData));
2027 if (ale) {
2028 feMassRhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
2029 "DOT_" + material_position_field_name, commonData));
2030 } else {
2031 feMassRhs.meshPositionsFieldName = material_position_field_name;
2032 }
2033 }
2034 std::map<int, BlockData>::iterator sit = setOfBlocks.begin();
2035 for (; sit != setOfBlocks.end(); sit++) {
2036 feMassRhs.getOpPtrVector().push_back(
2037 new OpMassJacobian(spatial_position_field_name, sit->second, commonData,
2038 methodsOp, tAg, false));
2039 feMassRhs.getOpPtrVector().push_back(
2040 new OpMassRhs(spatial_position_field_name, sit->second, commonData));
2041 }
2042
2043 // Lhs
2044 feMassLhs.getOpPtrVector().push_back(
2045 new OpGetCommonDataAtGaussPts(velocity_field_name, commonData));
2046 feMassLhs.getOpPtrVector().push_back(
2047 new OpGetCommonDataAtGaussPts(spatial_position_field_name, commonData));
2048 feMassLhs.getOpPtrVector().push_back(
2049 new OpGetCommonDataAtGaussPts("DOT_" + velocity_field_name, commonData));
2050 feMassLhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
2051 "DOT_" + spatial_position_field_name, commonData));
2052 if (mField.check_field(material_position_field_name)) {
2053 feMassLhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
2054 material_position_field_name, commonData));
2055 if (ale) {
2056 feMassLhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
2057 "DOT_" + material_position_field_name, commonData));
2058 } else {
2059 feMassLhs.meshPositionsFieldName = material_position_field_name;
2060 }
2061 }
2062 sit = setOfBlocks.begin();
2063 for (; sit != setOfBlocks.end(); sit++) {
2064 feMassLhs.getOpPtrVector().push_back(
2065 new OpMassJacobian(spatial_position_field_name, sit->second, commonData,
2066 methodsOp, tAg, true));
2067 feMassLhs.getOpPtrVector().push_back(
2068 new OpMassLhs_dM_dv(spatial_position_field_name, velocity_field_name,
2069 sit->second, commonData));
2070 feMassLhs.getOpPtrVector().push_back(new OpMassLhs_dM_dx(
2071 spatial_position_field_name, spatial_position_field_name, sit->second,
2072 commonData));
2073 if (mField.check_field(material_position_field_name)) {
2074 if (ale) {
2075 feMassLhs.getOpPtrVector().push_back(new OpMassLhs_dM_dX(
2076 spatial_position_field_name, material_position_field_name,
2077 sit->second, commonData));
2078 } else {
2079 feMassLhs.meshPositionsFieldName = material_position_field_name;
2080 }
2081 }
2082 }
2083
2084 // Energy
2085 feEnergy.getOpPtrVector().push_back(
2086 new OpGetCommonDataAtGaussPts(velocity_field_name, commonData));
2087 feEnergy.getOpPtrVector().push_back(
2088 new OpGetCommonDataAtGaussPts(spatial_position_field_name, commonData));
2089 if (mField.check_field(material_position_field_name)) {
2090 feEnergy.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
2091 material_position_field_name, commonData));
2092 feEnergy.meshPositionsFieldName = material_position_field_name;
2093 }
2094 sit = setOfBlocks.begin();
2095 for (; sit != setOfBlocks.end(); sit++) {
2096 feEnergy.getOpPtrVector().push_back(new OpEnergy(
2097 spatial_position_field_name, sit->second, commonData, feEnergy.V));
2098 }
2099
2101}
boost::ptr_vector< MethodForForceScaling > methodsOp

◆ 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 2181 of file ConvectiveMassElement.cpp.

2183 {
2185
2186 commonData.spatialPositions = spatial_position_field_name;
2187 commonData.meshPositions = material_position_field_name;
2188 commonData.spatialVelocities = velocity_field_name;
2189
2190 // Rhs
2191 feTRhs.getOpPtrVector().push_back(
2192 new OpGetCommonDataAtGaussPts(velocity_field_name, commonData));
2193 feTRhs.getOpPtrVector().push_back(
2194 new OpGetCommonDataAtGaussPts(spatial_position_field_name, commonData));
2195 feTRhs.getOpPtrVector().push_back(
2196 new OpGetCommonDataAtGaussPts(material_position_field_name, commonData));
2197 feTRhs.getOpPtrVector().push_back(
2198 new OpGetCommonDataAtGaussPts("DOT_" + velocity_field_name, commonData));
2199
2200 std::map<int, BlockData>::iterator sit = setOfBlocks.begin();
2201 for (; sit != setOfBlocks.end(); sit++) {
2202 feTRhs.getOpPtrVector().push_back(
2203 new OpEshelbyDynamicMaterialMomentumJacobian(
2204 material_position_field_name, sit->second, commonData, tAg, false));
2205 feTRhs.getOpPtrVector().push_back(new OpEshelbyDynamicMaterialMomentumRhs(
2206 material_position_field_name, sit->second, commonData,
2207 forces_on_entities_ptr));
2208 }
2209
2210 // Lhs
2211 feTLhs.getOpPtrVector().push_back(
2212 new OpGetCommonDataAtGaussPts(velocity_field_name, commonData));
2213 feTLhs.getOpPtrVector().push_back(
2214 new OpGetCommonDataAtGaussPts(spatial_position_field_name, commonData));
2215 feTLhs.getOpPtrVector().push_back(
2216 new OpGetCommonDataAtGaussPts("DOT_" + velocity_field_name, commonData));
2217 if (mField.check_field(material_position_field_name)) {
2218 feTLhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
2219 material_position_field_name, commonData));
2220 }
2221 sit = setOfBlocks.begin();
2222 for (; sit != setOfBlocks.end(); sit++) {
2223 feTLhs.getOpPtrVector().push_back(
2224 new OpEshelbyDynamicMaterialMomentumJacobian(
2225 material_position_field_name, sit->second, commonData, tAg));
2226 feTLhs.getOpPtrVector().push_back(
2227 new OpEshelbyDynamicMaterialMomentumLhs_dv(
2228 material_position_field_name, velocity_field_name, sit->second,
2229 commonData, forces_on_entities_ptr));
2230 feTLhs.getOpPtrVector().push_back(
2231 new OpEshelbyDynamicMaterialMomentumLhs_dx(
2232 material_position_field_name, spatial_position_field_name,
2233 sit->second, commonData, forces_on_entities_ptr));
2234 feTLhs.getOpPtrVector().push_back(
2235 new OpEshelbyDynamicMaterialMomentumLhs_dX(
2236 material_position_field_name, material_position_field_name,
2237 sit->second, commonData, forces_on_entities_ptr));
2238 }
2239
2241}

◆ 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 2243 of file ConvectiveMassElement.cpp.

2245 {
2247
2248 commonData.spatialPositions = spatial_position_field_name;
2249 commonData.meshPositions = material_position_field_name;
2250 commonData.spatialVelocities = velocity_field_name;
2251 commonData.lInear = linear;
2252
2253 // Rhs
2254 feMassRhs.getOpPtrVector().push_back(
2255 new OpGetCommonDataAtGaussPts(velocity_field_name, commonData));
2256 feMassRhs.getOpPtrVector().push_back(
2257 new OpGetCommonDataAtGaussPts(spatial_position_field_name, commonData));
2258 feMassRhs.getOpPtrVector().push_back(
2259 new OpGetCommonDataAtGaussPts("DOT_" + velocity_field_name, commonData));
2260 if (mField.check_field(material_position_field_name)) {
2261 feMassRhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
2262 material_position_field_name, commonData));
2263 feMassRhs.meshPositionsFieldName = material_position_field_name;
2264 }
2265 std::map<int, BlockData>::iterator sit = setOfBlocks.begin();
2266 for (; sit != setOfBlocks.end(); sit++) {
2267 feMassRhs.getOpPtrVector().push_back(
2268 new OpMassJacobian(spatial_position_field_name, sit->second, commonData,
2269 methodsOp, tAg, false));
2270 feMassRhs.getOpPtrVector().push_back(
2271 new OpMassRhs(spatial_position_field_name, sit->second, commonData));
2272 }
2273
2274 // Lhs
2275 feMassLhs.getOpPtrVector().push_back(
2276 new OpGetCommonDataAtGaussPts(velocity_field_name, commonData));
2277 feMassLhs.getOpPtrVector().push_back(
2278 new OpGetCommonDataAtGaussPts(spatial_position_field_name, commonData));
2279 feMassLhs.getOpPtrVector().push_back(
2280 new OpGetCommonDataAtGaussPts("DOT_" + velocity_field_name, commonData));
2281 if (mField.check_field(material_position_field_name)) {
2282 feMassLhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
2283 material_position_field_name, commonData));
2284 feMassLhs.meshPositionsFieldName = material_position_field_name;
2285 }
2286 sit = setOfBlocks.begin();
2287 for (; sit != setOfBlocks.end(); sit++) {
2288 feMassLhs.getOpPtrVector().push_back(
2289 new OpMassJacobian(spatial_position_field_name, sit->second, commonData,
2290 methodsOp, tAg, true));
2291 feMassLhs.getOpPtrVector().push_back(new OpMassLhs_dM_dv(
2292 spatial_position_field_name, spatial_position_field_name, sit->second,
2293 commonData));
2294 if (mField.check_field(material_position_field_name)) {
2295 feMassLhs.meshPositionsFieldName = material_position_field_name;
2296 }
2297 }
2298
2299 // Aux Lhs
2300 feMassAuxLhs.getOpPtrVector().push_back(
2301 new OpGetCommonDataAtGaussPts(velocity_field_name, commonData));
2302 feMassAuxLhs.getOpPtrVector().push_back(
2303 new OpGetCommonDataAtGaussPts(spatial_position_field_name, commonData));
2304 feMassAuxLhs.getOpPtrVector().push_back(
2305 new OpGetCommonDataAtGaussPts("DOT_" + velocity_field_name, commonData));
2306 if (mField.check_field(material_position_field_name)) {
2307 feMassAuxLhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
2308 material_position_field_name, commonData));
2309 feMassAuxLhs.meshPositionsFieldName = material_position_field_name;
2310 }
2311 sit = setOfBlocks.begin();
2312 for (; sit != setOfBlocks.end(); sit++) {
2313 feMassAuxLhs.getOpPtrVector().push_back(
2314 new OpMassJacobian(spatial_position_field_name, sit->second, commonData,
2315 methodsOp, tAg, true));
2316 feMassAuxLhs.getOpPtrVector().push_back(new OpMassLhs_dM_dx(
2317 spatial_position_field_name, spatial_position_field_name, sit->second,
2318 commonData));
2319 if (mField.check_field(material_position_field_name)) {
2320 feMassAuxLhs.meshPositionsFieldName = material_position_field_name;
2321 }
2322 }
2323
2324 // Energy E=0.5*rho*v*v
2325 feEnergy.getOpPtrVector().push_back(
2326 new OpGetCommonDataAtGaussPts(velocity_field_name, commonData));
2327 feEnergy.getOpPtrVector().push_back(
2328 new OpGetCommonDataAtGaussPts(spatial_position_field_name, commonData));
2329 if (mField.check_field(material_position_field_name)) {
2330 feEnergy.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
2331 material_position_field_name, commonData));
2332 feEnergy.meshPositionsFieldName = material_position_field_name;
2333 }
2334 sit = setOfBlocks.begin();
2335 for (; sit != setOfBlocks.end(); sit++) {
2336 feEnergy.getOpPtrVector().push_back(new OpEnergy(
2337 spatial_position_field_name, sit->second, commonData, feEnergy.V));
2338 }
2339
2341}

◆ 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 2103 of file ConvectiveMassElement.cpp.

2105 {
2107
2108 commonData.spatialPositions = spatial_position_field_name;
2109 commonData.meshPositions = material_position_field_name;
2110 commonData.spatialVelocities = velocity_field_name;
2111
2112 // Rhs
2113 feVelRhs.getOpPtrVector().push_back(
2114 new OpGetCommonDataAtGaussPts(velocity_field_name, commonData));
2115 feVelRhs.getOpPtrVector().push_back(
2116 new OpGetCommonDataAtGaussPts(spatial_position_field_name, commonData));
2117 feVelRhs.getOpPtrVector().push_back(
2118 new OpGetCommonDataAtGaussPts("DOT_" + velocity_field_name, commonData));
2119 if (mField.check_field(material_position_field_name)) {
2120 feVelRhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
2121 "DOT_" + spatial_position_field_name, commonData));
2122 feVelRhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
2123 material_position_field_name, commonData));
2124 if (ale) {
2125 feVelRhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
2126 "DOT_" + material_position_field_name, commonData));
2127 } else {
2128 feVelRhs.meshPositionsFieldName = material_position_field_name;
2129 }
2130 }
2131 std::map<int, BlockData>::iterator sit = setOfBlocks.begin();
2132 for (; sit != setOfBlocks.end(); sit++) {
2133 feVelRhs.getOpPtrVector().push_back(new OpVelocityJacobian(
2134 velocity_field_name, sit->second, commonData, tAg, false));
2135 feVelRhs.getOpPtrVector().push_back(
2136 new OpVelocityRhs(velocity_field_name, sit->second, commonData));
2137 }
2138
2139 // Lhs
2140 feVelLhs.getOpPtrVector().push_back(
2141 new OpGetCommonDataAtGaussPts(velocity_field_name, commonData));
2142 feVelLhs.getOpPtrVector().push_back(
2143 new OpGetCommonDataAtGaussPts(spatial_position_field_name, commonData));
2144 feVelLhs.getOpPtrVector().push_back(
2145 new OpGetCommonDataAtGaussPts("DOT_" + velocity_field_name, commonData));
2146 if (mField.check_field(material_position_field_name)) {
2147 feVelLhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
2148 "DOT_" + spatial_position_field_name, commonData));
2149 feVelLhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
2150 material_position_field_name, commonData));
2151 if (ale) {
2152 feVelLhs.getOpPtrVector().push_back(new OpGetCommonDataAtGaussPts(
2153 "DOT_" + material_position_field_name, commonData));
2154 } else {
2155 feVelLhs.meshPositionsFieldName = material_position_field_name;
2156 }
2157 }
2158 sit = setOfBlocks.begin();
2159 for (; sit != setOfBlocks.end(); sit++) {
2160 feVelLhs.getOpPtrVector().push_back(new OpVelocityJacobian(
2161 velocity_field_name, sit->second, commonData, tAg));
2162 feVelLhs.getOpPtrVector().push_back(new OpVelocityLhs_dV_dv(
2163 velocity_field_name, velocity_field_name, sit->second, commonData));
2164 feVelLhs.getOpPtrVector().push_back(new OpVelocityLhs_dV_dx(
2165 velocity_field_name, spatial_position_field_name, sit->second,
2166 commonData));
2167 if (mField.check_field(material_position_field_name)) {
2168 if (ale) {
2169 feVelLhs.getOpPtrVector().push_back(new OpVelocityLhs_dV_dX(
2170 velocity_field_name, material_position_field_name, sit->second,
2171 commonData));
2172 } else {
2173 feVelLhs.meshPositionsFieldName = material_position_field_name;
2174 }
2175 }
2176 }
2177
2179}

◆ ZeroEntriesOp()

static MoFEMErrorCode ConvectiveMassElement::ZeroEntriesOp ( Mat  A)
inlinestatic
Examples
nonlinear_dynamics.cpp.

Definition at line 589 of file ConvectiveMassElement.hpp.

589 {
591
592 void *void_ctx;
593 CHKERR MatShellGetContext(A, &void_ctx);
594 MatShellCtx *ctx = (MatShellCtx *)void_ctx;
595 CHKERR MatZeroEntries(ctx->K);
596 CHKERR MatZeroEntries(ctx->M);
598 }

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: