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	DMMGViaApproxOrdersCtx
	Structure for DM for multi-grid via approximation orders. More...

Functions
PetscErrorCode	MoFEM::DMRegister_MoFEM (const char sname[])
	Register MoFEM problem. More...
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. More...
PetscErrorCode	MoFEM::DMMoFEMCreateSubDM (DM subdm, DM dm, const char problem_name[])
	Must be called by user to set Sub DM MoFEM data structures. More...
PetscErrorCode	MoFEM::DMoFEMGetInterfacePtr (DM dm, MoFEM::Interface **m_field_ptr)
	Get pointer to MoFEM::Interface. More...
PetscErrorCode	MoFEM::DMMoFEMGetProblemPtr (DM dm, const MoFEM::Problem **problem_ptr)
	Get pointer to problem data structure. More...
PetscErrorCode	MoFEM::DMMoFEMSetSquareProblem (DM dm, PetscBool square_problem)
	set squared problemIt if true is assumed that matrix has the same indexing on rows and columns. This reduces interprocessor communication. More...
PetscErrorCode	MoFEM::DMMoFEMGetSquareProblem (DM dm, PetscBool *square_problem)
	get squared problemIt if true is assumed that matrix has the same indexing on rows and columns. This reduces interprocessor communication. More...
PetscErrorCode	MoFEM::DMMoFEMResolveSharedEntities (DM dm, const char fe_name[])
	Resolve shared entities. More...
PetscErrorCode	MoFEM::DMMoFEMGetProblemFiniteElementLayout (DM dm, const char fe_name[], PetscLayout *layout)
	Get finite elements layout in the problem. More...
PetscErrorCode	MoFEM::DMMoFEMAddElement (DM dm, const char fe_name[])
	add element to dm More...
PetscErrorCode	MoFEM::DMMoFEMUnSetElement (DM dm, const char fe_name[])
	unset element from dm More...
PetscErrorCode	MoFEM::DMoFEMMeshToLocalVector (DM dm, Vec l, InsertMode mode, ScatterMode scatter_mode)
	set local (or ghosted) vector values on mesh for partition only More...
PetscErrorCode	MoFEM::DMoFEMMeshToGlobalVector (DM dm, Vec g, InsertMode mode, ScatterMode scatter_mode)
	set ghosted vector values on all existing mesh entities More...
PetscErrorCode	MoFEM::DMoFEMPreProcessFiniteElements (DM dm, MoFEM::FEMethod *method)
	execute finite element method for each element in dm (problem) More...
PetscErrorCode	MoFEM::DMoFEMPostProcessFiniteElements (DM dm, MoFEM::FEMethod *method)
	execute finite element method for each element in dm (problem) More...
PetscErrorCode	MoFEM::DMoFEMLoopFiniteElementsUpAndLowRank (DM dm, const char fe_name[], MoFEM::FEMethod *method, int low_rank, int up_rank)
	Executes FEMethod for finite elements in DM. More...
PetscErrorCode	MoFEM::DMoFEMLoopFiniteElementsUpAndLowRank (DM dm, const std::string &fe_name, boost::shared_ptr< MoFEM::FEMethod > method, int low_rank, int up_rank)
	Executes FEMethod for finite elements in DM. More...
PetscErrorCode	MoFEM::DMoFEMLoopFiniteElements (DM dm, const char fe_name[], MoFEM::FEMethod *method)
	Executes FEMethod for finite elements in DM. More...
PetscErrorCode	MoFEM::DMoFEMLoopFiniteElements (DM dm, const std::string &fe_name, boost::shared_ptr< MoFEM::FEMethod > method)
	Executes FEMethod for finite elements in DM. More...
PetscErrorCode	MoFEM::DMoFEMLoopDofs (DM dm, const char field_name[], MoFEM::DofMethod *method)
	execute method for dofs on field in problem More...
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. More...
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 More...
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. More...
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. More...
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 More...
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 More...
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 More...
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 More...
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 More...
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 More...
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 More...
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 More...
PetscErrorCode	MoFEM::DMMoFEMGetKspCtx (DM dm, MoFEM::KspCtx **ksp_ctx)
	get MoFEM::KspCtx data structure More...
