PetscDMMoose.h File Reference

Go to the source code of this file.

Functions
PetscErrorCode	DMMooseRegisterAll ()
PetscErrorCode	DMCreateMoose (MPI_Comm comm, NonlinearSystemBase &nl, const std::string &dm_name, DM *dm)
	Create a MOOSE DM. More...
PetscErrorCode	DMMooseReset (DM)
PetscErrorCode	DMMooseSetNonlinearSystem (DM, NonlinearSystemBase &)
PetscErrorCode	DMMooseGetNonlinearSystem (DM, NonlinearSystemBase *&)
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 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
dm_name	A name to associate with the DM
dm	A pointer to the PETSc DM

Definition at line 2044 of file PetscDMMoose.C.

Referenced by DMCreateFieldDecomposition_Moose(), and Moose::PetscSupport::petscSetupDM().

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

DMMooseGetBlocks()

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

Definition at line 201 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 416 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 212 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 2156 of file PetscDMMoose.C.

Referenced by Moose::PetscSupport::petscSetupDM().

{
  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 1594 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 > &
	)

DMMooseSetNonlinearSystem()

PetscErrorCode DMMooseSetNonlinearSystem	(	DM	,
		NonlinearSystemBase &
	)

Definition at line 223 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 310 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 426 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 325 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 2117 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);
}