PetscDMMoose.h File Reference

Go to the source code of this file.

Namespaces
	libMesh
	The following methods are specializations for using the libMesh::Parallel::packed_range_* routines for std::strings.

Functions
PetscErrorCode	DMMooseRegisterAll ()
PetscErrorCode	DMCreateMoose (MPI_Comm comm, NonlinearSystemBase &nl, const libMesh::DofMapBase &dof_map, const libMesh::System &system, const std::string &dm_name, DM *dm)
	Create a MOOSE DM. More...
PetscErrorCode	DMMooseReset (DM)
PetscErrorCode	DMMooseSetNonlinearSystem (DM, NonlinearSystemBase &)
PetscErrorCode	DMMooseGetNonlinearSystem (DM, NonlinearSystemBase *&)
PetscErrorCode	DMMooseSetDofMap (DM, const libMesh::DofMapBase &)
PetscErrorCode	DMMooseGetBlocks (DM, std::vector< std::string > &)
PetscErrorCode	DMMooseGetVariables (DM, std::vector< std::string > &)
PetscErrorCode	DMMooseGetSides (DM, std::set< std::string > &)
PetscErrorCode	DMMooseGetUnSides (DM, std::set< std::string > &)
PetscErrorCode	DMMooseGetContacts (DM, std::vector< std::pair< std::string, std::string >> &, std::vector< bool > &)
PetscErrorCode	DMMooseGetUnContacts (DM, std::vector< std::pair< std::string, std::string >> &, std::vector< bool > &)
PetscErrorCode	DMMooseSetBlocks (DM, const std::vector< std::string > &)
PetscErrorCode	DMMooseSetVariables (DM, const std::vector< std::string > &)
PetscErrorCode	DMMooseSetSides (DM, const std::set< std::string > &)
PetscErrorCode	DMMooseSetUnSides (DM, const std::set< std::string > &)
PetscErrorCode	DMMooseSetContacts (DM, const std::vector< std::pair< std::string, std::string >> &, const std::vector< bool > &)
PetscErrorCode	DMMooseSetUnContacts (DM, const std::vector< std::pair< std::string, std::string >> &, const std::vector< bool > &)
PetscErrorCode	DMMooseSetSplitNames (DM, const std::vector< std::string > &)
PetscErrorCode	DMMooseGetSplitNames (DM, const std::vector< std::string > &)
PetscErrorCode	DMMooseSetSplitVars (DM, const std::string &, const std::set< std::string > &)
PetscErrorCode	DMMooseGetSplitVars (DM, const std::string &, std::set< std::string > &)
PetscErrorCode	DMMooseSetSplitBlocks (DM, const std::string &, const std::set< std::string > &)
PetscErrorCode	DMMooseGetSplitBlocks (DM, const std::string &, std::set< std::string > &)
PetscErrorCode	DMMooseSetSplitSides (DM, const std::string &, const std::set< std::string > &)
PetscErrorCode	DMMooseGetSplitSides (DM, const std::string &, std::set< std::string > &)
PetscErrorCode	SNESUpdateDMMoose (SNES snes, PetscInt iteration)

Function Documentation

DMCreateMoose()

PetscErrorCode DMCreateMoose	(	MPI_Comm	comm,
		NonlinearSystemBase &	nl,
		const libMesh::DofMapBase &	dof_map,
		const libMesh::System &	system,
		const std::string &	dm_name,
		DM *	dm
	)

Create a MOOSE DM.

Parameters

comm	The communicator that the DM should use
nl	The nonlinear system context that the DM is associated with
dof_map	A reference to the DoFMap, which you can get from the system
dm_name	A name to associate with the DM
dm	A pointer to the PETSc DM

Definition at line 2061 of file PetscDMMoose.C.

Referenced by FieldSplitPreconditionerTempl< MoosePreconditioner >::createMooseDM(), and DMCreateFieldDecomposition_Moose().

{
  PetscFunctionBegin;
  LibmeshPetscCallQ(DMCreate(comm, dm));
  LibmeshPetscCallQ(DMSetType(*dm, DMMOOSE));
  LibmeshPetscCallQ(DMMooseSetNonlinearSystem(*dm, nl));
  LibmeshPetscCallQ(DMMooseSetDofMap(*dm, dof_map));
  LibmeshPetscCallQ(DMMooseSetSystem(*dm, system));
  LibmeshPetscCallQ(DMMooseSetName(*dm, dm_name));
  PetscFunctionReturn(PETSC_SUCCESS);
}