PetscErrorCode	MoFEM::DMMoFEMGetKspCtx (DM dm, const boost::shared_ptr< MoFEM::KspCtx > &ksp_ctx)
	get MoFEM::KspCtx data structure More...
PetscErrorCode	MoFEM::DMMoFEMSetKspCtx (DM dm, boost::shared_ptr< MoFEM::KspCtx > &ksp_ctx)
	set MoFEM::KspCtx data structure More...
PetscErrorCode	MoFEM::DMMoFEMGetSnesCtx (DM dm, MoFEM::SnesCtx **snes_ctx)
	get MoFEM::SnesCtx data structure More...
PetscErrorCode	MoFEM::DMMoFEMGetSnesCtx (DM dm, const boost::shared_ptr< MoFEM::SnesCtx > &snes_ctx)
	get MoFEM::SnesCtx data structure More...
PetscErrorCode	MoFEM::DMMoFEMSetSnesCtx (DM dm, boost::shared_ptr< MoFEM::SnesCtx > &snes_ctx)
	Set MoFEM::SnesCtx data structure. More...
PetscErrorCode	MoFEM::DMMoFEMGetTsCtx (DM dm, MoFEM::TsCtx **ts_ctx)
	get MoFEM::TsCtx data structure More...
PetscErrorCode	MoFEM::DMMoFEMGetTsCtx (DM dm, const boost::shared_ptr< MoFEM::TsCtx > &ts_ctx)
	get MoFEM::TsCtx data structure More...
PetscErrorCode	MoFEM::DMMoFEMSetTsCtx (DM dm, boost::shared_ptr< MoFEM::TsCtx > &ts_ctx)
	Set MoFEM::TsCtx data structureIt take over pointer, do not delete it, DM will destroy pointer when is destroyed. More...
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. More...
PetscErrorCode	MoFEM::DMCreate_MoFEM (DM dm)
	Create dm data structure with MoFEM data structure. More...
PetscErrorCode	MoFEM::DMDestroy_MoFEM (DM dm)
	Destroys dm with MoFEM data structure. More...
PetscErrorCode	MoFEM::DMCreateGlobalVector_MoFEM (DM dm, Vec *g)
	DMShellSetCreateGlobalVectorsets the routine to create a global vector associated with the shell DM. More...
PetscErrorCode	MoFEM::DMCreateLocalVector_MoFEM (DM dm, Vec *l)
	DMShellSetCreateLocalVectorsets the routine to create a local vector associated with the shell DM. More...
PetscErrorCode	MoFEM::DMCreateMatrix_MoFEM (DM dm, 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[], EntityType lo_type=MBVERTEX, EntityType hi_type=MBMAXTYPE)
PetscErrorCode	MoFEM::DMMoFEMAddSubFieldCol (DM dm, const char field_name[], EntityType lo_type=MBVERTEX, EntityType hi_type=MBMAXTYPE)
PetscErrorCode	MoFEM::DMMoFEMGetIsSubDM (DM dm, PetscBool *is_sub_dm)
PetscErrorCode	MoFEM::DMMoFEMAddRowCompositeProblem (DM dm, const char prb_name[])
	Add problem to composite DM on rowThis create block on row with DOFs from problem of given name. More...
PetscErrorCode	MoFEM::DMMoFEMAddColCompositeProblem (DM dm, const char prb_name[])
	Add problem to composite DM on colThis create block on col with DOFs from problem of given name. More...
PetscErrorCode	MoFEM::DMMoFEMGetIsCompDM (DM dm, PetscBool *is_comp_dm)
	Get if this DM is composite DM. More...
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 More...
MoFEMErrorCode	DMMGViaApproxOrdersPushBackCoarseningIS (DM, IS is, Mat A, Mat *subA, bool create_sub_matrix, bool shell_sub_a)
	Push back coarsening level to MG via approximation orders. More...
MoFEMErrorCode	DMMGViaApproxOrdersPopBackCoarseningIS (DM)
	Pop is form MG via approximation orders. More...
MoFEMErrorCode	DMMGViaApproxOrdersClearCoarseningIS (DM)
	Clear approximation orders. More...
MoFEMErrorCode	DMRegister_MGViaApproxOrders (const char sname[])
	Register DM for Multi-Grid via approximation orders. More...
MoFEMErrorCode	DMCreateMatrix_MGViaApproxOrders (DM dm, Mat *M)
	Create matrix for Multi-Grid via approximation orders. More...
