Distributed mesh manager

Implementation of PETSc DM, managing interactions between mesh data structures and vectors and matrices. More...

Collaboration diagram for Distributed mesh manager:

Classes
struct	MoFEM::DMCtx
	PETSc Discrete Manager data structure. More...
struct	MoFEM::DMMGViaApproxOrdersCtx
	Structure for DM for multi-grid via approximation orders. More...

Functions
PetscErrorCode	MoFEM::DMRegister_MoFEM (const char sname[])
	Register MoFEM problem.
PetscErrorCode	MoFEM::DMMoFEMCreateMoFEM (DM dm, MoFEM::Interface *m_field_ptr, const char problem_name[], const MoFEM::BitRefLevel bit_level, const MoFEM::BitRefLevel bit_mask=MoFEM::BitRefLevel().set())
	Must be called by user to set MoFEM data structures.
PetscErrorCode	MoFEM::DMMoFEMCreateSubDM (DM subdm, DM dm, const char problem_name[])
	Must be called by user to set Sub DM MoFEM data structures.
PetscErrorCode	MoFEM::DMoFEMGetInterfacePtr (DM dm, MoFEM::Interface **m_field_ptr)
	Get pointer to MoFEM::Interface.
PetscErrorCode	MoFEM::DMMoFEMGetProblemPtr (DM dm, const MoFEM::Problem **problem_ptr)
	Get pointer to problem data structure.
PetscErrorCode	MoFEM::DMMoFEMSetSquareProblem (DM dm, PetscBool square_problem)
	set squared problem
PetscErrorCode	MoFEM::DMMoFEMGetSquareProblem (DM dm, PetscBool *square_problem)
	get squared problem
PetscErrorCode	MoFEM::DMMoFEMResolveSharedFiniteElements (DM dm, std::string fe_name)
	Resolve shared entities.
PetscErrorCode	MoFEM::DMMoFEMGetProblemFiniteElementLayout (DM dm, std::string fe_name, PetscLayout *layout)
	Get finite elements layout in the problem.
PetscErrorCode	MoFEM::DMMoFEMAddElement (DM dm, std::string fe_name)
	add element to dm
PetscErrorCode	MoFEM::DMMoFEMAddElement (DM dm, std::vector< std::string > fe_name)
	add element to dm
PetscErrorCode	MoFEM::DMMoFEMUnSetElement (DM dm, std::string fe_name)
	unset element from dm
PetscErrorCode	MoFEM::DMoFEMMeshToLocalVector (DM dm, Vec l, InsertMode mode, ScatterMode scatter_mode)
	set local (or ghosted) vector values on mesh for partition only
PetscErrorCode	MoFEM::DMoFEMMeshToGlobalVector (DM dm, Vec g, InsertMode mode, ScatterMode scatter_mode)
	set ghosted vector values on all existing mesh entities
PetscErrorCode	MoFEM::DMoFEMPreProcessFiniteElements (DM dm, MoFEM::FEMethod *method)
	execute finite element method for each element in dm (problem)
PetscErrorCode	MoFEM::DMoFEMPostProcessFiniteElements (DM dm, MoFEM::FEMethod *method)
	execute finite element method for each element in dm (problem)
PetscErrorCode	MoFEM::DMoFEMLoopFiniteElementsUpAndLowRank (DM dm, const char fe_name[], MoFEM::FEMethod *method, int low_rank, int up_rank, CacheTupleWeakPtr cache_ptr=CacheTupleSharedPtr())
	Executes FEMethod for finite elements in DM.
PetscErrorCode	MoFEM::DMoFEMLoopFiniteElementsUpAndLowRank (DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, int low_rank, int up_rank, CacheTupleWeakPtr cache_ptr=CacheTupleSharedPtr())
	Executes FEMethod for finite elements in DM.
PetscErrorCode	MoFEM::DMoFEMLoopFiniteElements (DM dm, const char fe_name[], MoFEM::FEMethod *method, CacheTupleWeakPtr cache_ptr=CacheTupleSharedPtr())
	Executes FEMethod for finite elements in DM.
PetscErrorCode	MoFEM::DMoFEMLoopFiniteElements (DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, CacheTupleWeakPtr cache_ptr=CacheTupleSharedPtr())
	Executes FEMethod for finite elements in DM.
PetscErrorCode	MoFEM::DMoFEMLoopDofs (DM dm, const char field_name[], MoFEM::DofMethod *method)
	execute method for dofs on field in problem