DMMooseGetBlocks()

PetscErrorCode DMMooseGetBlocks	(	DM	,
		std::vector< std::string > &
	)

Definition at line 203 of file PetscDMMoose.C.

{
  PetscFunctionBegin;
  LibmeshPetscCallQ(DMMooseValidityCheck(dm));
  DM_Moose * dmm = (DM_Moose *)dm->data;
  for (const auto & it : *(dmm->_block_ids))
    block_names.push_back(it.first);
  PetscFunctionReturn(PETSC_SUCCESS);
}

DMMooseGetContacts()

PetscErrorCode DMMooseGetContacts	(	DM	,
		std::vector< std::pair< std::string, std::string >> &	,
		std::vector< bool > &
	)

DMMooseGetNonlinearSystem()

PetscErrorCode DMMooseGetNonlinearSystem	(	DM	,
		NonlinearSystemBase *&
	)

Definition at line 446 of file PetscDMMoose.C.

Referenced by DMMooseFunction(), DMMooseJacobian(), and DMVariableBounds_Moose().

{
  PetscFunctionBegin;
  LibmeshPetscCallQ(DMMooseValidityCheck(dm));
  DM_Moose * dmm = (DM_Moose *)(dm->data);
  nl = dmm->_nl;
  PetscFunctionReturn(PETSC_SUCCESS);
}

DMMooseGetSides()

PetscErrorCode DMMooseGetSides	(	DM	,
		std::set< std::string > &
	)

DMMooseGetSplitBlocks()

PetscErrorCode DMMooseGetSplitBlocks	(	DM	,
		const std::string &	,
		std::set< std::string > &
	)

DMMooseGetSplitNames()

PetscErrorCode DMMooseGetSplitNames	(	DM	,
		const std::vector< std::string > &
	)

DMMooseGetSplitSides()

PetscErrorCode DMMooseGetSplitSides	(	DM	,
		const std::string &	,
		std::set< std::string > &
	)

DMMooseGetSplitVars()

PetscErrorCode DMMooseGetSplitVars	(	DM	,
		const std::string &	,
		std::set< std::string > &
	)

DMMooseGetUnContacts()

PetscErrorCode DMMooseGetUnContacts	(	DM	,
		std::vector< std::pair< std::string, std::string >> &	,
		std::vector< bool > &
	)

DMMooseGetUnSides()

PetscErrorCode DMMooseGetUnSides	(	DM	,
		std::set< std::string > &
	)

DMMooseGetVariables()

PetscErrorCode DMMooseGetVariables	(	DM	,
		std::vector< std::string > &
	)

Definition at line 214 of file PetscDMMoose.C.

{
  PetscFunctionBegin;
  LibmeshPetscCallQ(DMMooseValidityCheck(dm));
  DM_Moose * dmm = (DM_Moose *)(dm->data);
  for (const auto & it : *(dmm->_var_ids))
    var_names.push_back(it.first);
  PetscFunctionReturn(PETSC_SUCCESS);
}

DMMooseRegisterAll()

PetscErrorCode DMMooseRegisterAll

(

)

Definition at line 2180 of file PetscDMMoose.C.

Referenced by StaticCondensationFieldSplitPreconditioner::setupDM(), and FieldSplitPreconditioner::setupDM().

{
  static PetscBool DMMooseRegisterAllCalled = PETSC_FALSE;

  PetscFunctionBegin;
  if (!DMMooseRegisterAllCalled)
  {
    LibmeshPetscCallQ(DMRegister(DMMOOSE, DMCreate_Moose));
    DMMooseRegisterAllCalled = PETSC_TRUE;
  }
  PetscFunctionReturn(PETSC_SUCCESS);
}

DMMooseReset()

PetscErrorCode DMMooseReset

(

DM

)

Definition at line 1612 of file PetscDMMoose.C.

Referenced by SNESUpdateDMMoose().