MoFEMErrorCode	DMCoarsen_MGViaApproxOrders (DM dm, MPI_Comm comm, DM *dmc)
	Coarsen DM. More...

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

DMCoarsen_MGViaApproxOrders()

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

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 477 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);
  CHKERR PetscObjectReference((PetscObject)(*dmc));
  PetscInfo1(dm, "Coarsen DMMGViaApproxOrders leveldown = %d\n", dm->leveldown);
  MoFEMFunctionReturn(0);
}

DMCreate_MoFEM()

PetscErrorCode MoFEM::DMCreate_MoFEM

(

DM

dm

)

Create dm data structure with MoFEM data structure.

Definition at line 81 of file DMMMoFEM.cpp.

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

DMCreateFieldIS_MoFEM()

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

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 1098 of file DMMMoFEM.cpp.

                                                                      {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;

  if (numFields) {
    *numFields = 0;
  }
  if (fieldNames) {
    *fieldNames = NULL;
  }
  if (fields) {
    *fields = NULL;
  }

  DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
  const Field_multiIndex *fields_ptr;
  CHKERR dm_field->mField_ptr->get_fields(&fields_ptr);
  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()

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

DMShellSetCreateGlobalVectorsets the routine to create a global vector associated with the shell DM.

Examples

elasticity_mixed_formulation.cpp.

Definition at line 867 of file DMMMoFEM.cpp.

                                                         {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
  CHKERR dm_field->mField_ptr->getInterface<VecManager>()->vecCreateGhost(
      dm_field->problemName, COL, g);
  MoFEMFunctionReturnHot(0);
}

DMCreateLocalVector_MoFEM()

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

DMShellSetCreateLocalVectorsets the routine to create a local vector associated with the shell DM.

Definition at line 876 of file DMMMoFEM.cpp.

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

DMCreateMatrix_MGViaApproxOrders()

MoFEMErrorCode DMCreateMatrix_MGViaApproxOrders	(	DM	dm,
		Mat *	M
	)

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 446 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);
  }

  PetscInfo1(dm, "Create Matrix DMMGViaApproxOrders leveldown = %d\n",
             leveldown);

  MoFEMFunctionReturn(0);
}

DMCreateMatrix_MoFEM()

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

DMShellSetCreateMatrix

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

Examples

elasticity_mixed_formulation.cpp.

Definition at line 885 of file DMMMoFEM.cpp.

                                                   {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
  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 {
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
            "Matrix type not implemented");
  }
  MoFEMFunctionReturn(0);
}

DMDestroy_MoFEM()

PetscErrorCode MoFEM::DMDestroy_MoFEM

(

DM

dm

)

Destroys dm with MoFEM data structure.

destroy the MoFEM structure

Definition at line 89 of file DMMMoFEM.cpp.

                                      {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
  MoFEMFunctionBeginHot;
  if (((DMCtx *)dm->data)->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
    }
    // cerr << "Destroy " << dm_field->problemName << endl;
    delete ((DMCtx *)dm->data);
  } else {
    // cerr << "Dereference " << dm_field->problemName << " "  <<
    // ((DMCtx*)dm->data)->referenceNumber << endl;
    (((DMCtx *)dm->data)->referenceNumber)--;
  }
  MoFEMFunctionReturnHot(0);
}

DMGlobalToLocalBegin_MoFEM()

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

DMShellSetGlobalToLocal

the routine that begins the global to local scatter

Definition at line 1026 of file DMMMoFEM.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
	)

DMShellSetGlobalToLocal

the routine that begins the global to local scatter