PetscErrorCode	MoFEM::DMMoFEMKSPSetComputeRHS (DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
	Set compute operator for KSP solver via sub-matrix and IS.
PetscErrorCode	MoFEM::DMMoFEMKSPSetComputeRHS (DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
	set KSP right hand side evaluation function
PetscErrorCode	MoFEM::DMMoFEMKSPSetComputeOperators (DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
	Set KSP operators and push mofem finite element methods.
PetscErrorCode	MoFEM::DMMoFEMKSPSetComputeOperators (DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
	Set KSP operators and push mofem finite element methods.
PetscErrorCode	MoFEM::DMMoFEMSNESSetFunction (DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
	set SNES residual evaluation function
PetscErrorCode	MoFEM::DMMoFEMSNESSetFunction (DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
	set SNES residual evaluation function
PetscErrorCode	MoFEM::DMMoFEMSNESSetJacobian (DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
	set SNES Jacobian evaluation function
PetscErrorCode	MoFEM::DMMoFEMSNESSetJacobian (DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
	set SNES Jacobian evaluation function
PetscErrorCode	MoFEM::DMMoFEMTSSetIFunction (DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
	set TS implicit function evaluation function
PetscErrorCode	MoFEM::DMMoFEMTSSetIFunction (DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
	set TS implicit function evaluation function
PetscErrorCode	MoFEM::DMMoFEMTSSetIJacobian (DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
	set TS Jacobian evaluation function
PetscErrorCode	MoFEM::DMMoFEMTSSetIJacobian (DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
	set TS Jacobian evaluation function
PetscErrorCode	MoFEM::DMMoFEMTSSetI2Function (DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
	set TS implicit function evaluation function
PetscErrorCode	MoFEM::DMMoFEMTSSetI2Function (DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
	set TS implicit function evaluation function
PetscErrorCode	MoFEM::DMMoFEMTSSetI2Jacobian (DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
	set TS Jacobian evaluation function
PetscErrorCode	MoFEM::DMMoFEMTSSetI2Jacobian (DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
	set TS Jacobian evaluation function
PetscErrorCode	MoFEM::DMMoFEMGetKspCtx (DM dm, MoFEM::KspCtx **ksp_ctx)
	get MoFEM::KspCtx data structure
PetscErrorCode	MoFEM::DMMoFEMGetKspCtx (DM dm, const boost::shared_ptr< MoFEM::KspCtx > &ksp_ctx)
	get MoFEM::KspCtx data structure
PetscErrorCode	MoFEM::DMMoFEMSetKspCtx (DM dm, boost::shared_ptr< MoFEM::KspCtx > ksp_ctx)
	set MoFEM::KspCtx data structure
PetscErrorCode	MoFEM::DMMoFEMGetSnesCtx (DM dm, MoFEM::SnesCtx **snes_ctx)
	get MoFEM::SnesCtx data structure
PetscErrorCode	MoFEM::DMMoFEMGetSnesCtx (DM dm, const boost::shared_ptr< MoFEM::SnesCtx > &snes_ctx)
	get MoFEM::SnesCtx data structure
PetscErrorCode	MoFEM::DMMoFEMSetSnesCtx (DM dm, boost::shared_ptr< MoFEM::SnesCtx > snes_ctx)
	Set MoFEM::SnesCtx data structure.
PetscErrorCode	MoFEM::DMMoFEMGetTsCtx (DM dm, MoFEM::TsCtx **ts_ctx)
	get MoFEM::TsCtx data structure
PetscErrorCode	MoFEM::DMMoFEMGetTsCtx (DM dm, const boost::shared_ptr< MoFEM::TsCtx > &ts_ctx)
	get MoFEM::TsCtx data structure
PetscErrorCode	MoFEM::DMMoFEMSetTsCtx (DM dm, boost::shared_ptr< MoFEM::TsCtx > ts_ctx)
	Set MoFEM::TsCtx data structure.
PetscErrorCode	MoFEM::DMMoFEMSetIsPartitioned (DM dm, PetscBool is_partitioned)
PetscErrorCode	MoFEM::DMMoFEMGetIsPartitioned (DM dm, PetscBool *is_partitioned)
PetscErrorCode	MoFEM::DMSetOperators_MoFEM (DM dm)
	Set operators for MoFEM dm.
PetscErrorCode	MoFEM::DMCreate_MoFEM (DM dm)
	Create dm data structure with MoFEM data structure.
PetscErrorCode	MoFEM::DMDestroy_MoFEM (DM dm)
	Destroys dm with MoFEM data structure.
PetscErrorCode	MoFEM::DMCreateGlobalVector_MoFEM (DM dm, Vec *g)
	DMShellSetCreateGlobalVector.
PetscErrorCode	MoFEM::DMCreateGlobalVector_MoFEM (DM dm, SmartPetscObj< Vec > &g_ptr)
	DMShellSetCreateGlobalVector.
PetscErrorCode	MoFEM::DMCreateLocalVector_MoFEM (DM dm, Vec *l)
	DMShellSetCreateLocalVector.
PetscErrorCode	MoFEM::DMCreateMatrix_MoFEM (DM dm, Mat *M)
PetscErrorCode	MoFEM::DMCreateMatrix_MoFEM (DM dm, SmartPetscObj< Mat > &M)
PetscErrorCode	MoFEM::DMSetFromOptions_MoFEM (DM dm)
PetscErrorCode	MoFEM::DMSetUp_MoFEM (DM dm)
PetscErrorCode	MoFEM::DMSubDMSetUp_MoFEM (DM subdm)
PetscErrorCode	MoFEM::DMMoFEMAddSubFieldRow (DM dm, const char field_name[])
PetscErrorCode	MoFEM::DMMoFEMAddSubFieldRow (DM dm, const char field_name[], boost::shared_ptr< Range > r_ptr)
	Add field to sub dm problem on rows.
PetscErrorCode	MoFEM::DMMoFEMAddSubFieldCol (DM dm, const char field_name[])
PetscErrorCode	MoFEM::DMMoFEMGetIsSubDM (DM dm, PetscBool *is_sub_dm)
PetscErrorCode	MoFEM::DMMoFEMAddRowCompositeProblem (DM dm, const char prb_name[])
	Add problem to composite DM on row.
PetscErrorCode	MoFEM::DMMoFEMAddColCompositeProblem (DM dm, const char prb_name[])
	Add problem to composite DM on col.
PetscErrorCode	MoFEM::DMMoFEMGetIsCompDM (DM dm, PetscBool *is_comp_dm)
	Get if this DM is composite DM.
PetscErrorCode	MoFEM::DMGlobalToLocalBegin_MoFEM (DM dm, Vec, InsertMode, Vec)
PetscErrorCode	MoFEM::DMGlobalToLocalEnd_MoFEM (DM dm, Vec, InsertMode, Vec)
PetscErrorCode	MoFEM::DMLocalToGlobalBegin_MoFEM (DM, Vec, InsertMode, Vec)
PetscErrorCode	MoFEM::DMLocalToGlobalEnd_MoFEM (DM, Vec, InsertMode, Vec)
PetscErrorCode	MoFEM::DMCreateFieldIS_MoFEM (DM dm, PetscInt *numFields, char ***fieldNames, IS **fields)
PetscErrorCode	MoFEM::DMMoFEMGetFieldIS (DM dm, RowColData rc, const char field_name[], IS *is)
	get field is in the problem
MoFEMErrorCode	MoFEM::DMMoFEMCreateBlockMat (DM dm, Mat *mat)
	Create block matrix.
MoFEMErrorCode	MoFEM::DMMoFEMCreateBlockMat (DM dm, SmartPetscObj< Mat > &mat)
	Create block matrix.
auto	MoFEM::createDMMatrix (DM dm)
	Get smart matrix from DM.
auto	MoFEM::createDMVector (DM dm)
	Get smart vector from DM.
MoFEMErrorCode	MoFEM::DMMGViaApproxOrdersPushBackCoarseningIS (DM, IS is, Mat A, bool create_sub_matrix, bool shell_sub_a)
	Push back coarsening level to MG via approximation orders.
MoFEMErrorCode	MoFEM::DMMGViaApproxOrdersPopBackCoarseningIS (DM)
	Pop IS form MG via approximation orders.
MoFEMErrorCode	MoFEM::DMMGViaApproxOrdersClearCoarseningIS (DM)
	Clear approximation orders.
MoFEMErrorCode	MoFEM::DMRegister_MGViaApproxOrders (const char sname[])
	Register DM for Multi-Grid via approximation orders.
MoFEMErrorCode	MoFEM::DMCreateMatrix_MGViaApproxOrders (DM dm, Mat *M)
	Create matrix for Multi-Grid via approximation orders.
MoFEMErrorCode	MoFEM::DMCoarsen_MGViaApproxOrders (DM dm, MPI_Comm comm, DM *dmc)
	Coarsen DM.

Detailed Description

Implementation of PETSc DM, managing interactions between mesh data structures and vectors and matrices.

DM objects are used to manage communication between the algebraic structures in PETSc (Vec and Mat) and mesh data structures in PDE-based (or other) simulations.

DM is abstract interface, here is it particular implementation for MoFEM code.

Function Documentation

createDMMatrix()

auto MoFEM::createDMMatrix ( DM dm )

inline

#include <src/petsc/DMMoFEM.hpp>

Get smart matrix from DM.

Examples

free_surface.cpp, level_set.cpp, mofem/tutorials/vec-7/adjoint.cpp, and navier_stokes.cpp.

Definition at line 1059 of file DMMoFEM.hpp.

                                  {
  SmartPetscObj<Mat> a;
  ierr = DMCreateMatrix_MoFEM(dm, a);
  CHKERRABORT(getCommFromPetscObject(reinterpret_cast<PetscObject>(dm)), ierr);
  return a;
};

createDMVector()

auto MoFEM::createDMVector ( DM dm )

inline

#include <src/petsc/DMMoFEM.hpp>

Get smart vector from DM.

Examples

adolc_plasticity.cpp, approx_sphere.cpp, child_and_parent.cpp, dg_projection.cpp, dynamic_first_order_con_law.cpp, eigen_elastic.cpp, free_surface.cpp, hanging_node_approx.cpp, heat_method.cpp, helmholtz.cpp, higher_derivatives.cpp, level_set.cpp, mixed_poisson.cpp, mofem/tutorials/vec-7/adjoint.cpp, navier_stokes.cpp, phase.cpp, plate.cpp, poisson_2d_dis_galerkin.cpp, poisson_2d_homogeneous.cpp, and shallow_wave.cpp.

Definition at line 1102 of file DMMoFEM.hpp.

                                  {
  SmartPetscObj<Vec> v;
  ierr = DMCreateGlobalVector_MoFEM(dm, v);
  CHKERRABORT(getCommFromPetscObject(reinterpret_cast<PetscObject>(dm)), ierr);
  return v;
};

DMCoarsen_MGViaApproxOrders()

MoFEMErrorCode MoFEM::DMCoarsen_MGViaApproxOrders	(	DM	dm,
		MPI_Comm	comm,
		DM *	dmc )

#include <src/petsc/impl/PCMGSetUpViaApproxOrders.cpp>

Coarsen DM.

Not used directly by user

Parameters

dm	Distributed mesh data structure
comm	Communicator
dmc	Coarse distributed mesh data structure

Returns

Error code

Definition at line 386 of file PCMGSetUpViaApproxOrders.cpp.

                                                                          {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  GET_DM_FIELD(dm);
  CHKERR PetscObjectGetComm((PetscObject)dm, &comm);
  CHKERR DMCreate(comm, dmc);
  (*dmc)->data = dm->data;
  DMType type;
  CHKERR DMGetType(dm, &type);
  CHKERR DMSetType(*dmc, type);
  dm_field->coarsenDM = SmartPetscObj<DM>(*dmc, false);
#if PETSC_VERSION_GE(3, 17, 0)
  PetscInfo(dm, "Coarsen DMMGViaApproxOrders leveldown = %d\n", dm->leveldown);
#else
  PetscInfo1(dm, "Coarsen DMMGViaApproxOrders leveldown = %d\n", dm->leveldown);
#endif
  MoFEMFunctionReturn(0);
}

DMCreate_MoFEM()

PetscErrorCode MoFEM::DMCreate_MoFEM

(

DM

dm

)

#include <src/petsc/DMMoFEM.hpp>

Create dm data structure with MoFEM data structure.

Definition at line 71 of file DMMoFEM.cpp.

                                     {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  dm->data = new DMCtxImpl();
  CHKERR DMSetOperators_MoFEM(dm);
  MoFEMFunctionReturn(0);
}

DMCreateFieldIS_MoFEM()

PetscErrorCode MoFEM::DMCreateFieldIS_MoFEM	(	DM	dm,
		PetscInt *	numFields,
		char ***	fieldNames,
		IS **	fields )

#include <src/petsc/DMMoFEM.hpp>

Creates a set of IS objects with the global indices of dofs for each field

Parameters

dm	The number of fields (or NULL if not requested)

Output:

Parameters

numFields	The number of fields (or NULL if not requested)
fieldNames	The name for each field (or NULL if not requested)
fields	The global indices for each field (or NULL if not requested)

Returns

error code

Note

The user is responsible for freeing all requested arrays. In particular, every entry of names should be freed with PetscFree(), every entry of fields should be destroyed with ISDestroy(), and both arrays should be freed with PetscFree().

Definition at line 1461 of file DMMoFEM.cpp.

                                                                      {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
 
  if (numFields) {
    *numFields = 0;
  }
  if (fieldNames) {
    *fieldNames = NULL;
  }
  if (fields) {
    *fields = NULL;
  }
 
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  auto fields_ptr = dm_field->mField_ptr->get_fields();
  Field_multiIndex::iterator fit, hi_fit;
  fit = fields_ptr->begin();
  hi_fit = fields_ptr->end();
  *numFields = std::distance(fit, hi_fit);
 
  if (fieldNames) {
    CHKERR PetscMalloc1(*numFields, fieldNames);
  }
  if (fields) {
    CHKERR PetscMalloc1(*numFields, fields);
  }
 
  for (int f = 0; fit != hi_fit; fit++, f++) {
    if (fieldNames) {
      CHKERR PetscStrallocpy(fit->get()->getName().c_str(),
                             (char **)&(*fieldNames)[f]);
    }
    if (fields) {
      CHKERR dm_field->mField_ptr->getInterface<ISManager>()
          ->isCreateProblemFieldAndRank(
              dm_field->problemPtr->getName(), ROW, fit->get()->getName(), 0,
              fit->get()->getNbOfCoeffs(), &(*fields)[f]);
    }
  }
 
  MoFEMFunctionReturn(0);
}

DMCreateGlobalVector_MoFEM() [1/2]

PetscErrorCode MoFEM::DMCreateGlobalVector_MoFEM	(	DM	dm,
		SmartPetscObj< Vec > &	g_ptr )

#include <src/petsc/DMMoFEM.hpp>

DMShellSetCreateGlobalVector.

sets the routine to create a global vector associated with the shell DM

Definition at line 1167 of file DMMoFEM.cpp.

                                                                            {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  CHKERR dm_field->mField_ptr->getInterface<VecManager>()->vecCreateGhost(
      dm_field->problemName, COL, g_ptr);
  CHKERR VecSetDM(g_ptr, dm);
  MoFEMFunctionReturn(0);
}

DMCreateGlobalVector_MoFEM() [2/2]

PetscErrorCode MoFEM::DMCreateGlobalVector_MoFEM	(	DM	dm,
		Vec *	g )

#include <src/petsc/DMMoFEM.hpp>

DMShellSetCreateGlobalVector.

sets the routine to create a global vector associated with the shell DM

Definition at line 1157 of file DMMoFEM.cpp.

                                                         {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  CHKERR dm_field->mField_ptr->getInterface<VecManager>()->vecCreateGhost(
      dm_field->problemName, COL, g);
  CHKERR VecSetDM(*g, dm);
  MoFEMFunctionReturn(0);
}

DMCreateLocalVector_MoFEM()

PetscErrorCode MoFEM::DMCreateLocalVector_MoFEM	(	DM	dm,
		Vec *	l )

#include <src/petsc/DMMoFEM.hpp>

DMShellSetCreateLocalVector.

sets the routine to create a local vector associated with the shell DM

Definition at line 1177 of file DMMoFEM.cpp.

                                                        {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  CHKERR dm_field->mField_ptr->getInterface<VecManager>()->vecCreateSeq(
      dm_field->problemName, COL, l);
  CHKERR VecSetDM(*l, dm);
  MoFEMFunctionReturn(0);
}

DMCreateMatrix_MGViaApproxOrders()

MoFEMErrorCode MoFEM::DMCreateMatrix_MGViaApproxOrders	(	DM	dm,
		Mat *	M )

#include <src/petsc/impl/PCMGSetUpViaApproxOrders.cpp>

Create matrix for Multi-Grid via approximation orders.

Not used directly by user

Parameters

dm	Distributed mesh data structure
M	Matrix

Returns

Error code

Definition at line 349 of file PCMGSetUpViaApproxOrders.cpp.

                                                               {
 
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  GET_DM_FIELD(dm);
 
  int leveldown = dm->leveldown;
 
  if (dm_field->kspOperators.empty()) {
    CHKERR DMCreateMatrix_MoFEM(dm, M);
  } else {
    MPI_Comm comm;
    CHKERR PetscObjectGetComm((PetscObject)dm, &comm);
    if (dm_field->kspOperators.empty()) {
      SETERRQ(comm, MOFEM_DATA_INCONSISTENCY,
              "data inconsistency, operator can not be set");
    }
    if (static_cast<int>(dm_field->kspOperators.size()) < leveldown) {
      SETERRQ(comm, MOFEM_DATA_INCONSISTENCY,
              "data inconsistency, no IS for that level");
    }
    *M = dm_field->kspOperators[dm_field->kspOperators.size() - 1 - leveldown];
    CHKERR PetscObjectReference((PetscObject)*M);
    CHKERR MatSetDM(*M, dm);
  }
 
#if PETSC_VERSION_GE(3, 17, 0)
  PetscInfo(dm, "Create Matrix DMMGViaApproxOrders leveldown = %d\n",
             leveldown);
#else
  PetscInfo1(dm, "Create Matrix DMMGViaApproxOrders leveldown = %d\n",
             leveldown);
#endif
 
  MoFEMFunctionReturn(0);
}

DMCreateMatrix_MoFEM() [1/2]

PetscErrorCode MoFEM::DMCreateMatrix_MoFEM	(	DM	dm,
		Mat *	M )

#include <src/petsc/DMMoFEM.hpp>

DMShellSetCreateMatrix

sets the routine to create a matrix associated with the shell DM

Examples

eigen_elastic.cpp.

Definition at line 1187 of file DMMoFEM.cpp.

                                                   {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
 
  if (strcmp(dm->mattype, MATSHELL) == 0) {
 
    if (dm_field->blocMatDataPtr) {
      CHKERR DMMoFEMCreateBlockMat(dm, M);
      CHKERR MatSetDM(*M, dm);
      MoFEMFunctionReturnHot(0);
    } else {
      SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
              "Matrix shell data not set, or matrix type not implemented");
    }
 
  } else if (strcmp(dm->mattype, MATMPIAIJ) == 0) {
    CHKERR dm_field->mField_ptr->getInterface<MatrixManager>()
        ->createMPIAIJWithArrays<PetscGlobalIdx_mi_tag>(dm_field->problemName,
                                                        M);
  } else if (strcmp(dm->mattype, MATAIJ) == 0) {
    CHKERR dm_field->mField_ptr->getInterface<MatrixManager>()
        ->createSeqAIJWithArrays<PetscLocalIdx_mi_tag>(dm_field->problemName,
                                                       M);
  } else if (strcmp(dm->mattype, MATAIJCUSPARSE) == 0) {
    CHKERR dm_field->mField_ptr->getInterface<MatrixManager>()
        ->createMPIAIJCUSPARSEWithArrays<PetscGlobalIdx_mi_tag>(
            dm_field->problemName, M);
  } else if (strcmp(dm->mattype, MATSEQAIJCUSPARSE) == 0) {
    CHKERR dm_field->mField_ptr->getInterface<MatrixManager>()
        ->createSeqAIJCUSPARSEWithArrays<PetscLocalIdx_mi_tag>(
            dm_field->problemName, M);
  } else {
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
            "Matrix type not implemented");
  }
  CHKERR MatSetDM(*M, dm);
  MoFEMFunctionReturn(0);
}

DMCreateMatrix_MoFEM() [2/2]

PetscErrorCode MoFEM::DMCreateMatrix_MoFEM	(	DM	dm,
		SmartPetscObj< Mat > &	M )

#include <src/petsc/DMMoFEM.hpp>

DMShellSetCreateMatrix

sets the routine to create a matrix associated with the shell DM

Definition at line 1227 of file DMMoFEM.cpp.

                                                                  {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
 
  if (strcmp(dm->mattype, MATSHELL) == 0) {
    if (dm_field->blocMatDataPtr) {
      Mat mat_raw;
      CHKERR DMMoFEMCreateBlockMat(dm, &mat_raw);
      M = SmartPetscObj<Mat>(mat_raw);
      MoFEMFunctionReturnHot(0);
    } else {
      SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
              "Matrix shell data not set, or matrix type not implemented");
    }
  } else if (strcmp(dm->mattype, MATMPIAIJ) == 0) {
    CHKERR dm_field->mField_ptr->getInterface<MatrixManager>()
        ->createMPIAIJWithArrays<PetscGlobalIdx_mi_tag>(dm_field->problemName,
                                                        M);
  } else if (strcmp(dm->mattype, MATAIJ) == 0) {
    CHKERR dm_field->mField_ptr->getInterface<MatrixManager>()
        ->createSeqAIJWithArrays<PetscLocalIdx_mi_tag>(dm_field->problemName,
                                                       M);
  } else if (strcmp(dm->mattype, MATAIJCUSPARSE) == 0) {
    CHKERR dm_field->mField_ptr->getInterface<MatrixManager>()
        ->createMPIAIJCUSPARSEWithArrays<PetscGlobalIdx_mi_tag>(
            dm_field->problemName, M);
  } else if (strcmp(dm->mattype, MATSEQAIJCUSPARSE) == 0) {
    CHKERR dm_field->mField_ptr->getInterface<MatrixManager>()
        ->createSeqAIJCUSPARSEWithArrays<PetscLocalIdx_mi_tag>(
            dm_field->problemName, M);
  } else {
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
            "Matrix type not implemented");
  }
  CHKERR MatSetDM(M, dm);
  MoFEMFunctionReturn(0);
}

DMDestroy_MoFEM()

PetscErrorCode MoFEM::DMDestroy_MoFEM

(

DM

dm

)

#include <src/petsc/DMMoFEM.hpp>

Destroys dm with MoFEM data structure.

destroy the MoFEM structure

Definition at line 79 of file DMMoFEM.cpp.

                                      {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  MoFEMFunctionBeginHot;
 
  MPI_Comm comm;
  CHKERR PetscObjectGetComm((PetscObject)dm, &comm);
 
  int result;
  MPI_Comm_compare(comm, PETSC_COMM_SELF, &result);
  if (result == MPI_IDENT)
    MOFEM_LOG("DMSELF", Sev::noisy)
        << "MoFEM DM destroy for problem " << dm_field->problemName
        << " referenceNumber " << dm_field->referenceNumber;
  else
    MOFEM_LOG("DMWORLD", Sev::noisy)
        << "MoFEM DM destroy for problem " << dm_field->problemName
        << " referenceNumber " << dm_field->referenceNumber;
 
  if (dm_field->referenceNumber == 0) {
    if (dm_field->destroyProblem) {
 
      if (dm_field->mField_ptr->check_problem(dm_field->problemName)) {
        dm_field->mField_ptr->delete_problem(dm_field->problemName);
      } // else problem has to be deleted by the user
    }
 
    delete static_cast<DMCtxImpl *>(dm->data);
 
  } else
    --dm_field->referenceNumber;
 
  MoFEMFunctionReturnHot(0);
}

DMGlobalToLocalBegin_MoFEM()

PetscErrorCode MoFEM::DMGlobalToLocalBegin_MoFEM	(	DM	dm,
		Vec	g,
		InsertMode	mode,
		Vec	l )

#include <src/petsc/DMMoFEM.hpp>

DMShellSetGlobalToLocal

the routine that begins the global to local scatter

Definition at line 1391 of file DMMoFEM.cpp.

                                                 {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  CHKERR VecGhostUpdateBegin(g, INSERT_VALUES, SCATTER_FORWARD);
  MoFEMFunctionReturn(0);
}

DMGlobalToLocalEnd_MoFEM()

PetscErrorCode MoFEM::DMGlobalToLocalEnd_MoFEM	(	DM	dm,
		Vec	g,
		InsertMode	mode,
		Vec	l )

#include <src/petsc/DMMoFEM.hpp>

DMShellSetGlobalToLocal

the routine that begins the global to local scatter

Definition at line 1399 of file DMMoFEM.cpp.

                                                                              {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
 
  CHKERR VecGhostUpdateEnd(g, INSERT_VALUES, SCATTER_FORWARD);
 
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  int nb_dofs = dm_field->problemPtr->getNbLocalDofsRow();
  int nb_ghost = dm_field->problemPtr->getNbGhostDofsRow();
 
  double *array_loc, *array_glob;
  CHKERR VecGetArray(l, &array_loc);
  CHKERR VecGetArray(g, &array_glob);
  switch (mode) {
  case INSERT_VALUES:
    cblas_dcopy(nb_dofs + nb_ghost, array_glob, 1, array_loc, 1);
    break;
  case ADD_VALUES:
    cblas_daxpy(nb_dofs + nb_ghost, 1, array_glob, 1, array_loc, 1);
    break;
  default:
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED, "not implemented");
  }
  CHKERR VecRestoreArray(l, &array_loc);
  CHKERR VecRestoreArray(g, &array_glob);
  MoFEMFunctionReturn(0);
}

DMLocalToGlobalBegin_MoFEM()

PetscErrorCode MoFEM::DMLocalToGlobalBegin_MoFEM	(	DM	dm,
		Vec	l,
		InsertMode	mode,
		Vec	g )

#include <src/petsc/DMMoFEM.hpp>

DMShellSetLocalToGlobal

the routine that begins the local to global scatter

DMShellSetLocalToGlobal

the routine that ends the local to global scatter

Definition at line 1427 of file DMMoFEM.cpp.

                                                 {
 
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
 
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  int nb_dofs = dm_field->problemPtr->getNbLocalDofsRow();
  int nb_ghost = dm_field->problemPtr->getNbGhostDofsRow();
 
  double *array_loc, *array_glob;
  CHKERR VecGetArray(l, &array_loc);
  CHKERR VecGetArray(g, &array_glob);
  switch (mode) {
  case INSERT_VALUES:
    cblas_dcopy(nb_dofs + nb_ghost, array_loc, 1, array_glob, 1);
    break;
  case ADD_VALUES:
    cblas_daxpy(nb_dofs + nb_ghost, 1, array_loc, 1, array_glob, 1);
    break;
  default:
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED, "not implemented");
  }
  CHKERR VecRestoreArray(l, &array_loc);
  CHKERR VecRestoreArray(g, &array_glob);
 
  MoFEMFunctionReturn(0);
}

DMLocalToGlobalEnd_MoFEM()

PetscErrorCode MoFEM::DMLocalToGlobalEnd_MoFEM	(	DM	,
		Vec	l,
		InsertMode	mode,
		Vec	g )

#include <src/petsc/DMMoFEM.hpp>

DMShellSetLocalToGlobal

the routine that ends the local to global scatter

Definition at line 1456 of file DMMoFEM.cpp.

                                                                           {
  MoFEMFunctionBeginHot;
  MoFEMFunctionReturnHot(0);
}

DMMGViaApproxOrdersClearCoarseningIS()

MoFEMErrorCode MoFEM::DMMGViaApproxOrdersClearCoarseningIS

(

DM

)

#include <src/petsc/impl/PCMGSetUpViaApproxOrders.cpp>

Clear approximation orders.

Parameters

DM

dm

Returns

Error code

Definition at line 293 of file PCMGSetUpViaApproxOrders.cpp.

                                                           {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  GET_DM_FIELD(dm);
  CHKERR dm_field->destroyCoarseningIS();
  PetscInfo(dm, "Clear DMs data structures\n");
  MoFEMFunctionReturn(0);
}

DMMGViaApproxOrdersPopBackCoarseningIS()

MoFEMErrorCode MoFEM::DMMGViaApproxOrdersPopBackCoarseningIS

(

DM

)

#include <src/petsc/impl/PCMGSetUpViaApproxOrders.cpp>

Pop IS form MG via approximation orders.

Parameters

DM

dm

Returns

error code

Definition at line 281 of file PCMGSetUpViaApproxOrders.cpp.

                                                             {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  GET_DM_FIELD(dm);
  if (dm_field->coarseningIS.back()) {
    dm_field->coarseningIS.pop_back();
  }
  dm_field->kspOperators.pop_back();
  PetscInfo(dm, "Pop back IS to DMMGViaApproxOrders\n");
  MoFEMFunctionReturn(0);
}

DMMGViaApproxOrdersPushBackCoarseningIS()

MoFEMErrorCode MoFEM::DMMGViaApproxOrdersPushBackCoarseningIS	(	DM	,
		IS	is,
		Mat	A,
		bool	create_sub_matrix,
		bool	shell_sub_a )

#include <src/petsc/impl/PCMGSetUpViaApproxOrders.cpp>

Push back coarsening level to MG via approximation orders.

Parameters

DM	discrete manager
is	Push back IS used for coarsening
A	Get sub-matrix of A using is (that sets operators for coarsening levels)
subA	Returning pointer to created sub matrix
subA	If true create sub matrix, otherwise in subA has to be valid pointer to subA

Returns

Error code

Definition at line 227 of file PCMGSetUpViaApproxOrders.cpp.

                                                                         {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  GET_DM_FIELD(dm);
  dm_field->coarseningIS.emplace_back(SmartPetscObj<IS>(is, true));
  dm_field->shellMatrixCtxPtr.push_back(new PCMGSubMatrixCtx(A, is));
  if (is) {
    auto is2 = SmartPetscObj<IS>(is, true);
    if (dm_field->aO) {
      is2 = isDuplicate(is);
      CHKERR ISCopy(is, is2);
      CHKERR AOApplicationToPetscIS(dm_field->aO, is2);
    }
    if (create_sub_matrix) {
      if (shell_sub_a) {
        int n, N;
        CHKERR ISGetSize(is, &N);
        CHKERR ISGetLocalSize(is, &n);
        MPI_Comm comm;
        CHKERR PetscObjectGetComm((PetscObject)A, &comm);
        Mat sub_a_raw;
        CHKERR MatCreateShell(comm, n, n, N, N,
                              &(dm_field->shellMatrixCtxPtr.back()),
                              &sub_a_raw);
        CHKERR MatShellSetOperation(sub_a_raw, MATOP_MULT,
                                    (void (*)(void))sub_mat_mult);
        CHKERR MatShellSetOperation(sub_a_raw, MATOP_MULT_ADD,
                                    (void (*)(void))sub_mat_mult_add);
        CHKERR MatShellSetOperation(sub_a_raw, MATOP_SOR,
                                    (void (*)(void))sub_mat_sor);
        dm_field->kspOperators.emplace_back(
            SmartPetscObj<Mat>(sub_a_raw, false));
      } else {
        Mat sub_a_raw;
#if PETSC_VERSION_GE(3, 8, 0)
        CHKERR MatCreateSubMatrix(A, is2, is2, MAT_INITIAL_MATRIX, &sub_a_raw);
#else
        CHKERR MatGetSubMatrix(A, is2, is2, MAT_INITIAL_MATRIX, &sub_a_raw);
#endif
        dm_field->kspOperators.emplace_back(
            SmartPetscObj<Mat>(sub_a_raw, false));
      }
    } else {
      dm_field->kspOperators.emplace_back(SmartPetscObj<Mat>(A, true));
    }
  } else {
    SETERRQ(PETSC_COMM_WORLD, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
  }
  PetscInfo(dm, "Push back IS to DMMGViaApproxOrders\n");
  MoFEMFunctionReturn(0);
}

DMMoFEMAddColCompositeProblem()

PetscErrorCode MoFEM::DMMoFEMAddColCompositeProblem	(	DM	dm,
		const char	prb_name[] )

#include <src/petsc/DMMoFEM.hpp>

Add problem to composite DM on col.

This create block on col with DOFs from problem of given name

Parameters

dm	the DM object
prb_name	add problem name

Returns

error code

Definition at line 382 of file DMMoFEM.cpp.

                                                                           {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  if (!dm->data) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
            "data structure for MoFEM not yet created");
  }
  if (!dm_field->isCompDM) {
    dm_field->isCompDM = PETSC_TRUE;
  }
  if (dm_field->isSquareMatrix) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA,
            "No need to add problem on column when problem block structurally "
            "symmetric");
  }
  dm_field->colCompPrb.push_back(prb_name);
  MoFEMFunctionReturn(0);
}

DMMoFEMAddElement() [1/2]

PetscErrorCode MoFEM::DMMoFEMAddElement	(	DM	dm,
		std::string	fe_name )

#include <src/petsc/DMMoFEM.hpp>

add element to dm

Note

add_file is a collective, should be executed on all processors. Otherwise could lead to deadlock.

Examples

free_surface.cpp, level_set.cpp, mofem/tutorials/vec-7/adjoint.cpp, navier_stokes.cpp, and photon_diffusion.cpp.

Definition at line 488 of file DMMoFEM.cpp.

                                                           {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  CHKERR dm_field->mField_ptr->modify_problem_add_finite_element(
      dm_field->problemName, fe_name);
  MoFEMFunctionReturn(0);
}

DMMoFEMAddElement() [2/2]

PetscErrorCode MoFEM::DMMoFEMAddElement	(	DM	dm,
		std::vector< std::string >	fe_name )

#include <src/petsc/DMMoFEM.hpp>

add element to dm

Note

add_file is a collective, should be executed on all processors. Otherwise could lead to deadlock.

Definition at line 497 of file DMMoFEM.cpp.

                                                                      {
  MoFEMFunctionBegin;
  for (auto fe : fe_name) {
    CHKERR DMMoFEMAddElement(dm, fe);
  }
  MoFEMFunctionReturn(0);
}

DMMoFEMAddRowCompositeProblem()

PetscErrorCode MoFEM::DMMoFEMAddRowCompositeProblem	(	DM	dm,
		const char	prb_name[] )

#include <src/petsc/DMMoFEM.hpp>

Add problem to composite DM on row.

This create block on row with DOFs from problem of given name

Parameters

dm	the DM object
prb_name	add problem name

Returns

error code

Definition at line 364 of file DMMoFEM.cpp.

                                                                           {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  if (!dm->data) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
            "data structure for MoFEM not yet created");
  }
  if (!dm_field->isCompDM) {
    dm_field->isCompDM = PETSC_TRUE;
  }
  dm_field->rowCompPrb.push_back(prb_name);
  if (dm_field->isSquareMatrix) {
    dm_field->colCompPrb.push_back(prb_name);
  }
  MoFEMFunctionReturn(0);
}

DMMoFEMAddSubFieldCol()

PetscErrorCode MoFEM::DMMoFEMAddSubFieldCol	(	DM	dm,
		const char	field_name[] )

#include <src/petsc/DMMoFEM.hpp>

Add field to sub dm problem on columns

Examples

free_surface.cpp, and mofem/tutorials/vec-7/adjoint.cpp.

Definition at line 280 of file DMMoFEM.cpp.

                                                                     {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  if (!dm->data) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
            "data structure for MoFEM not yet created");
  }
  if (!dm_field->isSubDM) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "this is not sub-dm");
  }
  dm_field->colSubFields.push_back(field_name);
  dm_field->mapTypeCol.erase(field_name);
  MoFEMFunctionReturnHot(0);
}

DMMoFEMAddSubFieldRow() [1/2]

PetscErrorCode MoFEM::DMMoFEMAddSubFieldRow	(	DM	dm,
		const char	field_name[] )

#include <src/petsc/DMMoFEM.hpp>

Add field to sub dm problem on rows

Examples

free_surface.cpp, level_set.cpp, and mofem/tutorials/vec-7/adjoint.cpp.

Definition at line 238 of file DMMoFEM.cpp.

                                                                     {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  if (!dm->data) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
            "data structure for MoFEM not yet created");
  }
  if (!dm_field->isSubDM) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "this is not sub-dm");
  }
  dm_field->rowSubFields.push_back(field_name);
  dm_field->mapTypeRow.erase(field_name);
  MoFEMFunctionReturnHot(0);
}