{
  PetscBool ismoose;
  DM_Moose * dmm = (DM_Moose *)(dm->data);

  PetscFunctionBegin;
  LibmeshPetscCallQ(PetscObjectTypeCompare((PetscObject)dm, DMMOOSE, &ismoose));
  if (!ismoose)
    PetscFunctionReturn(PETSC_SUCCESS);
  if (!dmm->_nl)
    SETERRQ(PETSC_COMM_WORLD, PETSC_ERR_ARG_WRONGSTATE, "No Moose system set for DM_Moose");
  LibmeshPetscCallQ(ISDestroy(&dmm->_embedding));
  for (auto & it : *(dmm->_splits))
  {
    DM_Moose::SplitInfo & split = it.second;
    LibmeshPetscCallQ(ISDestroy(&split._rembedding));
    if (split._dm)
      LibmeshPetscCallQ(DMMooseReset(split._dm));
  }
  dm->setupcalled = PETSC_FALSE;
  PetscFunctionReturn(PETSC_SUCCESS);
}

DMMooseSetBlocks()

PetscErrorCode DMMooseSetBlocks	(	DM	,
		const std::vector< std::string > &
	)

DMMooseSetContacts()

PetscErrorCode DMMooseSetContacts	(	DM	,
		const std::vector< std::pair< std::string, std::string >> &	,
		const std::vector< bool > &
	)

DMMooseSetDofMap()

PetscErrorCode DMMooseSetDofMap	(	DM	,
		const libMesh::DofMapBase &
	)

Definition at line 239 of file PetscDMMoose.C.

Referenced by DMCreateMoose().

{
  PetscFunctionBegin;
  LibmeshPetscCallQ(DMMooseValidityCheck(dm));
  if (dm->setupcalled)
    SETERRQ(((PetscObject)dm)->comm,
            PETSC_ERR_ARG_WRONGSTATE,
            "Cannot reset the degree of freedom map after DM has been set up.");
  DM_Moose * dmm = (DM_Moose *)(dm->data);
  dmm->_dof_map = &dof_map;
  PetscFunctionReturn(PETSC_SUCCESS);
}

DMMooseSetNonlinearSystem()

PetscErrorCode DMMooseSetNonlinearSystem	(	DM	,
		NonlinearSystemBase &
	)

Definition at line 225 of file PetscDMMoose.C.

Referenced by DMCreateMoose().

{
  PetscFunctionBegin;
  LibmeshPetscCallQ(DMMooseValidityCheck(dm));
  if (dm->setupcalled)
    SETERRQ(((PetscObject)dm)->comm,
            PETSC_ERR_ARG_WRONGSTATE,
            "Cannot reset the NonlinearSystem after DM has been set up.");
  DM_Moose * dmm = (DM_Moose *)(dm->data);
  dmm->_nl = &nl;
  PetscFunctionReturn(PETSC_SUCCESS);
}

DMMooseSetSides()

PetscErrorCode DMMooseSetSides	(	DM	,
		const std::set< std::string > &
	)

Definition at line 340 of file PetscDMMoose.C.

{
  DM_Moose * dmm = (DM_Moose *)dm->data;

  PetscFunctionBegin;
  LibmeshPetscCallQ(DMMooseValidityCheck(dm));
  if (dm->setupcalled)
    SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONGSTATE, "Not for an already setup DM");
  if (dmm->_sides)
    delete dmm->_sides;
  dmm->_sides = new std::set<std::string>(sides);
  PetscFunctionReturn(PETSC_SUCCESS);
}

DMMooseSetSplitBlocks()

PetscErrorCode DMMooseSetSplitBlocks	(	DM	,
		const std::string &	,
		const std::set< std::string > &
	)

DMMooseSetSplitNames()

PetscErrorCode DMMooseSetSplitNames	(	DM	,
		const std::vector< std::string > &
	)

Definition at line 456 of file PetscDMMoose.C.

Referenced by if().