Definition at line 1034 of file DMMMoFEM.cpp.

                                                                              {
  MoFEMFunctionBeginHot;
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;

  CHKERR VecGhostUpdateEnd(g, INSERT_VALUES, SCATTER_FORWARD);

  DMCtx *dm_field = static_cast<DMCtx *>(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
	)

DMShellSetLocalToGlobal

the routine that begins the local to global scatter

DMShellSetLocalToGlobal

the routine that ends the local to global scatter

Definition at line 1063 of file DMMMoFEM.cpp.

                                                 {

  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;

  DMCtx *dm_field = static_cast<DMCtx *>(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
	)

DMShellSetLocalToGlobal

the routine that ends the local to global scatter

Definition at line 1092 of file DMMMoFEM.cpp.

                                                                           {
  //
  MoFEMFunctionBeginHot;
  MoFEMFunctionReturnHot(0);
}

DMMGViaApproxOrdersClearCoarseningIS()

MoFEMErrorCode DMMGViaApproxOrdersClearCoarseningIS

(

DM

)

Clear approximation orders.

Parameters

DM

dm

Returns

Error code

Definition at line 296 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 DMMGViaApproxOrdersPopBackCoarseningIS

(

DM

)

Pop is form MG via approximation orders.

Parameters

DM	dm
is	pop back IS

Returns

error code

Definition at line 280 of file PCMGSetUpViaApproxOrders.cpp.

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

DMMGViaApproxOrdersPushBackCoarseningIS()

MoFEMErrorCode DMMGViaApproxOrdersPushBackCoarseningIS	(	DM	,
		IS	is,
		Mat	A,
		Mat *	subA,
		bool	create_sub_matrix,
		bool	shell_sub_a
	)

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 230 of file PCMGSetUpViaApproxOrders.cpp.

                                                                         {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  GET_DM_FIELD(dm);
  dm_field->coarseningIS.push_back(is);
  dm_field->shellMatrixCtxPtr.push_back(new PCMGSubMatrixCtx_private(A, is));
  if (is) {
    CHKERR PetscObjectReference((PetscObject)is);
  }
  if (is) {
    IS is2 = is;
    if (dm_field->aO) {
      CHKERR ISDuplicate(is, &is2);
      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);
        CHKERR MatCreateShell(comm, n, n, N, N,
                              &(dm_field->shellMatrixCtxPtr.back()), subA);
        CHKERR MatShellSetOperation(*subA, MATOP_MULT,
                                    (void (*)(void))sub_mat_mult);
        CHKERR MatShellSetOperation(*subA, MATOP_MULT_ADD,
                                    (void (*)(void))sub_mat_mult_add);
        CHKERR MatShellSetOperation(*subA, MATOP_SOR,
                                    (void (*)(void))sub_mat_sor);
      } else {
        CHKERR MatGetSubMatrix(A, is2, is2, MAT_INITIAL_MATRIX, subA);
      }
    }
    if (dm_field->aO) {
      CHKERR ISDestroy(&is2);
    }
    dm_field->kspOperators.push_back(*subA);
    CHKERR PetscObjectReference((PetscObject)(*subA));
  } 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[]
	)