DMMoFEMAddSubFieldRow() [2/2]

PetscErrorCode MoFEM::DMMoFEMAddSubFieldRow	(	DM	dm,
		const char	field_name[],
		boost::shared_ptr< Range >	r_ptr )

#include <src/petsc/DMMoFEM.hpp>

Add field to sub dm problem on rows.

Parameters

dm
field_name
m

Returns

PetscErrorCode

Definition at line 258 of file DMMoFEM.cpp.

                                                                   {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  if (!dm->data) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
            "data structure for MoFEM not yet created");
  }
  if (!dm_field->isSubDM) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "this is not sub-dm");
  }
  dm_field->rowSubFields.push_back(field_name);
  dm_field->mapTypeRow[field_name] = r_ptr;
  MoFEMFunctionReturnHot(0);
}

DMMoFEMCreateBlockMat() [1/2]

MoFEMErrorCode MoFEM::DMMoFEMCreateBlockMat	(	DM	dm,
		Mat *	mat )

#include <src/petsc/DMMoFEM.hpp>

Create block matrix.

Parameters

dm
mat

Returns

MoFEMErrorCode

Definition at line 1543 of file DMMoFEM.cpp.

                                                      {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  auto mat_data = createBlockMat(dm, dm_field->blocMatDataPtr);
  *mat = mat_data.first;
  CHKERR PetscObjectReference((PetscObject)(*mat));
  MoFEMFunctionReturn(0);
}

