v0.14.0
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 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

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::Interface & mField
 
short int tAg
 
std::map< int, BlockData > setOfBlocks
 maps block set id with appropriate BlockData More...
 
CommonData commonData
 
boost::ptr_vector< MethodForForceScaling > methodsOp
 

Detailed Description

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

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

\ nonlinear_elastic_elem

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) {}

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  {
1839  MoFEMFunctionBeginHot;
1840 
1841  //
1842 
1843  CHKERR mField.add_finite_element(element_name, MF_ZERO);
1844  CHKERR mField.modify_finite_element_add_field_row(element_name,
1845  velocity_field_name);
1846  CHKERR mField.modify_finite_element_add_field_col(element_name,
1847  velocity_field_name);
1848  CHKERR mField.modify_finite_element_add_field_data(element_name,
1849  velocity_field_name);
1850  CHKERR mField.modify_finite_element_add_field_row(
1851  element_name, spatial_position_field_name);
1852  CHKERR mField.modify_finite_element_add_field_col(
1853  element_name, spatial_position_field_name);
1854  CHKERR mField.modify_finite_element_add_field_data(
1855  element_name, spatial_position_field_name);
1856  if (mField.check_field(material_position_field_name)) {
1857  if (ale) {
1858  CHKERR mField.modify_finite_element_add_field_row(
1859  element_name, material_position_field_name);
1860  CHKERR mField.modify_finite_element_add_field_col(
1861  element_name, material_position_field_name);
1862  CHKERR mField.modify_finite_element_add_field_data(
1863  element_name, "DOT_" + material_position_field_name);
1864  }
1865  CHKERR mField.modify_finite_element_add_field_data(
1866  element_name, material_position_field_name);
1867  }
1868  CHKERR mField.modify_finite_element_add_field_data(
1869  element_name, "DOT_" + velocity_field_name);
1870  CHKERR mField.modify_finite_element_add_field_data(
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  }
1885  CHKERR mField.add_ents_to_finite_element_by_type(add_tets, MBTET,
1886  element_name);
1887  }
1888 
1889  MoFEMFunctionReturnHot(0);
1890 }

◆ 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  {
1949  MoFEMFunctionBeginHot;
1950 
1951  //
1952 
1953  CHKERR mField.add_finite_element(element_name, MF_ZERO);
1954  CHKERR mField.modify_finite_element_add_field_col(element_name,
1955  velocity_field_name);
1956  CHKERR mField.modify_finite_element_add_field_data(element_name,
1957  velocity_field_name);
1958  CHKERR mField.modify_finite_element_add_field_col(
1959  element_name, spatial_position_field_name);
1960  CHKERR mField.modify_finite_element_add_field_data(
1961  element_name, spatial_position_field_name);
1962  if (mField.check_field(material_position_field_name)) {
1963  if (ale) {
1964  CHKERR mField.modify_finite_element_add_field_row(
1965  element_name, material_position_field_name);
1966  CHKERR mField.modify_finite_element_add_field_col(
1967  element_name, material_position_field_name);
1968  CHKERR mField.modify_finite_element_add_field_data(
1969  element_name, "DOT_" + material_position_field_name);
1970  }
1971  CHKERR mField.modify_finite_element_add_field_data(
1972  element_name, material_position_field_name);
1973  }
1974  CHKERR mField.modify_finite_element_add_field_data(
1975  element_name, "DOT_" + velocity_field_name);
1976  CHKERR mField.modify_finite_element_add_field_data(
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  }
1998  CHKERR mField.add_ents_to_finite_element_by_type(add_tets, MBTET,
1999  element_name);
2000  }
2001 
2002  MoFEMFunctionReturnHot(0);
2003 }

◆ addHOOpsVol()

MoFEMErrorCode ConvectiveMassElement::addHOOpsVol ( )
inline

Definition at line 92 of file ConvectiveMassElement.hpp.

92  {
93  MoFEMFunctionBegin;
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);
105  MoFEMFunctionReturn(0);
106  }