Add problem to composite DM on colThis 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 296 of file DMMMoFEM.cpp.

                                                                           {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtx *dm_field = static_cast<DMCtx *>(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()

PetscErrorCode MoFEM::DMMoFEMAddElement	(	DM	dm,
		const char	fe_name[]
	)

add element to dm

Note

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

Examples

analytical_poisson_field_split.cpp, cell_forces.cpp, dm_build_partitioned_mesh.cpp, dm_create_subdm.cpp, elasticity.cpp, elasticity_mixed_formulation.cpp, EshelbianPlasticity.cpp, lorentz_force.cpp, MagneticElement.hpp, minimal_surface_area.cpp, Remodeling.cpp, simple_elasticity.cpp, and UnsaturatedFlow.hpp.

Definition at line 410 of file DMMMoFEM.cpp.

                                                              {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
  ierr = dm_field->mField_ptr->modify_problem_add_finite_element(
      dm_field->problemName, fe_name);
  CHKERRG(ierr);
  MoFEMFunctionReturnHot(0);
}

DMMoFEMAddRowCompositeProblem()

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

Add problem to composite DM on rowThis 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 278 of file DMMMoFEM.cpp.

                                                                           {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtx *dm_field = static_cast<DMCtx *>(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[],
		EntityType	lo_type = MBVERTEX,
		EntityType	hi_type = MBMAXTYPE
	)

Add field to sub dm problem on columns

Examples

analytical_poisson_field_split.cpp, cell_forces.cpp, and dm_create_subdm.cpp.

Definition at line 210 of file DMMMoFEM.cpp.

                                                                             {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtx *dm_field = static_cast<DMCtx *>(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->colFields.push_back(field_name);
  if (lo_type != MBVERTEX || hi_type != MBMAXTYPE) {
    if (!dm_field->mapTypeCol)
      dm_field->mapTypeCol = boost::make_shared<
          std::map<std::string, std::pair<EntityType, EntityType>>>();
    (*dm_field->mapTypeCol)[field_name] =
        std::pair<EntityType, EntityType>(lo_type, hi_type);
  }
  MoFEMFunctionReturnHot(0);
}

DMMoFEMAddSubFieldRow()

PetscErrorCode MoFEM::DMMoFEMAddSubFieldRow	(	DM	dm,
		const char	field_name[],
		EntityType	lo_type = MBVERTEX,
		EntityType	hi_type = MBMAXTYPE
	)

Add field to sub dm problem on rows

Examples

analytical_poisson_field_split.cpp, cell_forces.cpp, dm_create_subdm.cpp, and EshelbianPlasticity.cpp.

Definition at line 187 of file DMMMoFEM.cpp.

                                                                             {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtx *dm_field = static_cast<DMCtx *>(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->rowFields.push_back(field_name);
  if(lo_type != MBVERTEX || hi_type != MBMAXTYPE) {
    if(!dm_field->mapTypeRow)
      dm_field->mapTypeRow = boost::make_shared<
          std::map<std::string, std::pair<EntityType, EntityType>>>();
    (*dm_field->mapTypeRow)[field_name] =
        std::pair<EntityType, EntityType>(lo_type, hi_type);
  }
  MoFEMFunctionReturnHot(0);
}

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

Must be called by user to set MoFEM data structures.

Examples

cell_forces.cpp, dm_build_partitioned_mesh.cpp, dm_create_subdm.cpp, elasticity.cpp, elasticity_mixed_formulation.cpp, EshelbianPlasticity.cpp, lorentz_force.cpp, MagneticElement.hpp, minimal_surface_area.cpp, Remodeling.cpp, and UnsaturatedFlow.hpp.

Definition at line 109 of file DMMMoFEM.cpp.

                                                                   {
  MoFEMFunctionBegin;

  DMCtx *dm_field = static_cast<DMCtx *>(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);
  // std::cerr << result << " " << MPI_IDENT << " " << MPI_CONGRUENT << " " <<
  // MPI_SIMILAR << " " << MPI_UNEQUAL << std::endl;
  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);

  MoFEMFunctionReturn(0);
}

DMMoFEMCreateSubDM()

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

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

Examples

analytical_poisson_field_split.cpp, cell_forces.cpp, dm_create_subdm.cpp, and EshelbianPlasticity.cpp.

Definition at line 166 of file DMMMoFEM.cpp.

                                                                              {
  MoFEMFunctionBegin;

  DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
  if (!dm->data) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
            "data structure for MoFEM not yet created");
  }
  CHKERR DMMoFEMCreateMoFEM(subdm, dm_field->mField_ptr, problem_name,
                            dm_field->problemPtr->getBitRefLevel());

  DMCtx *subdm_field = (DMCtx *)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
	)

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 1144 of file DMMMoFEM.cpp.

                                         {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtx *dm_field = static_cast<DMCtx *>(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
	)

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 316 of file DMMMoFEM.cpp.

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

DMMoFEMGetIsPartitioned()

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

get if read mesh is partitioned

Definition at line 834 of file DMMMoFEM.cpp.

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

DMMoFEMGetIsSubDM()

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

Return true if this DM is sub problem

Parameters

dm	the DM object
is_subproblem	true if subproblem

Returns

error code

Definition at line 233 of file DMMMoFEM.cpp.

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

DMMoFEMGetKspCtx() [1/2]

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

get MoFEM::KspCtx data structure

Definition at line 768 of file DMMMoFEM.cpp.

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

DMMoFEMGetKspCtx() [2/2]

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

get MoFEM::KspCtx data structure

Definition at line 777 of file DMMMoFEM.cpp.

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

DMMoFEMGetProblemFiniteElementLayout()

PetscErrorCode MoFEM::DMMoFEMGetProblemFiniteElementLayout	(	DM	dm,
		const char	fe_name[],
		PetscLayout *	layout
	)

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 386 of file DMMMoFEM.cpp.

                                                                         {
  MoFEMFunctionBeginHot;
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtx *dm_field = static_cast<DMCtx *>(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
	)

Get pointer to problem data structure.

Examples

EshelbianPlasticity.cpp, field_evaluator.cpp, loop_entities.cpp, lorentz_force.cpp, MagneticElement.hpp, and Remodeling.cpp.

Definition at line 337 of file DMMMoFEM.cpp.

                                                                             {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtx *dm_field = static_cast<DMCtx *>(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,
		MoFEM::SnesCtx **	snes_ctx
	)

get MoFEM::SnesCtx data structure

Examples

minimal_surface_area.cpp, testing_jacobian_of_hook_element.cpp, and testing_jacobian_of_hook_scaled_with_density_element.cpp.

Definition at line 794 of file DMMMoFEM.cpp.

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

DMMoFEMGetSnesCtx() [2/2]

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

get MoFEM::SnesCtx data structure

Definition at line 803 of file DMMMoFEM.cpp.

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

DMMoFEMGetSquareProblem()

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

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

Definition at line 400 of file DMMMoFEM.cpp.

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

DMMoFEMGetTsCtx() [1/2]

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

get MoFEM::TsCtx data structure

Examples

EshelbianPlasticity.cpp, Remodeling.cpp, and UnsaturatedFlow.hpp.

Definition at line 842 of file DMMMoFEM.cpp.

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

DMMoFEMGetTsCtx() [2/2]

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

get MoFEM::TsCtx data structure

Definition at line 850 of file DMMMoFEM.cpp.

                                                                          {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
  const_cast<boost::shared_ptr<MoFEM::TsCtx> &>(ts_ctx) = dm_field->tsCtx;
  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
	)

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

analytical_poisson.cpp, elasticity_mixed_formulation.cpp, and simple_elasticity.cpp.

Definition at line 582 of file DMMMoFEM.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
	)

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 593 of file DMMMoFEM.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
	)

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

Parameters

dm

DM

Returns

error codeset KSP right hand side evaluation function

Examples

analytical_poisson.cpp, and simple_elasticity.cpp.

Definition at line 541 of file DMMMoFEM.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
	)

set KSP right hand side evaluation function

Definition at line 551 of file DMMMoFEM.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);
}