DMMoFEMCreateBlockMat() [2/2]

MoFEMErrorCode MoFEM::DMMoFEMCreateBlockMat	(	DM	dm,
		SmartPetscObj< Mat > &	mat )

#include <src/petsc/DMMoFEM.hpp>

Create block matrix.

Parameters

dm
mat	smart pointer

Returns

MoFEMErrorCode

DMMoFEMCreateMoFEM()

PetscErrorCode MoFEM::DMMoFEMCreateMoFEM	(	DM	dm,
		MoFEM::Interface *	m_field_ptr,
		const char	problem_name[],
		const MoFEM::BitRefLevel	bit_level,
		const MoFEM::BitRefLevel	bit_mask = MoFEM::BitRefLevel().set() )

#include <src/petsc/DMMoFEM.hpp>

Must be called by user to set MoFEM data structures.

Note

If problem exist function create DM for it. If you set bit levels, those bits are to existing bits. Thus if you do not like to change bit ref level for existing problem, set bits to zero.

Examples

free_surface.cpp, mofem/tutorials/vec-7/adjoint.cpp, and navier_stokes.cpp.

Definition at line 114 of file DMMoFEM.cpp.

                                                                   {
  MoFEMFunctionBegin;
 
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  if (!dm->data) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
            "data structure for MoFEM not yet created");
  }
  if (!m_field_ptr) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "DM function not implemented into MoFEM");
  }
  dm_field->mField_ptr = m_field_ptr;
  dm_field->problemName = problem_name;
  if (!m_field_ptr->check_problem(dm_field->problemName)) {
    // problem is not defined, declare problem internally set bool to
    // destroyProblem problem with DM
    dm_field->destroyProblem = PETSC_TRUE;
    CHKERR dm_field->mField_ptr->add_problem(dm_field->problemName, MF_EXCL,
                                             dm_field->verbosity);
  } else {
    dm_field->destroyProblem = PETSC_FALSE;
  }
  CHKERR dm_field->mField_ptr->modify_problem_ref_level_add_bit(
      dm_field->problemName, bit_level);
  CHKERR dm_field->mField_ptr->modify_problem_mask_ref_level_add_bit(
      dm_field->problemName, bit_mask);
  dm_field->kspCtx =
      boost::shared_ptr<KspCtx>(new KspCtx(*m_field_ptr, problem_name));
  dm_field->snesCtx =
      boost::shared_ptr<SnesCtx>(new SnesCtx(*m_field_ptr, problem_name));
  dm_field->tsCtx =
      boost::shared_ptr<TsCtx>(new TsCtx(*m_field_ptr, problem_name));
 
  MPI_Comm comm;
  CHKERR PetscObjectGetComm((PetscObject)dm, &comm);
  int result = 0;
  MPI_Comm_compare(comm, m_field_ptr->get_comm(), &result);
  if (result > MPI_CONGRUENT) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
            "MoFEM and DM using different communicators");
  }
  MPI_Comm_size(comm, &dm_field->sIze);
  MPI_Comm_rank(comm, &dm_field->rAnk);
 
  // problem structure
  CHKERR dm_field->mField_ptr->get_problem(dm_field->problemName,
                                           &dm_field->problemPtr);
 
  MPI_Comm_compare(comm, PETSC_COMM_SELF, &result);
  if (result == MPI_IDENT) {
    MOFEM_LOG("DMSELF", Sev::noisy)
        << "MoFEM DM created for problem " << dm_field->problemName;
    MOFEM_LOG("DMSELF", Sev::noisy) << *dm_field->problemPtr;
  } else {
    MOFEM_LOG("DMWORLD", Sev::noisy)
        << "MoFEM DM created for problem " << dm_field->problemName;
    MOFEM_LOG("DMWORLD", Sev::noisy) << *dm_field->problemPtr;
  }
 
  MoFEMFunctionReturn(0);
}