◆ 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  {
1896  MoFEMFunctionBeginHot;
1897 
1898  //
1899 
1900  CHKERR mField.add_finite_element(element_name, MF_ZERO);
1901  CHKERR mField.modify_finite_element_add_field_row(element_name,
1902  velocity_field_name);
1903  CHKERR mField.modify_finite_element_add_field_col(element_name,
1904  velocity_field_name);
1905  CHKERR mField.modify_finite_element_add_field_data(element_name,
1906  velocity_field_name);
1907  CHKERR mField.modify_finite_element_add_field_col(
1908  element_name, spatial_position_field_name);
1909  CHKERR mField.modify_finite_element_add_field_data(
1910  element_name, spatial_position_field_name);
1911  if (mField.check_field(material_position_field_name)) {
1912  if (ale) {
1913  CHKERR mField.modify_finite_element_add_field_col(
1914  element_name, material_position_field_name);
1915  CHKERR mField.modify_finite_element_add_field_data(
1916  element_name, "DOT_" + material_position_field_name);
1917  }
1918  CHKERR mField.modify_finite_element_add_field_data(
1919  element_name, material_position_field_name);
1920  }
1921  CHKERR mField.modify_finite_element_add_field_data(
1922  element_name, "DOT_" + velocity_field_name);
1923  CHKERR mField.modify_finite_element_add_field_data(
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  }
1938  CHKERR mField.add_ents_to_finite_element_by_type(add_tets, MBTET,
1939  element_name);
1940  }
1941 
1942  MoFEMFunctionReturnHot(0);
1943 }

◆ 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  {
547  MoFEMFunctionBeginHot;
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);
586  MoFEMFunctionReturnHot(0);
587  }

◆ 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  {
672  MoFEMFunctionBeginHot;
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);
712  MoFEMFunctionReturnHot(0);
713  }

◆ PCShellDestroy()

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

Definition at line 633 of file ConvectiveMassElement.hpp.

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

◆ PCShellSetUpOp()

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

Definition at line 618 of file ConvectiveMassElement.hpp.

618  {
619  MoFEMFunctionBeginHot;
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);
630  MoFEMFunctionReturnHot(0);
631  }

◆ setBlocks() [1/2]

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

Definition at line 1761 of file ConvectiveMassElement.cpp.