DMMoFEMResolveSharedEntities()

PetscErrorCode MoFEM::DMMoFEMResolveSharedEntities	(	DM	dm,
		const char	fe_name[]
	)

Resolve shared entities.

Parameters

dm	dm
fe_name	finite element for which shared entities are resolved

Returns

error code

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

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

Definition at line 376 of file DMMMoFEM.cpp.

                                                                         {
  MoFEMFunctionBeginHot;
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
  CHKERR dm_field->mField_ptr->resolve_shared_ents(dm_field->problemPtr,
                                                   fe_name);
  MoFEMFunctionReturn(0);
}

DMMoFEMSetIsPartitioned()

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

sets if read mesh is partitioned

get if read mesh is partitioned

Examples

cell_forces.cpp, elasticity.cpp, elasticity_mixed_formulation.cpp, EshelbianPlasticity.cpp, Remodeling.cpp, simple_elasticity.cpp, and UnsaturatedFlow.hpp.

Definition at line 823 of file DMMMoFEM.cpp.

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

DMMoFEMSetKspCtx()

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

set MoFEM::KspCtx data structure

Definition at line 785 of file DMMMoFEM.cpp.

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

DMMoFEMSetSnesCtx()

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

Set MoFEM::SnesCtx data structure.

Definition at line 811 of file DMMMoFEM.cpp.

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

DMMoFEMSetSquareProblem()

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

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

Examples

analytical_poisson_field_split.cpp, cell_forces.cpp, dm_build_partitioned_mesh.cpp, dm_create_subdm.cpp, and EshelbianPlasticity.cpp.

Definition at line 367 of file DMMMoFEM.cpp.

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

DMMoFEMSetTsCtx()

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

Set MoFEM::TsCtx data structureIt take over pointer, do not delete it, DM will destroy pointer when is destroyed.

Definition at line 859 of file DMMMoFEM.cpp.

                                                                           {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtx *dm_field = static_cast<DMCtx *>(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
	)

set SNES residual evaluation function

Examples

analytical_nonlinear_poisson.cpp, mesh_smoothing.cpp, minimal_surface_area.cpp, testing_jacobian_of_hook_element.cpp, and testing_jacobian_of_hook_scaled_with_density_element.cpp.

Definition at line 622 of file DMMMoFEM.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
	)