DMMoFEMCreateSubDM()

PetscErrorCode MoFEM::DMMoFEMCreateSubDM	(	DM	subdm,
		DM	dm,
		const char	problem_name[] )

#include <src/petsc/DMMoFEM.hpp>

Must be called by user to set Sub DM MoFEM data structures.

Examples

free_surface.cpp, level_set.cpp, and mofem/tutorials/vec-7/adjoint.cpp.

Definition at line 215 of file DMMoFEM.cpp.

                                                                              {
  MoFEMFunctionBegin;
 
  if (!dm->data) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "data structure for MoFEM not yet created");
  }
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
 
  CHKERR DMMoFEMCreateMoFEM(subdm, dm_field->mField_ptr, problem_name,
                            dm_field->problemPtr->getBitRefLevel(),
                            dm_field->problemPtr->getBitRefLevelMask());
 
  DMCtxImpl *subdm_field = (DMCtxImpl *)subdm->data;
  subdm_field->isSubDM = PETSC_TRUE;
  subdm_field->problemMainOfSubPtr = dm_field->problemPtr;
  subdm_field->isPartitioned = dm_field->isPartitioned;
  subdm_field->isSquareMatrix = PETSC_FALSE;
  subdm->ops->setup = DMSubDMSetUp_MoFEM;
 
  MoFEMFunctionReturn(0);
}

DMMoFEMGetFieldIS()

PetscErrorCode MoFEM::DMMoFEMGetFieldIS	(	DM	dm,
		RowColData	rc,
		const char	field_name[],
		IS *	is )

#include <src/petsc/DMMoFEM.hpp>

get field is in the problem

Parameters

dm	the DM objects
rc	ROW or COL (no difference is problem is squared)
field_name	name of the field
is	returned the IS object

Returns

error code

IS is;
ierr = DMMoFEMGetFieldIS(dm,ROW,"DISP",&is_disp); CHKERRG(ierr);

Definition at line 1506 of file DMMoFEM.cpp.

                                         {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  CHKERR dm_field->mField_ptr->getInterface<ISManager>()
      ->isCreateProblemFieldAndRank(dm_field->problemPtr->getName(), ROW,
                                    field_name, 0, 1000, is);
  MoFEMFunctionReturn(0);
}

DMMoFEMGetIsCompDM()

PetscErrorCode MoFEM::DMMoFEMGetIsCompDM	(	DM	dm,
		PetscBool *	is_comp_dm )

#include <src/petsc/DMMoFEM.hpp>

Get if this DM is composite DM.

Parameters

dm	the DM object
is_comp_dm	return true if composite problem here

Returns

error code

Definition at line 402 of file DMMoFEM.cpp.

                                                                {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  *is_comp_dm = dm_field->isCompDM;
  MoFEMFunctionReturnHot(0);
}

DMMoFEMGetIsPartitioned()

PetscErrorCode MoFEM::DMMoFEMGetIsPartitioned	(	DM	dm,
		PetscBool *	is_partitioned )

#include <src/petsc/DMMoFEM.hpp>

get if read mesh is partitioned

Definition at line 1124 of file DMMoFEM.cpp.

                                                                         {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  *is_partitioned = dm_field->isPartitioned;
  MoFEMFunctionReturnHot(0);
}

DMMoFEMGetIsSubDM()

PetscErrorCode MoFEM::DMMoFEMGetIsSubDM	(	DM	dm,
		PetscBool *	is_sub_dm )

#include <src/petsc/DMMoFEM.hpp>

Return true if this DM is sub problem

Parameters

dm	the DM object
is_subproblem	true if subproblem

Returns

error code

Definition at line 322 of file DMMoFEM.cpp.

                                                              {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  *is_sub_dm = dm_field->isSubDM;
  MoFEMFunctionReturnHot(0);
}

DMMoFEMGetKspCtx() [1/2]

PetscErrorCode MoFEM::DMMoFEMGetKspCtx	(	DM	dm,
		const boost::shared_ptr< MoFEM::KspCtx > &	ksp_ctx )

#include <src/petsc/DMMoFEM.hpp>

get MoFEM::KspCtx data structure

Definition at line 1067 of file DMMoFEM.cpp.

                                                                     {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  const_cast<boost::shared_ptr<MoFEM::KspCtx> &>(ksp_ctx) = dm_field->kspCtx;
  MoFEMFunctionReturnHot(0);
}

DMMoFEMGetKspCtx() [2/2]

PetscErrorCode MoFEM::DMMoFEMGetKspCtx	(	DM	dm,
		MoFEM::KspCtx **	ksp_ctx )

#include <src/petsc/DMMoFEM.hpp>

get MoFEM::KspCtx data structure

Definition at line 1058 of file DMMoFEM.cpp.

                                                              {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  *ksp_ctx = dm_field->kspCtx.get();
  MoFEMFunctionReturnHot(0);
}

DMMoFEMGetProblemFiniteElementLayout()

PetscErrorCode MoFEM::DMMoFEMGetProblemFiniteElementLayout	(	DM	dm,
		std::string	fe_name,
		PetscLayout *	layout )

#include <src/petsc/DMMoFEM.hpp>

Get finite elements layout in the problem.

In layout is stored information how many elements is on each processor, for more information look int petsc documentation http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/IS/PetscLayoutCreate.html#PetscLayoutCreate

Parameters

dm	discrete manager for this problem
fe_name	finite element name
layout	pointer to layout, for created layout user takes responsibility for destroying it.

Returns

error code

Definition at line 467 of file DMMoFEM.cpp.

                                                                         {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
 
  MPI_Comm comm;
  CHKERR PetscObjectGetComm((PetscObject)dm, &comm);
  CHKERR dm_field->problemPtr->getNumberOfElementsByNameAndPart(comm, fe_name,
                                                                layout);
  MoFEMFunctionReturn(0);
}

DMMoFEMGetProblemPtr()

PetscErrorCode MoFEM::DMMoFEMGetProblemPtr	(	DM	dm,
		const MoFEM::Problem **	problem_ptr )

#include <src/petsc/DMMoFEM.hpp>

Get pointer to problem data structure.

Examples

poisson_2d_dis_galerkin.cpp.

Definition at line 422 of file DMMoFEM.cpp.

                                                                             {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  if (!dm->data) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
            "data structure for MoFEM not yet created");
  }
  *problem_ptr = dm_field->problemPtr;
  MoFEMFunctionReturnHot(0);
}

DMMoFEMGetSnesCtx() [1/2]

PetscErrorCode MoFEM::DMMoFEMGetSnesCtx	(	DM	dm,
		const boost::shared_ptr< MoFEM::SnesCtx > &	snes_ctx )

#include <src/petsc/DMMoFEM.hpp>

get MoFEM::SnesCtx data structure

Definition at line 1093 of file DMMoFEM.cpp.

                                                                        {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  const_cast<boost::shared_ptr<MoFEM::SnesCtx> &>(snes_ctx) = dm_field->snesCtx;
  MoFEMFunctionReturnHot(0);
}

DMMoFEMGetSnesCtx() [2/2]

PetscErrorCode MoFEM::DMMoFEMGetSnesCtx	(	DM	dm,
		MoFEM::SnesCtx **	snes_ctx )

#include <src/petsc/DMMoFEM.hpp>

get MoFEM::SnesCtx data structure

Examples

navier_stokes.cpp.

Definition at line 1084 of file DMMoFEM.cpp.

                                                                 {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = (DMCtxImpl *)dm->data;
  *snes_ctx = dm_field->snesCtx.get();
  MoFEMFunctionReturnHot(0);
}

DMMoFEMGetSquareProblem()

PetscErrorCode MoFEM::DMMoFEMGetSquareProblem	(	DM	dm,
		PetscBool *	square_problem )

#include <src/petsc/DMMoFEM.hpp>

get squared problem

It if true is assumed that matrix has the same indexing on rows and columns. This reduces interprocessor communication.

Definition at line 480 of file DMMoFEM.cpp.

                                                                         {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  *square_problem = dm_field->isSquareMatrix;
  MoFEMFunctionReturnHot(0);
}

DMMoFEMGetTsCtx() [1/2]

PetscErrorCode MoFEM::DMMoFEMGetTsCtx	(	DM	dm,
		const boost::shared_ptr< MoFEM::TsCtx > &	ts_ctx )

#include <src/petsc/DMMoFEM.hpp>

get MoFEM::TsCtx data structure

Definition at line 1140 of file DMMoFEM.cpp.

                                                                          {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  const_cast<boost::shared_ptr<MoFEM::TsCtx> &>(ts_ctx) = dm_field->tsCtx;
  MoFEMFunctionReturnHot(0);
}

DMMoFEMGetTsCtx() [2/2]

PetscErrorCode MoFEM::DMMoFEMGetTsCtx	(	DM	dm,
		MoFEM::TsCtx **	ts_ctx )

#include <src/petsc/DMMoFEM.hpp>

get MoFEM::TsCtx data structure

Definition at line 1132 of file DMMoFEM.cpp.

                                                           {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  *ts_ctx = dm_field->tsCtx.get();
  MoFEMFunctionReturnHot(0);
}

DMMoFEMKSPSetComputeOperators() [1/2]

PetscErrorCode MoFEM::DMMoFEMKSPSetComputeOperators	(	DM	dm,
		const char	fe_name[],
		MoFEM::FEMethod *	method,
		MoFEM::BasicMethod *	pre_only,
		MoFEM::BasicMethod *	post_only )

#include <src/petsc/DMMoFEM.hpp>

Set KSP operators and push mofem finite element methods.

Parameters

dm	DM
fe_name	finite element name
method	method on the element (executed for each element in the problem which given name)
pre_only	method for pre-process before element method
post_only	method for post-process after element method

Returns

error code

Examples

level_set.cpp.

Definition at line 668 of file DMMoFEM.cpp.

                                                                          {
  return DMMoFEMKSPSetComputeOperators<const char *, MoFEM::FEMethod *,
                                       MoFEM::BasicMethod *,
                                       MoFEM::BasicMethod *>(
      dm, fe_name, method, pre_only, post_only);
}

DMMoFEMKSPSetComputeOperators() [2/2]

PetscErrorCode MoFEM::DMMoFEMKSPSetComputeOperators	(	DM	dm,
		const std::string	fe_name,
		boost::shared_ptr< MoFEM::FEMethod >	method,
		boost::shared_ptr< MoFEM::BasicMethod >	pre_only,
		boost::shared_ptr< MoFEM::BasicMethod >	post_only )