{
  PetscFunctionBegin;
  LibmeshPetscCallQ(DMMooseValidityCheck(dm));
  DM_Moose * dmm = (DM_Moose *)(dm->data);

  if (dmm->_splits)
  {
    for (auto & it : *(dmm->_splits))
    {
      LibmeshPetscCallQ(DMDestroy(&(it.second._dm)));
      LibmeshPetscCallQ(ISDestroy(&(it.second._rembedding)));
    }
    delete dmm->_splits;
    dmm->_splits = LIBMESH_PETSC_NULLPTR;
  }
  if (dmm->_splitlocs)
  {
    delete dmm->_splitlocs;
    dmm->_splitlocs = LIBMESH_PETSC_NULLPTR;
  }
  dmm->_splits = new std::map<std::string, DM_Moose::SplitInfo>();
  dmm->_splitlocs = new std::multimap<std::string, unsigned int>();
  for (unsigned int i = 0; i < split_names.size(); ++i)
  {
    DM_Moose::SplitInfo info;
    info._dm = LIBMESH_PETSC_NULLPTR;
    info._rembedding = LIBMESH_PETSC_NULLPTR;
    std::string name = split_names[i];
    (*dmm->_splits)[name] = info;
    dmm->_splitlocs->insert(std::make_pair(name, i));
  }
  PetscFunctionReturn(PETSC_SUCCESS);
}

DMMooseSetSplitSides()

PetscErrorCode DMMooseSetSplitSides	(	DM	,
		const std::string &	,
		const std::set< std::string > &
	)

DMMooseSetSplitVars()

PetscErrorCode DMMooseSetSplitVars	(	DM	,
		const std::string &	,
		const std::set< std::string > &
	)

DMMooseSetUnContacts()

PetscErrorCode DMMooseSetUnContacts	(	DM	,
		const std::vector< std::pair< std::string, std::string >> &	,
		const std::vector< bool > &
	)

DMMooseSetUnSides()

PetscErrorCode DMMooseSetUnSides	(	DM	,
		const std::set< std::string > &
	)

Definition at line 355 of file PetscDMMoose.C.

{
  DM_Moose * dmm = (DM_Moose *)dm->data;

  PetscFunctionBegin;
  LibmeshPetscCallQ(DMMooseValidityCheck(dm));
  if (dm->setupcalled)
    SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONGSTATE, "Not for an already setup DM");
  if (dmm->_unsides)
    delete dmm->_unsides;
  dmm->_unsides = new std::set<std::string>(unsides);
  PetscFunctionReturn(PETSC_SUCCESS);
}

DMMooseSetVariables()

PetscErrorCode DMMooseSetVariables	(	DM	,
		const std::vector< std::string > &
	)

SNESUpdateDMMoose()

PetscErrorCode SNESUpdateDMMoose	(	SNES	snes,
		PetscInt	iteration
	)

Definition at line 2141 of file PetscDMMoose.C.

{
  /* This is called any time the structure of the problem changes in a way that affects the Jacobian
     sparsity pattern.
     For example, this may happen when NodeFaceConstraints change Jacobian's sparsity pattern based
     on newly-detected Penetration.
     In that case certain preconditioners (e.g., PCASM) will not work, unless we tell them that the
     sparsity pattern has changed.
     For now we are rebuilding the whole KSP, when necessary.
  */
  DM dm;
  KSP ksp;
  const char * prefix;
  MPI_Comm comm;
  PC pc;

  PetscFunctionBegin;
  if (iteration)
  {
    /* TODO: limit this only to situations when displaced (un)contact splits are present, as is
     * DisplacedProblem(). */
    LibmeshPetscCallQ(SNESGetDM(snes, &dm));
    LibmeshPetscCallQ(DMMooseReset(dm));
    LibmeshPetscCallQ(DMSetUp(dm));
    LibmeshPetscCallQ(SNESGetKSP(snes, &ksp));
    /* Should we rebuild the whole KSP? */
    LibmeshPetscCallQ(PetscObjectGetOptionsPrefix((PetscObject)ksp, &prefix));
    LibmeshPetscCallQ(PetscObjectGetComm((PetscObject)ksp, &comm));
    LibmeshPetscCallQ(PCCreate(comm, &pc));
    LibmeshPetscCallQ(PCSetDM(pc, dm));
    LibmeshPetscCallQ(PCSetOptionsPrefix(pc, prefix));
    LibmeshPetscCallQ(PCSetFromOptions(pc));
    LibmeshPetscCallQ(KSPSetPC(ksp, pc));
    LibmeshPetscCallQ(PCDestroy(&pc));
  }
  PetscFunctionReturn(PETSC_SUCCESS);
}