1761  {
1762  MoFEMFunctionBeginHot;
1763 
1764  Range added_tets;
1765  for (_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(
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 
1782  for (_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(
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 
1804  MoFEMFunctionReturnHot(0);
1805 }

◆ 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  {
1810  MoFEMFunctionBegin;
1811 
1812  if (!block_sets_ptr)
1813  SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
1814  "Pointer to block of sets is null");
1815 
1816  for (_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(
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 
1832  MoFEMFunctionReturn(0);
1833 }

◆ 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  {
2008  MoFEMFunctionBeginHot;
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 
2100  MoFEMFunctionReturnHot(0);
2101 }

◆ 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  {
2184  MoFEMFunctionBeginHot;
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 
2240  MoFEMFunctionReturnHot(0);
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  {
2246  MoFEMFunctionBeginHot;
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 
2340  MoFEMFunctionReturnHot(0);
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  {
2106  MoFEMFunctionBeginHot;
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 
2178  MoFEMFunctionReturnHot(0);
2179 }

◆ ZeroEntriesOp()

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

Definition at line 589 of file ConvectiveMassElement.hpp.

589  {
590  MoFEMFunctionBeginHot;
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);
597  MoFEMFunctionReturnHot(0);
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:
MoFEMFunctionReturnHot
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:447
MoFEM::UnknownInterface::getInterface
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface refernce to pointer of interface.
Definition: UnknownInterface.hpp:93
MoFEM::Block_BodyForces
Body force data structure.
Definition: MaterialBlocks.hpp:313
EntityHandle
MoFEM::addHOOpsVol
MoFEMErrorCode addHOOpsVol(const std::string field, E &e, bool h1, bool hcurl, bool hdiv, bool l2)
Definition: HODataOperators.hpp:764
ConvectiveMassElement::feVelLhs
MyVolumeFE feVelLhs
calculate left hand side for tetrahedral elements
Definition: ConvectiveMassElement.hpp:79
MoFEM::CoreInterface::modify_finite_element_add_field_row
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
MoFEM::Mat_Elastic
Elastic material data structure.
Definition: MaterialBlocks.hpp:139
_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_
#define _IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(MESHSET_MANAGER, CUBITBCTYPE, IT)
Iterator that loops over a specific Cubit MeshSet in a moFEM field.
Definition: MeshsetsManager.hpp:49
A
constexpr AssemblyType A
Definition: operators_tests.cpp:30
ConvectiveMassElement::feEnergy
MyVolumeFE feEnergy
calculate kinetic energy
Definition: ConvectiveMassElement.hpp:87
ConvectiveMassElement::CommonData::spatialVelocities
string spatialVelocities
Definition: ConvectiveMassElement.hpp:137
MoFEM::CoreInterface::add_ents_to_finite_element_by_type
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
CHKERR
#define CHKERR
Inline error check.
Definition: definitions.h:535
MoFEM::CoreInterface::add_finite_element
virtual MoFEMErrorCode add_finite_element(const std::string &fe_name, enum MoFEMTypes bh=MF_EXCL, int verb=DEFAULT_VERBOSITY)=0
add finite element
MoFEM::CoreInterface::get_moab
virtual moab::Interface & get_moab()=0
MoFEM::CoreInterface::modify_finite_element_add_field_col
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
ConvectiveMassElement::setOfBlocks
std::map< int, BlockData > setOfBlocks
maps block set id with appropriate BlockData
Definition: ConvectiveMassElement.hpp:122
ConvectiveMassElement::feVelRhs
MyVolumeFE feVelRhs
calculate right hand side for tetrahedral elements
Definition: ConvectiveMassElement.hpp:77
BODYFORCESSET
@ BODYFORCESSET
block name is "BODY_FORCES"
Definition: definitions.h:162
bit
auto bit
set bit
Definition: hanging_node_approx.cpp:75
MAT_ELASTICSET
@ MAT_ELASTICSET
block name is "MAT_ELASTIC"
Definition: definitions.h:159
ConvectiveMassElement::feMassAuxLhs
MyVolumeFE feMassAuxLhs
Definition: ConvectiveMassElement.hpp:71
MoFEM::Mat_Elastic::data
_data_ data
Definition: MaterialBlocks.hpp:155
MoFEM::CoreInterface::check_field
virtual bool check_field(const std::string &name) const =0
check if field is in database
ConvectiveMassElement::CommonData::spatialPositions
string spatialPositions
Definition: ConvectiveMassElement.hpp:135
ConvectiveMassElement::CommonData::lInear
bool lInear
Definition: ConvectiveMassElement.hpp:129
ConvectiveMassElement::methodsOp
boost::ptr_vector< MethodForForceScaling > methodsOp
Definition: ConvectiveMassElement.hpp:150
MoFEM::Block_BodyForces::data
_data_ data
Definition: MaterialBlocks.hpp:328
ConvectiveMassElement::MyVolumeFE::V
SmartPetscObj< Vec > V
Definition: ConvectiveMassElement.hpp:55
Range
ConvectiveMassElement::commonData
CommonData commonData
Definition: ConvectiveMassElement.hpp:148
MF_ZERO
@ MF_ZERO
Definition: definitions.h:98
ConvectiveMassElement::feMassLhs
MyVolumeFE feMassLhs
Definition: ConvectiveMassElement.hpp:66
HenckyOps::f
auto f
Definition: HenckyOps.hpp:15
BLOCKSET
@ BLOCKSET
Definition: definitions.h:148
MOFEM_DATA_INCONSISTENCY
@ MOFEM_DATA_INCONSISTENCY
Definition: definitions.h:31
MoFEM::CoreInterface::modify_finite_element_add_field_data
virtual MoFEMErrorCode modify_finite_element_add_field_data(const std::string &fe_name, const std::string name_filed)=0
set finite element field data
ConvectiveMassElement::feTLhs
MyVolumeFE feTLhs
calculate left hand side for tetrahedral elements
Definition: ConvectiveMassElement.hpp:84
ConvectiveMassElement::CommonData::meshPositions
string meshPositions
Definition: ConvectiveMassElement.hpp:136
MoFEM::BitRefManager
Managing BitRefLevels.
Definition: BitRefManager.hpp:21
MoFEM::Types::BitRefLevel
std::bitset< BITREFLEVEL_SIZE > BitRefLevel
Bit structure attached to each entity identifying to what mesh entity is attached.
Definition: Types.hpp:40
MoFEMFunctionBeginHot
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:440
ConvectiveMassElement::feMassRhs
MyVolumeFE feMassRhs
calculate right hand side for tetrahedral elements
Definition: ConvectiveMassElement.hpp:62
ConvectiveMassElement::mField
MoFEM::Interface & mField
Definition: ConvectiveMassElement.hpp:108
ConvectiveMassElement::feTRhs
MyVolumeFE feTRhs
calculate right hand side for tetrahedral elements
Definition: ConvectiveMassElement.hpp:82
MoFEMFunctionReturn
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:416
MoFEMFunctionBegin
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:346
ConvectiveMassElement::tAg
short int tAg
Definition: ConvectiveMassElement.hpp:109
Generated by Doxygen 1.8.17 and hosted at University of Glasgow