#include <src/petsc/DMMoFEM.hpp>

Set KSP operators and push mofem finite element methods.

Parameters

dm	DM
fe_name	finite element name
method	method on the element (executed for each element in the problem which given name)
pre_only	method for pre-process before element method
post_only	method for post-process after element method

Returns

error code

Definition at line 679 of file DMMoFEM.cpp.

                                                                           {
  return DMMoFEMKSPSetComputeOperators<const std::string,
                                       boost::shared_ptr<MoFEM::FEMethod>>(
      dm, fe_name, method, pre_only, post_only);
}

DMMoFEMKSPSetComputeRHS() [1/2]

PetscErrorCode MoFEM::DMMoFEMKSPSetComputeRHS	(	DM	dm,
		const char	fe_name[],
		MoFEM::FEMethod *	method,
		MoFEM::BasicMethod *	pre_only,
		MoFEM::BasicMethod *	post_only )

#include <src/petsc/DMMoFEM.hpp>

Set compute operator for KSP solver via sub-matrix and IS.

Parameters

dm

DM

Returns

error code

set KSP right hand side evaluation function

Examples

level_set.cpp.

Definition at line 627 of file DMMoFEM.cpp.

                                                                    {
  return DMMoFEMKSPSetComputeRHS<const char *, MoFEM::FEMethod *,
                                 MoFEM::BasicMethod *, MoFEM::BasicMethod *>(
      dm, fe_name, method, pre_only, post_only);
}

DMMoFEMKSPSetComputeRHS() [2/2]

PetscErrorCode MoFEM::DMMoFEMKSPSetComputeRHS	(	DM	dm,
		const std::string	fe_name,
		boost::shared_ptr< MoFEM::FEMethod >	method,
		boost::shared_ptr< MoFEM::BasicMethod >	pre_only,
		boost::shared_ptr< MoFEM::BasicMethod >	post_only )

#include <src/petsc/DMMoFEM.hpp>

set KSP right hand side evaluation function

Definition at line 637 of file DMMoFEM.cpp.

                                                                     {
  return DMMoFEMKSPSetComputeRHS<const std::string,
                                 boost::shared_ptr<MoFEM::FEMethod>,
                                 boost::shared_ptr<MoFEM::BasicMethod>,
                                 boost::shared_ptr<MoFEM::BasicMethod>>(
      dm, fe_name, method, pre_only, post_only);
}

DMMoFEMResolveSharedFiniteElements()

PetscErrorCode MoFEM::DMMoFEMResolveSharedFiniteElements	(	DM	dm,
		std::string	fe_name )

#include <src/petsc/DMMoFEM.hpp>

Resolve shared entities.

Parameters

dm	dm
fe_name	finite element for which shared entities are resolved

Returns

error code

Note

This function is valid for parallel algebra and serial mesh. It should be run collectively, i.e. on all processors.

This allows for tag reduction or tag exchange, f.e.

CHKERR DMMoFEMResolveSharedFiniteElements(dm,"SHELL_ELEMENT");
Tag th;
CHKERR mField.get_moab().tag_get_handle("ADAPT_ORDER",th);
ParallelComm* pcomm =
ParallelComm::get_pcomm(&mField.get_moab(),MYPCOMM_INDEX);
// CHKERR pcomm->reduce_tags(th,MPI_SUM,prisms);
CHKERR pcomm->exchange_tags(th,prisms);

Definition at line 458 of file DMMoFEM.cpp.

                                                                            {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  CHKERR dm_field->mField_ptr->getInterface<CommInterface>()
      ->resolveSharedFiniteElements(dm_field->problemPtr, fe_name);
  MoFEMFunctionReturn(0);
}

DMMoFEMSetIsPartitioned()

PetscErrorCode MoFEM::DMMoFEMSetIsPartitioned	(	DM	dm,
		PetscBool	is_partitioned )

#include <src/petsc/DMMoFEM.hpp>

sets if read mesh is partitioned

get if read mesh is partitioned

Examples

mofem/tutorials/vec-7/adjoint.cpp, and navier_stokes.cpp.

Definition at line 1113 of file DMMoFEM.cpp.

                                                                        {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  dm_field->isPartitioned = is_partitioned;
  MoFEMFunctionReturnHot(0);
}

DMMoFEMSetKspCtx()

PetscErrorCode MoFEM::DMMoFEMSetKspCtx	(	DM	dm,
		boost::shared_ptr< MoFEM::KspCtx >	ksp_ctx )

#include <src/petsc/DMMoFEM.hpp>

set MoFEM::KspCtx data structure

Definition at line 1075 of file DMMoFEM.cpp.

                                                                      {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  dm_field->kspCtx = ksp_ctx;
  MoFEMFunctionReturnHot(0);
}

DMMoFEMSetSnesCtx()

PetscErrorCode MoFEM::DMMoFEMSetSnesCtx	(	DM	dm,
		boost::shared_ptr< MoFEM::SnesCtx >	snes_ctx )

#include <src/petsc/DMMoFEM.hpp>

Set MoFEM::SnesCtx data structure.

Definition at line 1101 of file DMMoFEM.cpp.

                                                                         {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  dm_field->snesCtx = snes_ctx;
  MoFEMFunctionReturnHot(0);
}

DMMoFEMSetSquareProblem()

PetscErrorCode MoFEM::DMMoFEMSetSquareProblem	(	DM	dm,
		PetscBool	square_problem )

#include <src/petsc/DMMoFEM.hpp>

set squared problem

It if true is assumed that matrix has the same indexing on rows and columns. This reduces interprocessor communication.

Examples

free_surface.cpp, level_set.cpp, and mofem/tutorials/vec-7/adjoint.cpp.

Definition at line 450 of file DMMoFEM.cpp.

                                                                        {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  dm_field->isSquareMatrix = square_problem;
  MoFEMFunctionReturnHot(0);
}

DMMoFEMSetTsCtx()

PetscErrorCode MoFEM::DMMoFEMSetTsCtx	(	DM	dm,
		boost::shared_ptr< MoFEM::TsCtx >	ts_ctx )

#include <src/petsc/DMMoFEM.hpp>

Set MoFEM::TsCtx data structure.

It take over pointer, do not delete it, DM will destroy pointer when is destroyed.

Definition at line 1149 of file DMMoFEM.cpp.

                                                                          {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  dm_field->tsCtx = ts_ctx;
  MoFEMFunctionReturnHot(0);
}

DMMoFEMSNESSetFunction() [1/2]

PetscErrorCode MoFEM::DMMoFEMSNESSetFunction	(	DM	dm,
		const char	fe_name[],
		MoFEM::FEMethod *	method,
		MoFEM::BasicMethod *	pre_only,
		MoFEM::BasicMethod *	post_only )

#include <src/petsc/DMMoFEM.hpp>

set SNES residual evaluation function

Examples

navier_stokes.cpp.

Definition at line 708 of file DMMoFEM.cpp.

                                                                   {
  return DMMoFEMSNESSetFunction<const char *, MoFEM::FEMethod *,
                                MoFEM::BasicMethod *, MoFEM::BasicMethod *>(
      dm, fe_name, method, pre_only, post_only);
}

DMMoFEMSNESSetFunction() [2/2]

PetscErrorCode MoFEM::DMMoFEMSNESSetFunction	(	DM	dm,
		const std::string	fe_name,
		boost::shared_ptr< MoFEM::FEMethod >	method,
		boost::shared_ptr< MoFEM::BasicMethod >	pre_only,
		boost::shared_ptr< MoFEM::BasicMethod >	post_only )

#include <src/petsc/DMMoFEM.hpp>

set SNES residual evaluation function

Definition at line 718 of file DMMoFEM.cpp.

                                                                    {
  return DMMoFEMSNESSetFunction<const std::string,
                                boost::shared_ptr<MoFEM::FEMethod>,
                                boost::shared_ptr<MoFEM::BasicMethod>,
                                boost::shared_ptr<MoFEM::BasicMethod>>(
      dm, fe_name, method, pre_only, post_only);
}

DMMoFEMSNESSetJacobian() [1/2]

PetscErrorCode MoFEM::DMMoFEMSNESSetJacobian	(	DM	dm,
		const char	fe_name[],
		MoFEM::FEMethod *	method,
		MoFEM::BasicMethod *	pre_only,
		MoFEM::BasicMethod *	post_only )

#include <src/petsc/DMMoFEM.hpp>

set SNES Jacobian evaluation function

Examples

navier_stokes.cpp.

Definition at line 749 of file DMMoFEM.cpp.

                                                                   {
  return DMMoFEMSNESSetJacobian<const char *, MoFEM::FEMethod *,
                                MoFEM::BasicMethod *, MoFEM::BasicMethod *>(
      dm, fe_name, method, pre_only, post_only);
}

DMMoFEMSNESSetJacobian() [2/2]

PetscErrorCode MoFEM::DMMoFEMSNESSetJacobian	(	DM	dm,
		const std::string	fe_name,
		boost::shared_ptr< MoFEM::FEMethod >	method,
		boost::shared_ptr< MoFEM::BasicMethod >	pre_only,
		boost::shared_ptr< MoFEM::BasicMethod >	post_only )

#include <src/petsc/DMMoFEM.hpp>

set SNES Jacobian evaluation function

Definition at line 759 of file DMMoFEM.cpp.

                                                                    {
  return DMMoFEMSNESSetJacobian<const std::string,
                                boost::shared_ptr<MoFEM::FEMethod>,
                                boost::shared_ptr<MoFEM::BasicMethod>,
                                boost::shared_ptr<MoFEM::BasicMethod>>(
      dm, fe_name, method, pre_only, post_only);
}

DMMoFEMTSSetI2Function() [1/2]

PetscErrorCode MoFEM::DMMoFEMTSSetI2Function	(	DM	dm,
		const char	fe_name[],
		MoFEM::FEMethod *	method,
		MoFEM::BasicMethod *	pre_only,
		MoFEM::BasicMethod *	post_only )

#include <src/petsc/DMMoFEM.hpp>

set TS implicit function evaluation function

Definition at line 954 of file DMMoFEM.cpp.

                                                                   {
  return DMMoFEMTSSetI2Function<const char *, MoFEM::FEMethod *,
                                MoFEM::BasicMethod *, MoFEM::BasicMethod *>(
      dm, fe_name, method, pre_only, post_only);
  MoFEMFunctionReturnHot(0);
}

DMMoFEMTSSetI2Function() [2/2]

PetscErrorCode MoFEM::DMMoFEMTSSetI2Function	(	DM	dm,
		const std::string	fe_name,
		boost::shared_ptr< MoFEM::FEMethod >	method,
		boost::shared_ptr< MoFEM::BasicMethod >	pre_only,
		boost::shared_ptr< MoFEM::BasicMethod >	post_only )

#include <src/petsc/DMMoFEM.hpp>

set TS implicit function evaluation function

Definition at line 965 of file DMMoFEM.cpp.

                                                                    {
  return DMMoFEMTSSetI2Function<const std::string,
                                boost::shared_ptr<MoFEM::FEMethod>,
                                boost::shared_ptr<MoFEM::BasicMethod>,
                                boost::shared_ptr<MoFEM::BasicMethod>>(
      dm, fe_name, method, pre_only, post_only);
  MoFEMFunctionReturnHot(0);
}

DMMoFEMTSSetI2Jacobian() [1/2]