set SNES residual evaluation function

Definition at line 632 of file DMMMoFEM.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
	)

set SNES Jacobian evaluation function

Examples

analytical_nonlinear_poisson.cpp, mesh_smoothing.cpp, minimal_surface_area.cpp, testing_jacobian_of_hook_element.cpp, and testing_jacobian_of_hook_scaled_with_density_element.cpp.

Definition at line 663 of file DMMMoFEM.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
	)

set SNES Jacobian evaluation function

Definition at line 673 of file DMMMoFEM.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);
}

DMMoFEMTSSetIFunction() [1/2]

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

Examples

bone_adaptation.cpp, EshelbianPlasticity.cpp, and UnsaturatedFlow.hpp.

Definition at line 704 of file DMMMoFEM.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
	)

set TS implicit function evaluation function

Definition at line 715 of file DMMMoFEM.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 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

Examples

bone_adaptation.cpp, EshelbianPlasticity.cpp, and UnsaturatedFlow.hpp.

Definition at line 757 of file DMMMoFEM.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);
}

DMMoFEMTSSetIJacobian() [2/2]

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

Definition at line 747 of file DMMMoFEM.cpp.

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

DMMoFEMUnSetElement()

PetscErrorCode MoFEM::DMMoFEMUnSetElement	(	DM	dm,
		const char	fe_name[]
	)

unset element from dm

Definition at line 420 of file DMMMoFEM.cpp.

                                                                {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
  ierr = dm_field->mField_ptr->modify_problem_unset_finite_element(
      dm_field->problemName, fe_name);
  CHKERRG(ierr);
  MoFEMFunctionReturnHot(0);
}

DMoFEMGetInterfacePtr()

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

Get pointer to MoFEM::Interface.

Parameters

dm	Distributed mesh manager
m_field_ptr	Pointer to pointer of field interface

Returns

Error code

Examples

HookeElement.cpp, and mesh_smoothing.cpp.