PetscErrorCode MoFEM::DMMoFEMTSSetI2Jacobian	(	DM	dm,
		const char	fe_name[],
		MoFEM::FEMethod *	method,
		MoFEM::BasicMethod *	pre_only,
		MoFEM::BasicMethod *	post_only )

#include <src/petsc/DMMoFEM.hpp>

set TS Jacobian evaluation function

Definition at line 997 of file DMMoFEM.cpp.

                                                                   {
  return DMMoFEMTSSetI2Jacobian<const char *, FEMethod *, MoFEM::BasicMethod *,
                                MoFEM::BasicMethod *>(dm, fe_name, method,
                                                      pre_only, post_only);
}

DMMoFEMTSSetI2Jacobian() [2/2]

PetscErrorCode MoFEM::DMMoFEMTSSetI2Jacobian	(	DM	dm,
		const std::string	fe_name,
		boost::shared_ptr< MoFEM::FEMethod >	method,
		boost::shared_ptr< MoFEM::BasicMethod >	pre_only,
		boost::shared_ptr< MoFEM::BasicMethod >	post_only )

#include <src/petsc/DMMoFEM.hpp>

set TS Jacobian evaluation function

Definition at line 1007 of file DMMoFEM.cpp.

                                                                    {
  return DMMoFEMTSSetI2Jacobian<const std::string,
                                boost::shared_ptr<MoFEM::FEMethod>,
                                boost::shared_ptr<MoFEM::BasicMethod>,
                                boost::shared_ptr<MoFEM::BasicMethod>>(
      dm, fe_name, method, pre_only, post_only);
}

DMMoFEMTSSetIFunction() [1/2]

PetscErrorCode MoFEM::DMMoFEMTSSetIFunction	(	DM	dm,
		const char	fe_name[],
		MoFEM::FEMethod *	method,
		MoFEM::BasicMethod *	pre_only,
		MoFEM::BasicMethod *	post_only )

#include <src/petsc/DMMoFEM.hpp>

set TS implicit function evaluation function

Definition at line 790 of file DMMoFEM.cpp.

                                                                  {
  return DMMoFEMTSSetIFunction<const char *, MoFEM::FEMethod *,
                               MoFEM::BasicMethod *, MoFEM::BasicMethod *>(
      dm, fe_name, method, pre_only, post_only);
  MoFEMFunctionReturnHot(0);
}

DMMoFEMTSSetIFunction() [2/2]

PetscErrorCode MoFEM::DMMoFEMTSSetIFunction	(	DM	dm,
		const std::string	fe_name,
		boost::shared_ptr< MoFEM::FEMethod >	method,
		boost::shared_ptr< MoFEM::BasicMethod >	pre_only,
		boost::shared_ptr< MoFEM::BasicMethod >	post_only )

#include <src/petsc/DMMoFEM.hpp>

set TS implicit function evaluation function

Definition at line 801 of file DMMoFEM.cpp.

                                                                   {
  return DMMoFEMTSSetIFunction<const std::string,
                               boost::shared_ptr<MoFEM::FEMethod>,
                               boost::shared_ptr<MoFEM::BasicMethod>,
                               boost::shared_ptr<MoFEM::BasicMethod>>(
      dm, fe_name, method, pre_only, post_only);
  MoFEMFunctionReturnHot(0);
}

DMMoFEMTSSetIJacobian() [1/2]

PetscErrorCode MoFEM::DMMoFEMTSSetIJacobian	(	DM	dm,
		const char	fe_name[],
		MoFEM::FEMethod *	method,
		MoFEM::BasicMethod *	pre_only,
		MoFEM::BasicMethod *	post_only )

#include <src/petsc/DMMoFEM.hpp>

set TS Jacobian evaluation function

Definition at line 833 of file DMMoFEM.cpp.

                                                                  {
  return DMMoFEMTSSetIJacobian<const char *, FEMethod *, MoFEM::BasicMethod *,
                               MoFEM::BasicMethod *>(dm, fe_name, method,
                                                     pre_only, post_only);
}

DMMoFEMTSSetIJacobian() [2/2]

PetscErrorCode MoFEM::DMMoFEMTSSetIJacobian	(	DM	dm,
		const std::string	fe_name,
		boost::shared_ptr< MoFEM::FEMethod >	method,
		boost::shared_ptr< MoFEM::BasicMethod >	pre_only,
		boost::shared_ptr< MoFEM::BasicMethod >	post_only )

#include <src/petsc/DMMoFEM.hpp>

set TS Jacobian evaluation function

Definition at line 843 of file DMMoFEM.cpp.

                                                                   {
  return DMMoFEMTSSetIJacobian<const std::string,
                               boost::shared_ptr<MoFEM::FEMethod>,
                               boost::shared_ptr<MoFEM::BasicMethod>,
                               boost::shared_ptr<MoFEM::BasicMethod>>(
      dm, fe_name, method, pre_only, post_only);
}

DMMoFEMUnSetElement()

PetscErrorCode MoFEM::DMMoFEMUnSetElement	(	DM	dm,
		std::string	fe_name )

#include <src/petsc/DMMoFEM.hpp>

unset element from dm

Definition at line 505 of file DMMoFEM.cpp.

                                                             {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  CHKERR dm_field->mField_ptr->modify_problem_unset_finite_element(
      dm_field->problemName, fe_name);
  MoFEMFunctionReturn(0);
}

DMoFEMGetInterfacePtr()

PetscErrorCode MoFEM::DMoFEMGetInterfacePtr	(	DM	dm,
		MoFEM::Interface **	m_field_ptr )

#include <src/petsc/DMMoFEM.hpp>

Get pointer to MoFEM::Interface.

Parameters

dm	Distributed mesh manager
m_field_ptr	Pointer to pointer of field interface

Returns

Error code

Examples

adolc_plasticity.cpp, and free_surface.cpp.

Definition at line 410 of file DMMoFEM.cpp.

                                                                          {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  if (!dm->data) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
            "data structure for MoFEM not yet created");
  }
  *m_field_ptr = dm_field->mField_ptr;
  MoFEMFunctionReturnHot(0);
}

DMoFEMLoopDofs()

PetscErrorCode MoFEM::DMoFEMLoopDofs	(	DM	dm,
		const char	field_name[],
		MoFEM::DofMethod *	method )

#include <src/petsc/DMMoFEM.hpp>

execute method for dofs on field in problem

Definition at line 595 of file DMMoFEM.cpp.

                                                      {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  ierr =
      dm_field->mField_ptr->loop_dofs(dm_field->problemPtr, field_name, COL,
                                      *method, dm_field->rAnk, dm_field->rAnk);
  CHKERRG(ierr);
  MoFEMFunctionReturnHot(0);
}

DMoFEMLoopFiniteElements() [1/2]

PetscErrorCode MoFEM::DMoFEMLoopFiniteElements	(	DM	dm,
		const char	fe_name[],
		MoFEM::FEMethod *	method,
		CacheTupleWeakPtr	cache_ptr = CacheTupleSharedPtr() )

#include <src/petsc/DMMoFEM.hpp>

Executes FEMethod for finite elements in DM.

Parameters

dm	MoFEM discrete manager
fe_name	name of element
method	pointer to MOFEM::FEMethod

Returns

Error code

Examples

adolc_plasticity.cpp, dynamic_first_order_con_law.cpp, free_surface.cpp, heat_equation.cpp, level_set.cpp, mofem/tutorials/vec-7/adjoint.cpp, navier_stokes.cpp, photon_diffusion.cpp, plastic.cpp, poisson_2d_homogeneous.cpp, shallow_wave.cpp, and wave_equation.cpp.

Definition at line 576 of file DMMoFEM.cpp.

                                                                     {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  ierr = DMoFEMLoopFiniteElementsUpAndLowRank(
      dm, fe_name, method, dm_field->rAnk, dm_field->rAnk, cache_ptr);
  CHKERRG(ierr);
  MoFEMFunctionReturnHot(0);
}

DMoFEMLoopFiniteElements() [2/2]

PetscErrorCode MoFEM::DMoFEMLoopFiniteElements	(	DM	dm,
		const std::string	fe_name,
		boost::shared_ptr< MoFEM::FEMethod >	method,
		CacheTupleWeakPtr	cache_ptr = CacheTupleSharedPtr() )

#include <src/petsc/DMMoFEM.hpp>

Executes FEMethod for finite elements in DM.

Parameters

dm	MoFEM discrete manager
fe_name	name of element
method	pointer to MOFEM::FEMethod

Returns

Error code

Definition at line 589 of file DMMoFEM.cpp.

                                                      {
  return DMoFEMLoopFiniteElements(dm, fe_name.c_str(), method.get(), cache_ptr);
}

DMoFEMLoopFiniteElementsUpAndLowRank() [1/2]

PetscErrorCode MoFEM::DMoFEMLoopFiniteElementsUpAndLowRank	(	DM	dm,
		const char	fe_name[],
		MoFEM::FEMethod *	method,
		int	low_rank,
		int	up_rank,
		CacheTupleWeakPtr	cache_ptr = CacheTupleSharedPtr() )

#include <src/petsc/DMMoFEM.hpp>

Executes FEMethod for finite elements in DM.

Parameters

dm	MoFEM discrete manager
fe_name	name of finite element
method	pointer to MoFEM::FEMethod
low_rank	lowest rank of processor
up_rank	upper run of processor

Returns

Error code

Definition at line 557 of file DMMoFEM.cpp.

                                                                               {
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  ierr = dm_field->mField_ptr->loop_finite_elements(
      dm_field->problemPtr, fe_name, *method, low_rank, up_rank, nullptr,
      MF_EXIST, cache_ptr);
  CHKERRG(ierr);
  MoFEMFunctionReturnHot(0);
}

DMoFEMLoopFiniteElementsUpAndLowRank() [2/2]

PetscErrorCode MoFEM::DMoFEMLoopFiniteElementsUpAndLowRank	(	DM	dm,
		const std::string	fe_name,
		boost::shared_ptr< MoFEM::FEMethod >	method,
		int	low_rank,
		int	up_rank,
		CacheTupleWeakPtr	cache_ptr = CacheTupleSharedPtr() )

#include <src/petsc/DMMoFEM.hpp>

Executes FEMethod for finite elements in DM.

Parameters

dm	MoFEM discrete manager
fe_name	name of finite element
method	pointer to MoFEM::FEMethod
low_rank	lowest rank of processor
up_rank	upper run of processor

Returns

Error code

Definition at line 569 of file DMMoFEM.cpp.

                                                            {
  return DMoFEMLoopFiniteElementsUpAndLowRank(dm, fe_name.c_str(), method.get(),
                                              low_rank, up_rank, cache_ptr);
}

DMoFEMMeshToGlobalVector()

PetscErrorCode MoFEM::DMoFEMMeshToGlobalVector	(	DM	dm,
		Vec	g,
		InsertMode	mode,
		ScatterMode	scatter_mode )

#include <src/petsc/DMMoFEM.hpp>

set ghosted vector values on all existing mesh entities

Parameters

g	vector
mode	see petsc manual for VecSetValue (ADD_VALUES or INSERT_VALUES)
scatter_mode	see petsc manual for ScatterMode (The available modes are: SCATTER_FORWARD or SCATTER_REVERSE)

SCATTER_REVERSE set data to field entities from V vector.

SCATTER_FORWARD set vector V from data field entities

Examples

navier_stokes.cpp.