Definition at line 325 of file DMMMoFEM.cpp.

                                                                          {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtx *dm_field = static_cast<DMCtx *>(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
	)

execute method for dofs on field in problem

Definition at line 509 of file DMMMoFEM.cpp.

                                                      {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtx *dm_field = static_cast<DMCtx *>(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
	)

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

analytical_nonlinear_poisson.cpp, analytical_poisson.cpp, analytical_poisson_field_split.cpp, cell_forces.cpp, elasticity.cpp, elasticity_mixed_formulation.cpp, EshelbianPlasticity.cpp, hello_world.cpp, HookeElement.cpp, MagneticElement.hpp, mesh_smoothing.cpp, minimal_surface_area.cpp, Remodeling.cpp, simple_elasticity.cpp, simple_interface.cpp, and UnsaturatedFlow.hpp.

Definition at line 492 of file DMMMoFEM.cpp.

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

DMoFEMLoopFiniteElements() [2/2]

PetscErrorCode MoFEM::DMoFEMLoopFiniteElements	(	DM	dm,
		const std::string &	fe_name,
		boost::shared_ptr< MoFEM::FEMethod >	method
	)

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 504 of file DMMMoFEM.cpp.

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

DMoFEMLoopFiniteElementsUpAndLowRank() [1/2]

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

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 473 of file DMMMoFEM.cpp.

                                                                               {
  MoFEMFunctionBeginHot;
  DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
  ierr = dm_field->mField_ptr->loop_finite_elements(
      dm_field->problemPtr, fe_name, *method, low_rank, up_rank);
  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
	)

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 485 of file DMMMoFEM.cpp.

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

DMoFEMMeshToGlobalVector()

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

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

analytical_nonlinear_poisson.cpp, analytical_poisson.cpp, analytical_poisson_field_split.cpp, elasticity_mixed_formulation.cpp, mesh_smoothing.cpp, minimal_surface_area.cpp, and simple_elasticity.cpp.

Definition at line 442 of file DMMMoFEM.cpp.

                                                                  {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtx *dm_field = static_cast<DMCtx *>(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
	)

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

bone_adaptation.cpp, cell_forces.cpp, elasticity.cpp, elasticity_mixed_formulation.cpp, EshelbianPlasticity.cpp, MagneticElement.hpp, mesh_smoothing.cpp, minimal_surface_area.cpp, testing_jacobian_of_hook_element.cpp, testing_jacobian_of_hook_scaled_with_density_element.cpp, and UnsaturatedFlow.hpp.

Definition at line 430 of file DMMMoFEM.cpp.

                                                                 {
  MoFEMFunctionBeginHot;
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtx *dm_field = static_cast<DMCtx *>(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
	)

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

Examples

cell_forces.cpp, elasticity.cpp, elasticity_mixed_formulation.cpp, and simple_elasticity.cpp.

Definition at line 463 of file DMMMoFEM.cpp.

                                                                             {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtx *dm_field = static_cast<DMCtx *>(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
	)

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

Examples

cell_forces.cpp, elasticity.cpp, and elasticity_mixed_formulation.cpp.

Definition at line 453 of file DMMMoFEM.cpp.

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

DMRegister_MGViaApproxOrders()

MoFEMErrorCode DMRegister_MGViaApproxOrders

(

const char

sname[]

)

Register DM for Multi-Grid via approximation orders.

Parameters

sname

problem/dm registered name

Returns

error code

Definition at line 392 of file PCMGSetUpViaApproxOrders.cpp.

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

DMRegister_MoFEM()

PetscErrorCode MoFEM::DMRegister_MoFEM

(

const char

sname[]

)

Register MoFEM problem.

Examples

analytical_nonlinear_poisson.cpp, analytical_poisson.cpp, analytical_poisson_field_split.cpp, cell_forces.cpp, dm_build_partitioned_mesh.cpp, dm_create_subdm.cpp, elasticity_mixed_formulation.cpp, ep.cpp, field_evaluator.cpp, hello_world.cpp, loop_entities.cpp, lorentz_force.cpp, MagneticElement.hpp, mesh_smoothing.cpp, minimal_surface_area.cpp, Remodeling.cpp, simple_elasticity.cpp, simple_interface.cpp, testing_jacobian_of_hook_element.cpp, testing_jacobian_of_hook_scaled_with_density_element.cpp, and unsaturated_transport.cpp.

Definition at line 53 of file DMMMoFEM.cpp.

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

DMSetFromOptions_MoFEM()

PetscErrorCode MoFEM::DMSetFromOptions_MoFEM

(

DM

dm

)

Set options for MoFEM DM

Definition at line 910 of file DMMMoFEM.cpp.

                                             {
#endif

  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
#if PETSC_VERSION_GE(3, 5, 3)
  ierr = PetscOptionsHead(PetscOptionsObject, "DMMoFEM Options");
  CHKERRG(ierr);
#else
  ierr = PetscOptionsHead("DMMoFEM Options");
  CHKERRG(ierr);
#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

)

Set operators for MoFEM dm.

Parameters

dm

Returns

error code

Definition at line 59 of file DMMMoFEM.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

)

sets up the MoFEM structures inside a DM object

Definition at line 932 of file DMMMoFEM.cpp.

                                    {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  ProblemsManager *prb_mng_ptr;
  MoFEMFunctionBegin;
  DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
  CHKERR dm_field->mField_ptr->getInterface(prb_mng_ptr);

  if (dm_field->isCompDM) {
    // It is composite probelm
    CHKERR prb_mng_ptr->buildCompsedProblem(
        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

)

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

Definition at line 979 of file DMMMoFEM.cpp.

                                            {
  PetscValidHeaderSpecific(subdm, DM_CLASSID, 1);
  ProblemsManager *prb_mng_ptr;
  MoFEMFunctionBegin;

  DMCtx *subdm_field = static_cast<DMCtx *>(subdm->data);

  // build sub dm problem
  CHKERR subdm_field->mField_ptr->getInterface(prb_mng_ptr);

  map<std::string, std::pair<EntityType, EntityType>> *entity_map_row = nullptr;
  map<std::string, std::pair<EntityType, EntityType>> *entity_map_col = nullptr;

  if(subdm_field->mapTypeRow)
    entity_map_row = subdm_field->mapTypeRow.get();
  if(subdm_field->mapTypeCol)
    entity_map_row = subdm_field->mapTypeCol.get();

  CHKERR prb_mng_ptr->buildSubProblem(
      subdm_field->problemName, subdm_field->rowFields, subdm_field->colFields,
      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);
}