Definition at line 525 of file DMMoFEM.cpp.

                                                                  {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  ierr = dm_field->mField_ptr->getInterface<VecManager>()->setGlobalGhostVector(
      dm_field->problemPtr, COL, g, mode, scatter_mode);
  CHKERRG(ierr);
  MoFEMFunctionReturnHot(0);
}

DMoFEMMeshToLocalVector()

PetscErrorCode MoFEM::DMoFEMMeshToLocalVector	(	DM	dm,
		Vec	l,
		InsertMode	mode,
		ScatterMode	scatter_mode )

#include <src/petsc/DMMoFEM.hpp>

set local (or ghosted) vector values on mesh for partition only

Parameters

l	vector
mode	see petsc manual for VecSetValue (ADD_VALUES or INSERT_VALUES)
scatter_mode	see petsc manual for ScatterMode (The available modes are: SCATTER_FORWARD or SCATTER_REVERSE)

SCATTER_REVERSE set data to field entities from V vector.

SCATTER_FORWARD set vector V from data field entities

Examples

adolc_plasticity.cpp, approx_sphere.cpp, child_and_parent.cpp, dg_projection.cpp, dynamic_first_order_con_law.cpp, free_surface.cpp, hanging_node_approx.cpp, heat_method.cpp, helmholtz.cpp, higher_derivatives.cpp, level_set.cpp, mixed_poisson.cpp, mofem/tutorials/vec-7/adjoint.cpp, phase.cpp, plate.cpp, poisson_2d_dis_galerkin.cpp, poisson_2d_homogeneous.cpp, and shallow_wave.cpp.

Definition at line 514 of file DMMoFEM.cpp.

                                                                 {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  ierr = dm_field->mField_ptr->getInterface<VecManager>()->setLocalGhostVector(
      dm_field->problemPtr, COL, l, mode, scatter_mode);
  CHKERRG(ierr);
  MoFEMFunctionReturnHot(0);
}

DMoFEMPostProcessFiniteElements()

PetscErrorCode MoFEM::DMoFEMPostProcessFiniteElements	(	DM	dm,
		MoFEM::FEMethod *	method )

#include <src/petsc/DMMoFEM.hpp>

execute finite element method for each element in dm (problem)

Examples

free_surface.cpp, and mofem/tutorials/vec-7/adjoint.cpp.

Definition at line 546 of file DMMoFEM.cpp.

                                                                             {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  ierr = dm_field->mField_ptr->problem_basic_method_postProcess(
      dm_field->problemPtr, *method);
  CHKERRG(ierr);
  MoFEMFunctionReturnHot(0);
}

DMoFEMPreProcessFiniteElements()

PetscErrorCode MoFEM::DMoFEMPreProcessFiniteElements	(	DM	dm,
		MoFEM::FEMethod *	method )

#include <src/petsc/DMMoFEM.hpp>

execute finite element method for each element in dm (problem)

Examples

free_surface.cpp, mofem/tutorials/vec-7/adjoint.cpp, and navier_stokes.cpp.

Definition at line 536 of file DMMoFEM.cpp.

                                                                            {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  ierr = dm_field->mField_ptr->problem_basic_method_preProcess(
      dm_field->problemPtr, *method);
  CHKERRG(ierr);
  MoFEMFunctionReturnHot(0);
}

DMRegister_MGViaApproxOrders()

MoFEMErrorCode MoFEM::DMRegister_MGViaApproxOrders

(

const char

sname[]

)

#include <src/petsc/impl/PCMGSetUpViaApproxOrders.cpp>

Register DM for Multi-Grid via approximation orders.

Parameters

sname

problem/dm registered name

Returns

error code

Definition at line 302 of file PCMGSetUpViaApproxOrders.cpp.

                                                                {
  MoFEMFunctionBegin;
  CHKERR DMRegister(sname, DMCreate_MGViaApproxOrders);
  MoFEMFunctionReturn(0);
}

DMRegister_MoFEM()

PetscErrorCode MoFEM::DMRegister_MoFEM

(

const char

sname[]

)

#include <src/petsc/DMMoFEM.hpp>

Register MoFEM problem.

Examples

mixed_poisson.cpp, navier_stokes.cpp, and photon_diffusion.cpp.

Definition at line 43 of file DMMoFEM.cpp.

                                                    {
  MoFEMFunctionBegin;
  CHKERR DMRegister(sname, DMCreate_MoFEM);
  MoFEMFunctionReturn(0);
}

DMSetFromOptions_MoFEM()

PetscErrorCode MoFEM::DMSetFromOptions_MoFEM

(

DM

dm

)

#include <src/petsc/DMMoFEM.hpp>

Set options for MoFEM DM

Definition at line 1275 of file DMMoFEM.cpp.

                                             {
#endif
 
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
#if PETSC_VERSION_GE(3, 18, 0)
  PetscOptionsHeadBegin(PetscOptionsObject, "DMMoFEM Options");
#elif PETSC_VERSION_GE(3, 5, 3)
  PetscOptionsHead(PetscOptionsObject, "DMMoFEM Options");
#else
  PetscOptionsHead("DMMoFEM Options");
#endif
  ierr = PetscOptionsBool("-dm_is_partitioned",
                          "set if mesh is partitioned (works which native MOAB "
                          "file format, i.e. h5m",
                          "DMSetUp", dm_field->isPartitioned,
                          &dm_field->isPartitioned, NULL);
  CHKERRG(ierr);
  MoFEMFunctionReturnHot(0);
}

DMSetOperators_MoFEM()

PetscErrorCode MoFEM::DMSetOperators_MoFEM

(

DM

dm

)

#include <src/petsc/DMMoFEM.hpp>

Set operators for MoFEM dm.

Parameters

dm

Returns

error code

Definition at line 49 of file DMMoFEM.cpp.

                                           {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
 
  dm->ops->createglobalvector = DMCreateGlobalVector_MoFEM;
  dm->ops->createlocalvector = DMCreateLocalVector_MoFEM;
  dm->ops->creatematrix = DMCreateMatrix_MoFEM;
  dm->ops->setup = DMSetUp_MoFEM;
  dm->ops->destroy = DMDestroy_MoFEM;
  dm->ops->setfromoptions = DMSetFromOptions_MoFEM;
  dm->ops->globaltolocalbegin = DMGlobalToLocalBegin_MoFEM;
  dm->ops->globaltolocalend = DMGlobalToLocalEnd_MoFEM;
  dm->ops->localtoglobalbegin = DMLocalToGlobalBegin_MoFEM;
  dm->ops->localtoglobalend = DMLocalToGlobalEnd_MoFEM;
  dm->ops->createfieldis = DMCreateFieldIS_MoFEM;
 
  // Default matrix type
  CHKERR DMSetMatType(dm, MATMPIAIJ);
 
  MoFEMFunctionReturn(0);
}

DMSetUp_MoFEM()

PetscErrorCode MoFEM::DMSetUp_MoFEM

(

DM

dm

)

#include <src/petsc/DMMoFEM.hpp>

sets up the MoFEM structures inside a DM object

Examples

mixed_poisson.cpp.

Definition at line 1297 of file DMMoFEM.cpp.

                                    {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  ProblemsManager *prb_mng_ptr;
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  CHKERR dm_field->mField_ptr->getInterface(prb_mng_ptr);
 
  if (dm_field->isCompDM) {
    // It is composite probelm
    CHKERR prb_mng_ptr->buildComposedProblem(
        dm_field->problemName, dm_field->rowCompPrb, dm_field->colCompPrb,
        dm_field->isSquareMatrix == PETSC_TRUE, dm_field->verbosity);
  } else {
    if (dm_field->isPartitioned) {
      CHKERR prb_mng_ptr->buildProblemOnDistributedMesh(
          dm_field->problemName, dm_field->isSquareMatrix == PETSC_TRUE,
          dm_field->verbosity);
    } else {
      CHKERR prb_mng_ptr->buildProblem(dm_field->problemName,
                                       dm_field->isSquareMatrix == PETSC_TRUE,
                                       dm_field->verbosity);
      CHKERR prb_mng_ptr->partitionProblem(dm_field->problemName,
                                           dm_field->verbosity);
    }
  }
 
  // Partition finite elements
  if (dm_field->isPartitioned) {
    CHKERR prb_mng_ptr->partitionFiniteElements(
        dm_field->problemName, true, 0, dm_field->sIze, dm_field->verbosity);
    CHKERR prb_mng_ptr->partitionGhostDofsOnDistributedMesh(
        dm_field->problemName, dm_field->verbosity);
  } else {
    // partition finite elemnets
    CHKERR prb_mng_ptr->partitionFiniteElements(dm_field->problemName, false,
                                                -1, -1, dm_field->verbosity);
    // Get ghost DOFs
    CHKERR prb_mng_ptr->partitionGhostDofs(dm_field->problemName,
                                           dm_field->verbosity);
  }
 
  // Set flag that problem is build and partitioned
  dm_field->isProblemBuild = PETSC_TRUE;
 
  MoFEMFunctionReturn(0);
}

DMSubDMSetUp_MoFEM()

PetscErrorCode MoFEM::DMSubDMSetUp_MoFEM

(

DM

subdm

)

#include <src/petsc/DMMoFEM.hpp>

Sets up the MoFEM structures inside a DM object for sub dm

Examples

level_set.cpp.

Definition at line 1344 of file DMMoFEM.cpp.

                                            {
  PetscValidHeaderSpecific(subdm, DM_CLASSID, 1);
  ProblemsManager *prb_mng_ptr;
  MoFEMFunctionBegin;
 
  DMCtxImpl *subdm_field = static_cast<DMCtxImpl *>(subdm->data);
 
  // build sub dm problem
  CHKERR subdm_field->mField_ptr->getInterface(prb_mng_ptr);
 
  map<std::string, boost::shared_ptr<Range>> *entity_map_row = nullptr;
  map<std::string, boost::shared_ptr<Range>> *entity_map_col = nullptr;
 
  if (subdm_field->mapTypeRow.size())
    entity_map_row = &subdm_field->mapTypeRow;
  if (subdm_field->mapTypeCol.size())
    entity_map_col = &subdm_field->mapTypeCol;
 
  CHKERR prb_mng_ptr->buildSubProblem(
      subdm_field->problemName, subdm_field->rowSubFields,
      subdm_field->colSubFields, subdm_field->problemMainOfSubPtr->getName(),
      subdm_field->isSquareMatrix == PETSC_TRUE, entity_map_row, entity_map_col,
      subdm_field->verbosity);
 
  // partition problem
  subdm_field->isPartitioned = subdm_field->isPartitioned;
  if (subdm_field->isPartitioned) {
    CHKERR prb_mng_ptr->partitionFiniteElements(subdm_field->problemName, true,
                                                0, subdm_field->sIze,
                                                subdm_field->verbosity);
    // set ghost nodes
    CHKERR prb_mng_ptr->partitionGhostDofsOnDistributedMesh(
        subdm_field->problemName, subdm_field->verbosity);
  } else {
    // partition finite elements
    CHKERR prb_mng_ptr->partitionFiniteElements(subdm_field->problemName, false,
                                                -1, -1, subdm_field->verbosity);
    // set ghost nodes
    CHKERR prb_mng_ptr->partitionGhostDofs(subdm_field->problemName,
                                           subdm_field->verbosity);
  }
 
  subdm_field->isProblemBuild = PETSC_TRUE;
 
  MoFEMFunctionReturn(0);
}