Moose::PetscSupport Namespace Reference

Classes
class	PetscOptions
	A struct for storing the various types of petsc options and values. More...
class	PetscOptionsScope
	Activates a problem's PETSc options database for the lifetime of this scope. More...

Functions
void	petscSetOptions (const PetscOptions &po, const SolverParams &solver_params, FEProblemBase *const problem=nullptr)
	A function for setting the PETSc options in PETSc from the options supplied to MOOSE.
void	petscSetOptions (const PetscOptions &po, const std::vector< SolverParams > &solver_params, FEProblemBase *problem)
	A function for setting the PETSc options in PETSc from the options supplied to MOOSE.
void	petscSetKSPDefaults (FEProblemBase &problem, KSP ksp)
	Set the default options for a KSP.
template<typename T >
void	setLinearSolverDefaults (FEProblemBase &problem, libMesh::LinearSolver< T > &linear_solver)
	Set the defaults for a libMesh LinearSolver.
void	petscSetDefaults (FEProblemBase &problem)
	Sets the default options for PETSc.
PetscErrorCode	petscSetupOutput (CommandLine *cmd_line)
void	outputNorm (libMesh::Real old_norm, libMesh::Real norm, bool use_color=false)
	Helper function for outputting the norm values with/without color.
PetscErrorCode	petscLinearMonitor (KSP, PetscInt its, PetscReal rnorm, void *void_ptr)
	Helper function for displaying the linear residual during PETSC solve.
void	processSingletonMooseWrappedOptions (FEProblemBase &fe_problem, const InputParameters &params)
	Process some MOOSE-wrapped PETSc options.
void	storePetscOptions (FEProblemBase &fe_problem, const std::string &prefix, const ParallelParamObject &param_object)
	Stores the PETSc options supplied from the parameter object on the problem.
void	setConvergedReasonFlags (FEProblemBase &fe_problem, std::string prefix)
	Set flags that will instruct the user on the reason their simulation diverged from PETSc's perspective.
void	setSolveTypeFromParams (FEProblemBase &fe_problem, const InputParameters &params)
	Sets the FE problem's solve type from the input params.
void	setLineSearchFromParams (FEProblemBase &fe_problem, const InputParameters &params)
	Sets the FE problem's line search from the input params.
void	setMFFDTypeFromParams (FEProblemBase &fe_problem, const InputParameters &params)
	Sets the FE problem's matrix-free finite difference type from the input params.
void	storePetscOptionsFromParams (FEProblemBase &fe_problem, const InputParameters &params)
	Stores the Petsc flags and pair options fron the input params in the given PetscOptions object.
void	addPetscFlagsToPetscOptions (const MultiMooseEnum &petsc_flags, std::string prefix, const ParallelParamObject &param_object, PetscOptions &petsc_options)
	Populate flags in a given PetscOptions object using a vector of input arguments.
void	addPetscPairsToPetscOptions (const std::vector< std::pair< MooseEnumItem, std::string > > &petsc_pair_options, const unsigned int mesh_dimension, std::string prefix, const ParallelParamObject &param_object, PetscOptions &petsc_options)
	Populate name and value pairs in a given PetscOptions object using vectors of input arguments.
std::set< std::string >	getPetscValidLineSearches ()
	Returns the valid petsc line search options as a set of strings.
InputParameters	getPetscValidParams ()
	Returns the PETSc options that are common between Executioners and Preconditioners.
MultiMooseEnum	getCommonPetscFlags ()
	A helper function to produce a MultiMooseEnum with commonly used PETSc single options (flags)
MultiMooseEnum	getCommonSNESFlags ()
	A helper function to produce a MultiMooseEnum with commonly used PETSc snes single options (flags)
MultiMooseEnum	getCommonKSPFlags ()
	A helper function to produce a MultiMooseEnum with commonly used PETSc ksp single options (flags)
MultiMooseEnum	getCommonPetscKeys ()
	A helper function to produce a MultiMooseEnum with commonly used PETSc iname options (keys in key-value pairs)
MultiMooseEnum	getCommonSNESKeys ()
	A helper function to produce a MultiMooseEnum with commonly used PETSc snes option names (keys)
MultiMooseEnum	getCommonKSPKeys ()
	A helper function to produce a MultiMooseEnum with commonly used PETSc ksp option names (keys)
bool	isSNESVI (FEProblemBase &fe_problem)
	check if SNES type is variational inequalities (VI) solver
void	setSinglePetscOption (const std::string &name, const std::string &value="", FEProblemBase *const problem=nullptr)
	A wrapper function for dealing with different versions of PetscOptionsSetValue.
void	setSinglePetscOptionIfAppropriate (const MultiMooseEnum &dont_add_these_options, const std::string &name, const std::string &value="", FEProblemBase *const problem=nullptr)
	Same as setSinglePetscOption, but does not set the option if it doesn't make sense for the current simulation type, e.g.
void	registerPetscCitation (const std::string &bibtex)
	Register a BibTeX entry with PETSc's citation list so that it is printed (alongside the run-specific citations from any PETSc solvers/preconditioners used) when the PETSc -citations option is enabled.
void	addPetscOptionsFromCommandline (FEProblemBase *const problem=nullptr)
	Insert command-line PETSc options into the active PETSc options database.
void	petscSetDefaultPCSide (FEProblemBase &problem, KSP ksp)
	Setup which side we want to apply preconditioner.
void	petscSetDefaultKSPNormType (FEProblemBase &problem, KSP ksp)
	Set norm type.
void	colorAdjacencyMatrix (PetscScalar *adjacency_matrix, unsigned int size, unsigned int colors, std::vector< unsigned int > &vertex_colors, const char *coloring_algorithm)
	This method takes an adjacency matrix, and a desired number of colors and applies a graph coloring algorithm to produce a coloring.
void	dontAddPetscFlag (const std::string &flag, PetscOptions &petsc_options)
	Function to ensure that a particular petsc option is not added to the PetscOptions storage object to be later set unless explicitly specified in input or on the command line.
void	dontAddNonlinearConvergedReason (FEProblemBase &fe_problem)
	Function to ensure that -snes_converged_reason is not added to the PetscOptions storage object to be later set unless explicitly specified in input or on the command line.
void	dontAddLinearConvergedReason (FEProblemBase &fe_problem)
	Function to ensure that -ksp_converged_reason is not added to the PetscOptions storage object to be later set unless explicitly specified in input or on the command line.
void	dontAddCommonKSPOptions (FEProblemBase &fe_problem)
	Function to ensure that common KSP options are not added to the PetscOptions storage object to be later set unless explicitly specified in input or on the command line.
void	dontAddCommonSNESOptions (FEProblemBase &fe_problem)
	Function to ensure that common SNES options are not added to the PetscOptions storage object to be later set unless explicitly specified in input or on the command line.
void	dontAddCommonSNESOptions (FEProblemBase &fe_problem, const std::string &prefix)
	Prefixed variant: suppress common SNES options for the system identified by prefix (e.g.
std::unique_ptr< PetscMatrix< Number > >	createMatrixFromFile (const libMesh::Parallel::Communicator &comm, Mat &petsc_mat, const std::string &binary_mat_file, unsigned int mat_number_to_load=1)
	Create a matrix from a binary file.
std::string	stringify (const LineSearchType &t)
std::string	stringify (const MffdType &t)
void	setSolverOptions (const SolverParams &solver_params, const MultiMooseEnum &dont_add_these_options)
void	petscSetOptionsHelper (const PetscOptions &po, FEProblemBase *const problem)
PetscErrorCode	petscNonlinearConverged (SNES, PetscInt it, PetscReal, PetscReal, PetscReal, SNESConvergedReason *reason, void *ctx)
PetscErrorCode	petscLinearConverged (KSP, PetscInt it, PetscReal, KSPConvergedReason *reason, void *ctx)
PCSide	getPetscPCSide (Moose::PCSideType pcs)
KSPNormType	getPetscKSPNormType (Moose::MooseKSPNormType kspnorm)
template<typename T >
void	checkUserProvidedPetscOption (const T &option, const ParallelParamObject &param_object)

Function Documentation

addPetscFlagsToPetscOptions()

void Moose::PetscSupport::addPetscFlagsToPetscOptions	(	const MultiMooseEnum &	petsc_flags,
		std::string	prefix,
		const ParallelParamObject &	param_object,
		PetscOptions &	petsc_options
	)

Populate flags in a given PetscOptions object using a vector of input arguments.

Parameters

petsc_flags	Container holding the flags of the petsc options
prefix	The prefix to add to the user provided petsc_flags. This should not contain a leading dash per PETSc prefix convention. Note that this function will immediately \emph add said dash at the start of prefix so that later calls to PetscOptionsSetValue work. This is the reason we pass prefix by value
param_object	The ParallelParamObject adding the PETSc options
petsc_options	Data structure which handles petsc options within moose

"-log_summary" cannot be used in the input file. This option needs to be set when PETSc is initialized which happens before the parser is even created. We'll throw an error if somebody attempts to add this option later.

"-log_summary" cannot be used in the input file. This option needs to be set when PETSc is initialized which happens before the parser is even created. We'll throw an error if somebody attempts to add this option later.

Definition at line 786 of file PetscSupport.C.

{
  prefix.insert(prefix.begin(), '-');
  checkPrefix(prefix);
 
  // Update the PETSc single flags
  for (const auto & option : petsc_flags)
  {
    checkUserProvidedPetscOption(option, param_object);
 
    const std::string & string_option = option.name();
 
    if (option == "-log_summary" || option == "-log_view")
      mooseError("The PETSc option \"-log_summary\" or \"-log_view\" can only be used on the "
                 "command line.  Please "
                 "remove it from the input file");
 
    // Update the stored items, but do not create duplicates
    const std::string prefixed_option = prefix + string_option.substr(1);
    if (!po.flags.isValueSet(prefixed_option))
    {
      po.flags.setAdditionalValue(prefixed_option);
      po.user_set_options.setAdditionalValue(prefixed_option);
    }
  }
}

Referenced by MFEMPetscNonlinearSolver::ConstructSolver(), and storePetscOptions().

addPetscOptionsFromCommandline()

void Moose::PetscSupport::addPetscOptionsFromCommandline

(

FEProblemBase *const

problem = nullptr

)

Insert command-line PETSc options into the active PETSc options database.

When problem is provided, this also reapplies vector and matrix type options that may have been consumed before the options database was rebuilt, which preserves PETSc's used-option bookkeeping for command-line '-vec_type' and '*mat_type' options.

Definition at line 328 of file PetscSupport.C.

{
  // commandline options always win
  // the options from a user commandline will overwrite the existing ones if any conflicts
  int argc;
  char ** args;
 
  LibmeshPetscCallA(PETSC_COMM_WORLD, PetscGetArgs(&argc, &args));
  std::vector<const char *> cl_args(args + 1, args + argc);
  const auto cl_argc = libMesh::cast_int<int>(cl_args.size());
 
  ::PetscOptions command_line_options;
  LibmeshPetscCallA(PETSC_COMM_WORLD, PetscOptionsCreate(&command_line_options));
  LibmeshPetscCallA(PETSC_COMM_WORLD,
                    PetscOptionsInsertArgs(command_line_options, cl_argc, cl_args.data()));
  LibmeshPetscCallA(PETSC_COMM_WORLD,
                    PetscOptionsInsertArgs(LIBMESH_PETSC_NULLPTR, cl_argc, cl_args.data()));
 
  if (!problem)
  {
    LibmeshPetscCallA(PETSC_COMM_WORLD, PetscOptionsDestroy(&command_line_options));
    return;
  }
 
  errorOnUnprefixedMatTypeOption(command_line_options, *problem);
 
  // Some vector/matrix-type options may have been consumed before the PETSc database rebuild.
  // Replay only the command-line-controlled applications so input-file options handled through
  // setSinglePetscOption() do not pay the cost twice.
  const bool have_vec_type = petscOptionsHasName(command_line_options, "-vec_type");
  bool have_mat_type = false;
 
  for (const auto sys_index : make_range(problem->numSolverSystems()))
  {
    have_mat_type = petscOptionsHasName(
        command_line_options, "-mat_type", problem->getSolverSystem(sys_index).name() + "_");
    if (have_mat_type)
      break;
  }
 
  if (have_vec_type)
    applyVectorTypeOptions(*problem);
  if (have_mat_type)
    applyMatrixTypeOptions(*problem);
 
  LibmeshPetscCallA(PETSC_COMM_WORLD, PetscOptionsDestroy(&command_line_options));
}

Referenced by petscSetOptionsHelper(), and Moose::SlepcSupport::slepcSetOptions().

addPetscPairsToPetscOptions()

void Moose::PetscSupport::addPetscPairsToPetscOptions	(	const std::vector< std::pair< MooseEnumItem, std::string > > &	petsc_pair_options,
		const unsigned int	mesh_dimension,
		std::string	prefix,
		const ParallelParamObject &	param_object,
		PetscOptions &	petsc_options
	)

Populate name and value pairs in a given PetscOptions object using vectors of input arguments.

Parameters

petsc_pair_options	Option-value pairs of petsc settings
mesh_dimension	The mesh dimension, needed for multigrid settings
prefix	The prefix to add to the user provided petsc_pair_options. This should not contain a leading dash per PETSc prefix convention. Note that this function will immediately \emph add said dash at the start of prefix so that later calls to PetscOptionsSetValue work. This is the reason we pass prefix by value
param_object	The ParallelParamObject adding the PETSc options
petsc_options	Data structure which handles petsc options within moose

Definition at line 850 of file PetscSupport.C.

{
  prefix.insert(prefix.begin(), '-');
  checkPrefix(prefix);
 
  // Setup the name value pairs
  bool boomeramg_found = false;
  bool strong_threshold_found = false;
#if !PETSC_VERSION_LESS_THAN(3, 7, 0)
  bool superlu_dist_found = false;
  bool fact_pattern_found = false;
  bool tiny_pivot_found = false;
#endif
  std::string pc_description = "";
#if !PETSC_VERSION_LESS_THAN(3, 12, 0)
  // If users use HMG, we would like to set
  bool hmg_found = false;
  bool matptap_found = false;
  bool hmg_strong_threshold_found = false;
#endif
  std::vector<std::pair<std::string, std::string>> new_options;
 
  for (const auto & [option_name, option_value] : petsc_pair_options)
  {
    checkUserProvidedPetscOption(option_name, param_object);
 
    new_options.clear();
    const std::string prefixed_option_name =
        prefix + static_cast<const std::string &>(option_name).substr(1);
 
    // Do not add duplicate settings
    if (auto it =
            MooseUtils::findPair(po.pairs, po.pairs.begin(), prefixed_option_name, MooseUtils::Any);
        it == po.pairs.end())
    {
#if !PETSC_VERSION_LESS_THAN(3, 9, 0)
      if (option_name == "-pc_factor_mat_solver_package")
        new_options.emplace_back(prefix + "pc_factor_mat_solver_type", option_value);
#else
      if (option_name == "-pc_factor_mat_solver_type")
        new_options.push_back(prefix + "pc_factor_mat_solver_package", option_value);
#endif
 
      // Look for a pc description
      if (option_name == "-pc_type" || option_name == "-sub_pc_type" ||
          option_name == "-pc_hypre_type")
        pc_description += option_value + ' ';
 
#if !PETSC_VERSION_LESS_THAN(3, 12, 0)
      if (option_name == "-pc_type" && option_value == "hmg")
        hmg_found = true;
 
      // MPIAIJ for PETSc 3.12.0: -matptap_via
      // MAIJ for PETSc 3.12.0: -matmaijptap_via
      // MPIAIJ for PETSc 3.13 to 3.16: -matptap_via, -matproduct_ptap_via
      // MAIJ for PETSc 3.13 to 3.16: -matproduct_ptap_via
      // MPIAIJ for PETSc 3.17 and higher: -matptap_via, -mat_product_algorithm
      // MAIJ for PETSc 3.17 and higher: -mat_product_algorithm
#if !PETSC_VERSION_LESS_THAN(3, 17, 0)
      if (hmg_found && (option_name == "-matptap_via" || option_name == "-matmaijptap_via" ||
                        option_name == "-matproduct_ptap_via"))
        new_options.emplace_back(prefix + "mat_product_algorithm", option_value);
#elif !PETSC_VERSION_LESS_THAN(3, 13, 0)
      if (hmg_found && (option_name == "-matptap_via" || option_name == "-matmaijptap_via"))
        new_options.emplace_back(prefix + "matproduct_ptap_via", option_value);
#else
      if (hmg_found && (option_name == "-matproduct_ptap_via"))
      {
        new_options.emplace_back(prefix + "matptap_via", option_value);
        new_options.emplace_back(prefix + "matmaijptap_via", option_value);
      }
#endif
 
      if (option_name == "-matptap_via" || option_name == "-matmaijptap_via" ||
          option_name == "-matproduct_ptap_via" || option_name == "-mat_product_algorithm")
        matptap_found = true;
 
      // For 3D problems, we need to set this 0.7
      if (option_name == "-hmg_inner_pc_hypre_boomeramg_strong_threshold")
        hmg_strong_threshold_found = true;
#endif
      // This special case is common enough that we'd like to handle it for the user.
      if (option_name == "-pc_hypre_type" && option_value == "boomeramg")
        boomeramg_found = true;
      if (option_name == "-pc_hypre_boomeramg_strong_threshold")
        strong_threshold_found = true;
#if !PETSC_VERSION_LESS_THAN(3, 7, 0)
      if ((option_name == "-pc_factor_mat_solver_package" ||
           option_name == "-pc_factor_mat_solver_type") &&
          option_value == "superlu_dist")
        superlu_dist_found = true;
      if (option_name == "-mat_superlu_dist_fact")
        fact_pattern_found = true;
      if (option_name == "-mat_superlu_dist_replacetinypivot")
        tiny_pivot_found = true;
#endif
 
      if (!new_options.empty())
      {
        std::copy(new_options.begin(), new_options.end(), std::back_inserter(po.pairs));
        for (const auto & option : new_options)
          po.user_set_options.setAdditionalValue(option.first);
      }
      else
      {
        po.pairs.push_back(std::make_pair(prefixed_option_name, option_value));
        po.user_set_options.setAdditionalValue(prefixed_option_name);
      }
    }
    else
    {
      do
      {
        it->second = option_value;
        it = MooseUtils::findPair(po.pairs, std::next(it), prefixed_option_name, MooseUtils::Any);
      } while (it != po.pairs.end());
    }
  }
 
  // When running a 3D mesh with boomeramg, it is almost always best to supply a strong threshold
  // value. We will provide that for the user here if they haven't supplied it themselves.
  if (boomeramg_found && !strong_threshold_found && mesh_dimension == 3)
  {
    po.pairs.emplace_back(prefix + "pc_hypre_boomeramg_strong_threshold", "0.7");
    pc_description += "strong_threshold: 0.7 (auto)";
  }
 
#if !PETSC_VERSION_LESS_THAN(3, 12, 0)
  if (hmg_found && !hmg_strong_threshold_found && mesh_dimension == 3)
  {
    po.pairs.emplace_back(prefix + "hmg_inner_pc_hypre_boomeramg_strong_threshold", "0.7");
    pc_description += "strong_threshold: 0.7 (auto)";
  }
 
  // Default PETSc PtAP takes too much memory, and it is not quite useful
  // Let us switch to use new algorithm
  if (hmg_found && !matptap_found)
  {
#if !PETSC_VERSION_LESS_THAN(3, 17, 0)
    po.pairs.emplace_back(prefix + "mat_product_algorithm", "allatonce");
#elif !PETSC_VERSION_LESS_THAN(3, 13, 0)
    po.pairs.emplace_back(prefix + "matproduct_ptap_via", "allatonce");
#else
    po.pairs.emplace_back(prefix + "matptap_via", "allatonce");
    po.pairs.emplace_back(prefix + "matmaijptap_via", "allatonce");
#endif
  }
#endif
 
#if !PETSC_VERSION_LESS_THAN(3, 7, 0)
  // In PETSc-3.7.{0--4}, there is a bug when using superlu_dist, and we have to use
  // SamePattern_SameRowPerm, otherwise we use whatever we have in PETSc
  if (superlu_dist_found && !fact_pattern_found)
  {
    po.pairs.emplace_back(prefix + "mat_superlu_dist_fact",
#if PETSC_VERSION_LESS_THAN(3, 7, 5)
                          "SamePattern_SameRowPerm");
    pc_description += "mat_superlu_dist_fact: SamePattern_SameRowPerm ";
#else
                          "SamePattern");
    pc_description += "mat_superlu_dist_fact: SamePattern ";
#endif
  }
 
  // restore this superlu  option
  if (superlu_dist_found && !tiny_pivot_found)
  {
    po.pairs.emplace_back(prefix + "mat_superlu_dist_replacetinypivot", "1");
    pc_description += " mat_superlu_dist_replacetinypivot: true ";
  }
#endif
  // Set Preconditioner description
  if (!pc_description.empty() && prefix.size() > 1)
    po.pc_description += "[" + prefix.substr(1, prefix.size() - 2) + "]: ";
  po.pc_description += pc_description;
}

Referenced by PhysicsBase::addPetscPairsToPetscOptions(), MFEMPetscNonlinearSolver::ConstructSolver(), and storePetscOptions().

checkUserProvidedPetscOption()

template<typename T >

void Moose::PetscSupport::checkUserProvidedPetscOption	(	const T &	option,
		const ParallelParamObject &	param_object
	)

Definition at line 778 of file PetscSupport.C.

{
  const auto & string_option = static_cast<const std::string &>(option);
  if (string_option[0] != '-')
    param_object.mooseError("PETSc option '", string_option, "' does not begin with '-'");
}

Referenced by addPetscFlagsToPetscOptions(), and addPetscPairsToPetscOptions().

colorAdjacencyMatrix()

void Moose::PetscSupport::colorAdjacencyMatrix	(	PetscScalar *	adjacency_matrix,
		unsigned int	size,
		unsigned int	colors,
		std::vector< unsigned int > &	vertex_colors,
		const char *	coloring_algorithm
	)

This method takes an adjacency matrix, and a desired number of colors and applies a graph coloring algorithm to produce a coloring.

The coloring is returned as a vector of unsigned integers indicating which color or group each vextex in the adjacency matrix belongs to.

Definition at line 1229 of file PetscSupport.C.

{
  // Mat A will be a dense matrix from the incoming data structure
  Mat A;
  LibmeshPetscCallA(PETSC_COMM_SELF, MatCreate(PETSC_COMM_SELF, &A));
  LibmeshPetscCallA(PETSC_COMM_SELF, MatSetSizes(A, size, size, size, size));
  LibmeshPetscCallA(PETSC_COMM_SELF, MatSetType(A, MATSEQDENSE));
  // PETSc requires a non-const data array to populate the matrix
  LibmeshPetscCallA(PETSC_COMM_SELF, MatSeqDenseSetPreallocation(A, adjacency_matrix));
  LibmeshPetscCallA(PETSC_COMM_SELF, MatAssemblyBegin(A, MAT_FINAL_ASSEMBLY));
  LibmeshPetscCallA(PETSC_COMM_SELF, MatAssemblyEnd(A, MAT_FINAL_ASSEMBLY));
 
  // Convert A to a sparse matrix
#if PETSC_VERSION_LESS_THAN(3, 7, 0)
  LibmeshPetscCallA(PETSC_COMM_SELF, MatConvert(A, MATAIJ, MAT_REUSE_MATRIX, &A));
#else
  LibmeshPetscCallA(PETSC_COMM_SELF, MatConvert(A, MATAIJ, MAT_INPLACE_MATRIX, &A));
#endif
 
  ISColoring iscoloring;
  MatColoring mc;
  LibmeshPetscCallA(PETSC_COMM_SELF, MatColoringCreate(A, &mc));
  LibmeshPetscCallA(PETSC_COMM_SELF, MatColoringSetType(mc, coloring_algorithm));
  LibmeshPetscCallA(PETSC_COMM_SELF, MatColoringSetMaxColors(mc, static_cast<PetscInt>(colors)));
 
  // Petsc normally colors by distance two (neighbors of neighbors), we just want one
  LibmeshPetscCallA(PETSC_COMM_SELF, MatColoringSetDistance(mc, 1));
  LibmeshPetscCallA(PETSC_COMM_SELF, MatColoringSetFromOptions(mc));
  LibmeshPetscCallA(PETSC_COMM_SELF, MatColoringApply(mc, &iscoloring));
 
  PetscInt nn;
  IS * is;
#if PETSC_RELEASE_LESS_THAN(3, 12, 0)
  LibmeshPetscCallA(PETSC_COMM_SELF, ISColoringGetIS(iscoloring, &nn, &is));
#else
  LibmeshPetscCallA(PETSC_COMM_SELF, ISColoringGetIS(iscoloring, PETSC_USE_POINTER, &nn, &is));
#endif
 
  if (nn > static_cast<PetscInt>(colors))
    throw std::runtime_error("Not able to color with designated number of colors");
 
  for (int i = 0; i < nn; i++)
  {
    PetscInt isize;
    const PetscInt * indices;
    LibmeshPetscCallA(PETSC_COMM_SELF, ISGetLocalSize(is[i], &isize));
    LibmeshPetscCallA(PETSC_COMM_SELF, ISGetIndices(is[i], &indices));
    for (int j = 0; j < isize; j++)
    {
      mooseAssert(indices[j] < static_cast<PetscInt>(vertex_colors.size()), "Index out of bounds");
      vertex_colors[indices[j]] = i;
    }
    LibmeshPetscCallA(PETSC_COMM_SELF, ISRestoreIndices(is[i], &indices));
  }
 
  LibmeshPetscCallA(PETSC_COMM_SELF, MatDestroy(&A));
  LibmeshPetscCallA(PETSC_COMM_SELF, MatColoringDestroy(&mc));
  LibmeshPetscCallA(PETSC_COMM_SELF, ISColoringDestroy(&iscoloring));
}

createMatrixFromFile()

std::unique_ptr< PetscMatrix< Number > > Moose::PetscSupport::createMatrixFromFile	(	const libMesh::Parallel::Communicator &	comm,
		Mat &	petsc_mat,
		const std::string &	binary_mat_file,
		unsigned int	mat_number_to_load = 1
	)

Create a matrix from a binary file.

Note that the returned libMesh matrix wrapper will not destroy the created matrix on destruction. petsc_mat must be destroyed manually via MatDestroy

Parameters

mat_number_to_load

A binary file may contain multiple writes of a matrix. This parameter can be used to load a particular matrix from the binary file. By default we load the first written matrix

Definition at line 1339 of file PetscSupport.C.

{
  LibmeshPetscCallA(comm.get(), MatCreate(comm.get(), &mat));
  PetscViewer matviewer;
  LibmeshPetscCallA(
      comm.get(),
      PetscViewerBinaryOpen(comm.get(), binary_mat_file.c_str(), FILE_MODE_READ, &matviewer));
  for (unsigned int i = 0; i < mat_number_to_load; ++i)
    LibmeshPetscCallA(comm.get(), MatLoad(mat, matviewer));
  LibmeshPetscCallA(comm.get(), PetscViewerDestroy(&matviewer));
 
  return std::make_unique<PetscMatrix<Number>>(mat, comm);
}

Referenced by MatrixSymmetryCheck::execute().

dontAddCommonKSPOptions()

void Moose::PetscSupport::dontAddCommonKSPOptions

(

FEProblemBase &

fe_problem

)

Function to ensure that common KSP options are not added to the PetscOptions storage object to be later set unless explicitly specified in input or on the command line.

Definition at line 1313 of file PetscSupport.C.

{
  auto & petsc_options = fe_problem.getPetscOptions();
  for (const auto & flag : getCommonKSPFlags().getNames())
    dontAddPetscFlag(flag, petsc_options);
  for (const auto & key : getCommonKSPKeys().getNames())
    dontAddPetscFlag(key, petsc_options);
}

Referenced by ExplicitTimeIntegrator::ExplicitTimeIntegrator().

dontAddCommonSNESOptions() [1/2]

void Moose::PetscSupport::dontAddCommonSNESOptions

(

FEProblemBase &

fe_problem

)

Function to ensure that common SNES options are not added to the PetscOptions storage object to be later set unless explicitly specified in input or on the command line.

Definition at line 1323 of file PetscSupport.C.

{
  dontAddCommonSNESOptions(fe_problem, "");
}

Referenced by dontAddCommonSNESOptions(), ExplicitTimeIntegrator::ExplicitTimeIntegrator(), and FEProblemSolve::FEProblemSolve().

dontAddCommonSNESOptions() [2/2]

void Moose::PetscSupport::dontAddCommonSNESOptions	(	FEProblemBase &	fe_problem,
		const std::string &	prefix
	)

Prefixed variant: suppress common SNES options for the system identified by prefix (e.g.

"v_sys_"). Adds the prefixed flag/key names to the blocklist so that setSolverOptions and setConvergedReasonFlags skip them for that system.

Definition at line 1329 of file PetscSupport.C.

{
  auto & petsc_options = fe_problem.getPetscOptions();
  for (const auto & flag : getCommonSNESFlags().getNames())
    dontAddPetscFlag("-" + prefix + flag.substr(1), petsc_options);
  for (const auto & key : getCommonSNESKeys().getNames())
    dontAddPetscFlag("-" + prefix + key.substr(1), petsc_options);
}

dontAddLinearConvergedReason()

void Moose::PetscSupport::dontAddLinearConvergedReason

(

FEProblemBase &

fe_problem

)

Function to ensure that -ksp_converged_reason is not added to the PetscOptions storage object to be later set unless explicitly specified in input or on the command line.

Definition at line 1307 of file PetscSupport.C.

{
  dontAddPetscFlag("-ksp_converged_reason", fe_problem.getPetscOptions());
}

Referenced by CommonOutputAction::act(), and EigenProblemSolve::EigenProblemSolve().

dontAddNonlinearConvergedReason()

void Moose::PetscSupport::dontAddNonlinearConvergedReason

(

FEProblemBase &

fe_problem

)

Function to ensure that -snes_converged_reason is not added to the PetscOptions storage object to be later set unless explicitly specified in input or on the command line.

Definition at line 1301 of file PetscSupport.C.

{
  dontAddPetscFlag("-snes_converged_reason", fe_problem.getPetscOptions());
}

Referenced by CommonOutputAction::act(), and EigenProblemSolve::EigenProblemSolve().

dontAddPetscFlag()

void Moose::PetscSupport::dontAddPetscFlag	(	const std::string &	flag,
		PetscOptions &	petsc_options
	)

Function to ensure that a particular petsc option is not added to the PetscOptions storage object to be later set unless explicitly specified in input or on the command line.

Definition at line 1294 of file PetscSupport.C.

{
  if (!petsc_options.dont_add_these_options.contains(flag))
    petsc_options.dont_add_these_options.setAdditionalValue(flag);
}

Referenced by dontAddCommonKSPOptions(), dontAddCommonSNESOptions(), dontAddLinearConvergedReason(), dontAddNonlinearConvergedReason(), and EigenProblemSolve::EigenProblemSolve().

getCommonKSPFlags()

MultiMooseEnum Moose::PetscSupport::getCommonKSPFlags

(

)

A helper function to produce a MultiMooseEnum with commonly used PETSc ksp single options (flags)

Definition at line 1085 of file PetscSupport.C.

{
  return MultiMooseEnum(
      "-ksp_converged_reason -ksp_gmres_modifiedgramschmidt -ksp_monitor", "", true);
}

Referenced by dontAddCommonKSPOptions(), and getCommonPetscFlags().

getCommonKSPKeys()

MultiMooseEnum Moose::PetscSupport::getCommonKSPKeys

(

)

A helper function to produce a MultiMooseEnum with commonly used PETSc ksp option names (keys)

Definition at line 1110 of file PetscSupport.C.

{
  return MultiMooseEnum("-ksp_atol -ksp_gmres_restart -ksp_max_it -ksp_pc_side -ksp_rtol "
                        "-ksp_type -sub_ksp_type",
                        "",
                        true);
}

Referenced by dontAddCommonKSPOptions(), and getCommonPetscKeys().

getCommonPetscFlags()

MultiMooseEnum Moose::PetscSupport::getCommonPetscFlags

(

)

A helper function to produce a MultiMooseEnum with commonly used PETSc single options (flags)

Definition at line 1092 of file PetscSupport.C.

{
  auto options = MultiMooseEnum("-dm_moose_print_embedding -dm_view", "", true);
  options.addValidName(getCommonKSPFlags());
  options.addValidName(getCommonSNESFlags());
  return options;
}

Referenced by getPetscValidParams(), AddFieldSplitAction::validParams(), MFEMPetscNonlinearSolver::validParams(), and Split::validParams().

getCommonPetscKeys()

MultiMooseEnum Moose::PetscSupport::getCommonPetscKeys

(

)

A helper function to produce a MultiMooseEnum with commonly used PETSc iname options (keys in key-value pairs)

Definition at line 1118 of file PetscSupport.C.

{
  auto options = MultiMooseEnum("-mat_fd_coloring_err -mat_fd_type -mat_mffd_type "
                                "-pc_asm_overlap -pc_factor_levels "
                                "-pc_factor_mat_ordering_type -pc_hypre_boomeramg_grid_sweeps_all "
                                "-pc_hypre_boomeramg_max_iter "
                                "-pc_hypre_boomeramg_strong_threshold -pc_hypre_type -pc_type "
                                "-sub_pc_type",
                                "",
                                true);
  options.addValidName(getCommonKSPKeys());
  options.addValidName(getCommonSNESKeys());
  return options;
}

Referenced by getPetscValidParams(), AddFieldSplitAction::validParams(), MFEMPetscNonlinearSolver::validParams(), and Split::validParams().

getCommonSNESFlags()

MultiMooseEnum Moose::PetscSupport::getCommonSNESFlags

(

)

A helper function to produce a MultiMooseEnum with commonly used PETSc snes single options (flags)

Definition at line 1074 of file PetscSupport.C.

{
  return MultiMooseEnum(
      "-ksp_monitor_snes_lg -snes_ksp_ew -snes_converged_reason "
      "-snes_ksp -snes_linesearch_monitor -snes_mf -snes_mf_operator -snes_monitor "
      "-snes_test_display -snes_view -snes_monitor_cancel",
      "",
      true);
}

Referenced by dontAddCommonSNESOptions(), and getCommonPetscFlags().

getCommonSNESKeys()

MultiMooseEnum Moose::PetscSupport::getCommonSNESKeys

(

)

A helper function to produce a MultiMooseEnum with commonly used PETSc snes option names (keys)

Definition at line 1101 of file PetscSupport.C.

{
  return MultiMooseEnum("-snes_atol -snes_linesearch_type -snes_ls -snes_max_it -snes_rtol "
                        "-snes_divergence_tolerance -snes_type",
                        "",
                        true);
}

Referenced by dontAddCommonSNESOptions(), and getCommonPetscKeys().

getPetscKSPNormType()

KSPNormType Moose::PetscSupport::getPetscKSPNormType

(

Moose::MooseKSPNormType

kspnorm

)

Definition at line 550 of file PetscSupport.C.

{
  switch (kspnorm)
  {
    case Moose::KSPN_NONE:
      return KSP_NORM_NONE;
    case Moose::KSPN_PRECONDITIONED:
      return KSP_NORM_PRECONDITIONED;
    case Moose::KSPN_UNPRECONDITIONED:
      return KSP_NORM_UNPRECONDITIONED;
    case Moose::KSPN_NATURAL:
      return KSP_NORM_NATURAL;
    case Moose::KSPN_DEFAULT:
      return KSP_NORM_DEFAULT;
    default:
      mooseError("Unknown KSP norm type requested.");
      break;
  }
}

Referenced by petscSetDefaultKSPNormType().

getPetscPCSide()

PCSide Moose::PetscSupport::getPetscPCSide

(

Moose::PCSideType

pcs

)

Definition at line 533 of file PetscSupport.C.

{
  switch (pcs)
  {
    case Moose::PCS_LEFT:
      return PC_LEFT;
    case Moose::PCS_RIGHT:
      return PC_RIGHT;
    case Moose::PCS_SYMMETRIC:
      return PC_SYMMETRIC;
    default:
      mooseError("Unknown PC side requested.");
      break;
  }
}

Referenced by petscSetDefaultPCSide().

getPetscValidLineSearches()

std::set< std::string > Moose::PetscSupport::getPetscValidLineSearches

(

)

Returns the valid petsc line search options as a set of strings.

Definition at line 1033 of file PetscSupport.C.

{
  return {"default", "shell", "none", "basic", "l2", "bt", "cp"};
}

Referenced by FEProblemSolve::validParams().

getPetscValidParams()

InputParameters Moose::PetscSupport::getPetscValidParams

(

)

Returns the PETSc options that are common between Executioners and Preconditioners.

Returns

InputParameters object containing the PETSc related parameters

The output of this function should be added to the the parameters object of the overarching class

See also

CreateExecutionerAction

Definition at line 1039 of file PetscSupport.C.

{
  InputParameters params = emptyInputParameters();
 
  MooseEnum solve_type("PJFNK JFNK NEWTON FD LINEAR");
  params.addParam<MooseEnum>("solve_type",
                             solve_type,
                             "PJFNK: Preconditioned Jacobian-Free Newton Krylov "
                             "JFNK: Jacobian-Free Newton Krylov "
                             "NEWTON: Full Newton Solve "
                             "FD: Use finite differences to compute Jacobian "
                             "LINEAR: Solving a linear problem");
 
  MooseEnum mffd_type("wp ds", "wp");
  params.addParam<MooseEnum>("mffd_type",
                             mffd_type,
                             "Specifies the finite differencing type for "
                             "Jacobian-free solve types. Note that the "
                             "default is wp (for Walker and Pernice).");
 
  params.addParam<MultiMooseEnum>(
      "petsc_options", getCommonPetscFlags(), "Singleton PETSc options");
  params.addParam<MultiMooseEnum>(
      "petsc_options_iname", getCommonPetscKeys(), "Names of PETSc name/value pairs");
  params.addParam<std::vector<std::string>>(
      "petsc_options_value",
      "Values of PETSc name/value pairs (must correspond with \"petsc_options_iname\"");
  params.addParamNamesToGroup("solve_type petsc_options petsc_options_iname petsc_options_value "
                              "mffd_type",
                              "PETSc");
 
  return params;
}

Referenced by FEProblemSolve::validParams(), and MoosePreconditioner::validParams().

isSNESVI()

bool Moose::PetscSupport::isSNESVI

(

FEProblemBase &

fe_problem

)

check if SNES type is variational inequalities (VI) solver

Definition at line 1134 of file PetscSupport.C.

{
  const PetscOptions & petsc = fe_problem.getPetscOptions();
 
  int argc;
  char ** args;
  LibmeshPetscCallA(fe_problem.comm().get(), PetscGetArgs(&argc, &args));
 
  std::vector<std::string> cml_arg;
  for (int i = 0; i < argc; i++)
    cml_arg.push_back(args[i]);
 
  if (MooseUtils::findPair(petsc.pairs, petsc.pairs.begin(), MooseUtils::Any, "vinewtonssls") ==
          petsc.pairs.end() &&
      MooseUtils::findPair(petsc.pairs, petsc.pairs.begin(), MooseUtils::Any, "vinewtonrsls") ==
          petsc.pairs.end() &&
      std::find(cml_arg.begin(), cml_arg.end(), "vinewtonssls") == cml_arg.end() &&
      std::find(cml_arg.begin(), cml_arg.end(), "vinewtonrsls") == cml_arg.end())
    return false;
 
  return true;
}

Referenced by BoundsBase::initialSetup().

outputNorm()

void Moose::PetscSupport::outputNorm	(	libMesh::Real	old_norm,
		libMesh::Real	norm,
		bool	use_color = false
	)

Helper function for outputting the norm values with/without color.

petscLinearConverged()

PetscErrorCode Moose::PetscSupport::petscLinearConverged	(	KSP	,
		PetscInt	it,
		PetscReal	,
		KSPConvergedReason *	reason,
		void *	ctx
	)

Definition at line 483 of file PetscSupport.C.

{
  PetscFunctionBegin;
  FEProblemBase & problem = *static_cast<FEProblemBase *>(ctx);
 
  // execute objects that may be used in convergence check
  // Right now, setting objects to execute on this flag would be ignored except in the
  // linear-system-only use case.
  problem.execute(EXEC_LINEAR_CONVERGENCE);
 
  // perform the convergence check
  Convergence::MooseConvergenceStatus status;
  if (problem.getFailNextSystemConvergenceCheck())
  {
    status = Convergence::MooseConvergenceStatus::DIVERGED;
    problem.resetFailNextSystemConvergenceCheck();
  }
  else
  {
    auto & convergence = problem.getConvergence(
        problem.getLinearConvergenceNames()[problem.currentLinearSystem().number()]);
    status = convergence.checkConvergence(it);
  }
 
  // convert convergence status to PETSc converged reason
  switch (status)
  {
    case Convergence::MooseConvergenceStatus::ITERATING:
      *reason = KSP_CONVERGED_ITERATING;
      break;
 
      // TODO: find a KSP code that works better for this case
    case Convergence::MooseConvergenceStatus::CONVERGED:
#if PETSC_VERSION_LESS_THAN(3, 24, 0)
      *reason = KSP_CONVERGED_RTOL_NORMAL;
#else
      *reason = KSP_CONVERGED_RTOL_NORMAL_EQUATIONS;
#endif
      break;
 
    case Convergence::MooseConvergenceStatus::DIVERGED:
      *reason = KSP_DIVERGED_DTOL;
      break;
  }
 
  PetscFunctionReturn(PETSC_SUCCESS);
}

Referenced by petscSetDefaults().

petscLinearMonitor()

PetscErrorCode Moose::PetscSupport::petscLinearMonitor	(	KSP	,
		PetscInt	its,
		PetscReal	rnorm,
		void *	void_ptr
	)

Helper function for displaying the linear residual during PETSC solve.

petscNonlinearConverged()

PetscErrorCode Moose::PetscSupport::petscNonlinearConverged	(	SNES	,
		PetscInt	it,
		PetscReal	,
		PetscReal	,
		PetscReal	,
		SNESConvergedReason *	reason,
		void *	ctx
	)

Definition at line 435 of file PetscSupport.C.

{
  PetscFunctionBegin;
  FEProblemBase & problem = *static_cast<FEProblemBase *>(ctx);
 
  // execute objects that may be used in convergence check
  problem.execute(EXEC_NONLINEAR_CONVERGENCE);
 
  // perform the convergence check
  Convergence::MooseConvergenceStatus status;
  if (problem.getFailNextNonlinearConvergenceCheck())
  {
    status = Convergence::MooseConvergenceStatus::DIVERGED;
    problem.resetFailNextNonlinearConvergenceCheck();
  }
  else
  {
    auto & convergence = problem.getConvergence(
        problem.getNonlinearConvergenceNames()[problem.currentNonlinearSystem().number()]);
    status = convergence.checkConvergence(it);
  }
 
  // convert convergence status to PETSc converged reason
  switch (status)
  {
    case Convergence::MooseConvergenceStatus::ITERATING:
      *reason = SNES_CONVERGED_ITERATING;
      break;
 
    case Convergence::MooseConvergenceStatus::CONVERGED:
      *reason = SNES_CONVERGED_FNORM_ABS;
      break;
 
    case Convergence::MooseConvergenceStatus::DIVERGED:
      *reason = SNES_DIVERGED_DTOL;
      break;
  }
 
  PetscFunctionReturn(PETSC_SUCCESS);
}

Referenced by petscSetDefaults().

petscSetDefaultKSPNormType()

void Moose::PetscSupport::petscSetDefaultKSPNormType	(	FEProblemBase &	problem,
		KSP	ksp
	)

Set norm type.

Definition at line 571 of file PetscSupport.C.

{
  for (const auto i : make_range(problem.numSolverSystems()))
  {
    SolverSystem & sys = problem.getSolverSystem(i);
    LibmeshPetscCallA(problem.comm().get(),
                      KSPSetNormType(ksp, getPetscKSPNormType(sys.getMooseKSPNormType())));
  }
}

Referenced by Moose::SlepcSupport::mooseSlepcEPSSNESKSPSetPCSide(), and petscSetKSPDefaults().

petscSetDefaultPCSide()

void Moose::PetscSupport::petscSetDefaultPCSide	(	FEProblemBase &	problem,
		KSP	ksp
	)

Setup which side we want to apply preconditioner.

Definition at line 582 of file PetscSupport.C.

{
  for (const auto i : make_range(problem.numSolverSystems()))
  {
    SolverSystem & sys = problem.getSolverSystem(i);
 
    // PETSc 3.2.x+
    if (sys.getPCSide() != Moose::PCS_DEFAULT)
      LibmeshPetscCallA(problem.comm().get(), KSPSetPCSide(ksp, getPetscPCSide(sys.getPCSide())));
  }
}

Referenced by Moose::SlepcSupport::mooseSlepcEPSSNESKSPSetPCSide(), and petscSetKSPDefaults().

petscSetDefaults()

void Moose::PetscSupport::petscSetDefaults

(

FEProblemBase &

problem

)

Sets the default options for PETSc.

Definition at line 617 of file PetscSupport.C.

{
  // Apply matrix-type options once the per-system matrix prefixes are known. This is different
  // from vectors: libMesh/PETSc vector construction already sees a global '-vec_type' option,
  // but prefixed matrix options such as '-nl0_mat_type' cannot match anything until we set the
  // matrix prefix here. Without this, a matrix may be constructed with the default type and keep
  // that type for the rest of the solve, unless we not only set the options prefix but also apply
  // the options to the matrix in this function call.
  applyMatrixTypeOptions(problem);
 
  for (const auto nl_index : make_range(problem.numNonlinearSystems()))
  {
    NonlinearSystemBase & nl = problem.getNonlinearSystemBase(nl_index);
 
    // dig out PETSc solver
    auto * const petsc_solver = cast_ptr<PetscNonlinearSolver<Number> *>(nl.nonlinearSolver());
 
    // Ensure we properly prefix SNES which in turn prefixes its KSP
    const char * snes_prefix = nullptr;
    std::string snes_prefix_str;
    if (nl.system().prefix_with_name())
    {
      snes_prefix_str = nl.system().prefix();
      snes_prefix = snes_prefix_str.c_str();
    }
    SNES snes = petsc_solver->snes(snes_prefix);
    KSP ksp;
    LibmeshPetscCallA(nl.comm().get(), SNESGetKSP(snes, &ksp));
    LibmeshPetscCallA(nl.comm().get(), SNESSetMaxLinearSolveFailures(snes, 1000000));
    LibmeshPetscCallA(nl.comm().get(), SNESSetCheckJacobianDomainError(snes, PETSC_TRUE));
    LibmeshPetscCallA(
        nl.comm().get(),
        SNESSetConvergenceTest(snes, petscNonlinearConverged, &problem, LIBMESH_PETSC_NULLPTR));
 
    petscSetKSPDefaults(problem, ksp);
  }
 
  for (auto sys_index : make_range(problem.numLinearSystems()))
  {
    // dig out PETSc solver
    LinearSystem & lin_sys = problem.getLinearSystem(sys_index);
    auto & lm_lin_sys = lin_sys.linearImplicitSystem();
    auto * const petsc_solver =
        dynamic_cast<PetscLinearSolver<Number> *>(lm_lin_sys.get_linear_solver());
    // Ensure we properly prefix KSP
    if (lm_lin_sys.prefix_with_name())
      petsc_solver->init(lm_lin_sys.prefix().c_str());
    else
      petsc_solver->init();
    // The KSP call here would initialize without a prefix if we hadn't "manually" performed
    // initialization above
    KSP ksp = petsc_solver->ksp();
 
    if (problem.hasLinearConvergenceObjects())
      LibmeshPetscCallA(
          lin_sys.comm().get(),
          KSPSetConvergenceTest(ksp, petscLinearConverged, &problem, LIBMESH_PETSC_NULLPTR));
 
    // We dont set the KSP defaults here because they seem to clash with the linear solve parameters
    // set in FEProblemBase::solveLinearSystem
  }
}

Referenced by FEProblemBase::initPetscOutputAndSomeSolverSettings(), Moose::ScopedThrowOnError::ScopedThrowOnError(), and FEProblemBase::solveLinearSystem().

petscSetKSPDefaults()

void Moose::PetscSupport::petscSetKSPDefaults	(	FEProblemBase &	problem,
		KSP	ksp
	)

Set the default options for a KSP.

Definition at line 595 of file PetscSupport.C.

{
  auto & es = problem.es();
 
  PetscReal rtol = es.parameters.get<Real>("linear solver tolerance");
  PetscReal atol = es.parameters.get<Real>("linear solver absolute tolerance");
 
  // MOOSE defaults this to -1 for some dumb reason
  if (atol < 0)
    atol = 1e-50;
 
  PetscReal maxits = es.parameters.get<unsigned int>("linear solver maximum iterations");
 
  // 1e100 is because we don't use divtol currently
  LibmeshPetscCallA(problem.comm().get(), KSPSetTolerances(ksp, rtol, atol, 1e100, maxits));
 
  petscSetDefaultPCSide(problem, ksp);
 
  petscSetDefaultKSPNormType(problem, ksp);
}

Referenced by petscSetDefaults(), and setLinearSolverDefaults().

petscSetOptions() [1/2]

void Moose::PetscSupport::petscSetOptions	(	const PetscOptions &	po,
		const SolverParams &	solver_params,
		FEProblemBase *const	problem = nullptr
	)

A function for setting the PETSc options in PETSc from the options supplied to MOOSE.

This interface function should be used when setting options on a per-system basis

Definition at line 397 of file PetscSupport.C.

{
  PetscCallAbort(PETSC_COMM_WORLD, PetscOptionsClear(LIBMESH_PETSC_NULLPTR));
  setSolverOptions(solver_params, po.dont_add_these_options);
  petscSetOptionsHelper(po, problem);
}

Referenced by Moose::SlepcSupport::slepcSetOptions(), FEProblemBase::solve(), and FEProblemBase::solveLinearSystem().

petscSetOptions() [2/2]

void Moose::PetscSupport::petscSetOptions	(	const PetscOptions &	po,
		const std::vector< SolverParams > &	solver_params,
		FEProblemBase *	problem
	)

A function for setting the PETSc options in PETSc from the options supplied to MOOSE.

This interface function should be used for setting options all at once for all systems in a multi-system context. Note that PetscOptions is not a vector because the options database has prefixes for the different systems

Definition at line 407 of file PetscSupport.C.

{
  PetscCallAbort(PETSC_COMM_WORLD, PetscOptionsClear(LIBMESH_PETSC_NULLPTR));
  for (const auto & solver_params : solver_params_vec)
    setSolverOptions(solver_params, po.dont_add_these_options);
  petscSetOptionsHelper(po, problem);
}

petscSetOptionsHelper()

void Moose::PetscSupport::petscSetOptionsHelper	(	const PetscOptions &	po,
		FEProblemBase *const	problem
	)

Definition at line 377 of file PetscSupport.C.

{
  // Add any additional options specified in the input file
  for (const auto & flag : po.flags)
    // Need to use name method here to pass a str instead of an EnumItem because
    // we don't care if the id attributes match
    if (!po.dont_add_these_options.contains(flag.name()) ||
        po.user_set_options.contains(flag.name()))
      setSinglePetscOption(flag.rawName().c_str());
 
  // Add option pairs
  for (auto & option : po.pairs)
    if (!po.dont_add_these_options.contains(option.first) ||
        po.user_set_options.contains(option.first))
      setSinglePetscOption(option.first, option.second, problem);
 
  addPetscOptionsFromCommandline(problem);
}

Referenced by petscSetOptions(), and petscSetOptions().

petscSetupOutput()

PetscErrorCode Moose::PetscSupport::petscSetupOutput

(

CommandLine *

cmd_line

)

Definition at line 418 of file PetscSupport.C.

{
  PetscFunctionBegin;
  char code[10] = {45, 45, 109, 111, 111, 115, 101};
  const std::vector<std::string> argv = cmd_line->getArguments();
  for (const auto & arg : argv)
  {
    if (arg.compare(code) == 0)
    {
      Console::petscSetupOutput();
      break;
    }
  }
  PetscFunctionReturn(PETSC_SUCCESS);
}

Referenced by MooseApp::executeExecutioner().

processSingletonMooseWrappedOptions()

void Moose::PetscSupport::processSingletonMooseWrappedOptions	(	FEProblemBase &	fe_problem,
		const InputParameters &	params
	)

Process some MOOSE-wrapped PETSc options.

These options have no support for multi-system as indicated by the fact that this function takes no prefix nor solver system argument

Definition at line 681 of file PetscSupport.C.

{
  setSolveTypeFromParams(fe_problem, params);
  setLineSearchFromParams(fe_problem, params);
  setMFFDTypeFromParams(fe_problem, params);
}

Referenced by storePetscOptions().

registerPetscCitation()

void Moose::PetscSupport::registerPetscCitation

(

const std::string &

bibtex

)

Register a BibTeX entry with PETSc's citation list so that it is printed (alongside the run-specific citations from any PETSc solvers/preconditioners used) when the PETSc -citations option is enabled.

The list is printed at PetscFinalize.

Definition at line 1357 of file PetscSupport.C.

{
  // PETSc concatenates registered entries verbatim, so ensure a trailing newline to keep entries
  // separated. A null "set" flag registers unconditionally; callers deduplicate by citation key.
  const std::string entry = (!bibtex.empty() && bibtex.back() == '\n') ? bibtex : bibtex + "\n";
  LibmeshPetscCallA(PETSC_COMM_WORLD, PetscCitationsRegister(entry.c_str(), nullptr));
}

Referenced by MooseApp::requestCitations().

setConvergedReasonFlags()

void Moose::PetscSupport::setConvergedReasonFlags	(	FEProblemBase &	fe_problem,
		std::string	prefix
	)

Set flags that will instruct the user on the reason their simulation diverged from PETSc's perspective.

Parameters

fe_problem	The problem from which to retrieve the PETSc options
prefix	The prefix to add to the convergence flags. This should not contain a leading dash per PETSc prefix convention. Note that this function will immediately \emph add said dash at the start of prefix so that calls to PetscOptionsSetValue work. This is the reason we pass prefix by value

Definition at line 823 of file PetscSupport.C.

{
  prefix.insert(prefix.begin(), '-');
  checkPrefix(prefix);
  libmesh_ignore(fe_problem); // avoid unused warnings for old PETSc
 
#if !PETSC_VERSION_LESS_THAN(3, 14, 0)
  // the boolean in these pairs denote whether the user has specified any of the reason flags in the
  // input file
  std::array<std::string, 2> reason_flags = {{"snes_converged_reason", "ksp_converged_reason"}};
 
  auto & po = fe_problem.getPetscOptions();
 
  for (const auto & reason_flag : reason_flags)
  {
    const auto full_flag = prefix + reason_flag;
    if (!po.flags.isValueSet(full_flag) && !po.dont_add_these_options.contains(full_flag) &&
        (std::find_if(po.pairs.begin(),
                      po.pairs.end(),
                      [&full_flag](auto & pair)
                      { return pair.first == (full_flag); }) == po.pairs.end()))
      po.pairs.emplace_back(full_flag, "::failed");
  }
#endif
}

Referenced by FEProblemSolve::FEProblemSolve().

setLinearSolverDefaults()

template<typename T >

void Moose::PetscSupport::setLinearSolverDefaults	(	FEProblemBase &	problem,
		libMesh::LinearSolver< T > &	linear_solver
	)

Set the defaults for a libMesh LinearSolver.

Used in explicit solves

Definition at line 118 of file PetscSupport.h.

{
  petscSetKSPDefaults(problem,
                      libMesh::cast_ref<libMesh::PetscLinearSolver<T> &>(linear_solver).ksp());
}

Referenced by ExplicitTimeIntegrator::setupSolver().

setLineSearchFromParams()

void Moose::PetscSupport::setLineSearchFromParams	(	FEProblemBase &	fe_problem,
		const InputParameters &	params
	)

Sets the FE problem's line search from the input params.

Definition at line 734 of file PetscSupport.C.

{
  // Note: Options set in the Preconditioner block will override those set in the Executioner block
  if (params.isParamValid("line_search"))
  {
    const auto & line_search = params.get<MooseEnum>("line_search");
    for (const auto i : make_range(fe_problem.numNonlinearSystems()))
      if (fe_problem.solverParams(i)._line_search == Moose::LS_INVALID || line_search != "default")
      {
        Moose::LineSearchType enum_line_search =
            Moose::stringToEnum<Moose::LineSearchType>(line_search);
        fe_problem.solverParams(i)._line_search = enum_line_search;
        if (enum_line_search == LS_CONTACT || enum_line_search == LS_PROJECT)
        {
          NonlinearImplicitSystem * nl_system = dynamic_cast<NonlinearImplicitSystem *>(
              &fe_problem.getNonlinearSystemBase(i).system());
          if (!nl_system)
            mooseError("You've requested a line search but you must be solving an EigenProblem. "
                       "These two things are not consistent.");
          PetscNonlinearSolver<Real> * petsc_nonlinear_solver =
              dynamic_cast<PetscNonlinearSolver<Real> *>(nl_system->nonlinear_solver.get());
          if (!petsc_nonlinear_solver)
            mooseError("Currently the MOOSE line searches all use Petsc, so you "
                       "must use Petsc as your non-linear solver.");
          petsc_nonlinear_solver->linesearch_object =
              std::make_unique<ComputeLineSearchObjectWrapper>(fe_problem);
        }
      }
  }
}

Referenced by processSingletonMooseWrappedOptions().

setMFFDTypeFromParams()

void Moose::PetscSupport::setMFFDTypeFromParams	(	FEProblemBase &	fe_problem,
		const InputParameters &	params
	)

Sets the FE problem's matrix-free finite difference type from the input params.

Definition at line 766 of file PetscSupport.C.

{
  if (params.isParamValid("mffd_type"))
  {
    const auto & mffd_type = params.get<MooseEnum>("mffd_type");
    for (const auto i : make_range(fe_problem.numNonlinearSystems()))
      fe_problem.solverParams(i)._mffd_type = Moose::stringToEnum<Moose::MffdType>(mffd_type);
  }
}

Referenced by processSingletonMooseWrappedOptions().

setSinglePetscOption()

void Moose::PetscSupport::setSinglePetscOption	(	const std::string &	name,
		const std::string &	value = "",
		FEProblemBase *const	problem = nullptr
	)

A wrapper function for dealing with different versions of PetscOptionsSetValue.

This is not generally called from MOOSE code, it is instead intended to be called by stuff in MOOSE::PetscSupport.

Definition at line 1158 of file PetscSupport.C.

{
  static const TIMPI::Communicator comm_world(PETSC_COMM_WORLD);
  const TIMPI::Communicator & comm = problem ? problem->comm() : comm_world;
  LibmeshPetscCallA(comm.get(),
                    PetscOptionsSetValue(LIBMESH_PETSC_NULLPTR,
                                         name.c_str(),
                                         value == "" ? LIBMESH_PETSC_NULLPTR : value.c_str()));
  // Create a single option data base so that we can use PETSC's internal option checking which
  // is case insensitive. This is better than re-implementing case-insensitive checks here in this
  // TU
  ::PetscOptions single_option;
  LibmeshPetscCallA(comm.get(), PetscOptionsCreate(&single_option));
  LibmeshPetscCallA(comm.get(),
                    PetscOptionsSetValue(single_option,
                                         name.c_str(),
                                         value == "" ? LIBMESH_PETSC_NULLPTR : value.c_str()));
  auto check_problem = [problem, &name]()
  {
    if (!problem)
      mooseError(
          "Setting the option '",
          name,
          "' requires passing a 'problem' parameter. Contact a developer of your application "
          "to have them update their code. If in doubt, reach out to the MOOSE team on Github "
          "discussions");
  };
 
  // Select vector type from user-passed PETSc options
  if (petscOptionsHasName(single_option, "-vec_type"))
  {
    check_problem();
    applyVectorTypeOptions(*problem);
  }
  // First do a cheap suffix check so unrelated PETSc options do not pay for looping over every
  // solver system. Once we know the name looks like a matrix-type option, rely on PETSc's
  // option lookup for the actual case-insensitive and prefix-aware matching.
  else if (problem && mightBeMatTypeOption(name))
  {
    errorOnUnprefixedMatTypeOption(single_option, *problem);
 
    for (const auto i : index_range(problem->_solver_systems))
    {
      const auto & solver_sys_name = problem->_solver_sys_names[i];
      if (!petscOptionsHasName(single_option, "-mat_type", solver_sys_name + "_"))
        continue;
 
      if (problem->solverParams(i)._type == Moose::ST_JFNK)
        mooseError("Setting option '", name, "' is incompatible with a JFNK 'solve_type'");
 
      applyMatrixTypeOptions(*problem, i);
      break;
    }
  }
 
  LibmeshPetscCallA(comm.get(), PetscOptionsDestroy(&single_option));
}

Referenced by Moose::SlepcSupport::clearFreeNonlinearPowerIterations(), MFEMPetscNonlinearSolver::ConstructSolver(), FEProblemBase::FEProblemBase(), petscSetOptionsHelper(), CommandLine::printUsage(), MooseApp::requestCitations(), Moose::SlepcSupport::setEigenSolverOptions(), Moose::SlepcSupport::setFreeNonlinearPowerIterations(), Moose::SlepcSupport::setNewtonPetscOptions(), Moose::SlepcSupport::setNonlinearPowerOptions(), and setSinglePetscOptionIfAppropriate().

setSinglePetscOptionIfAppropriate()

void Moose::PetscSupport::setSinglePetscOptionIfAppropriate	(	const MultiMooseEnum &	dont_add_these_options,
		const std::string &	name,
		const std::string &	value = "",
		FEProblemBase *const	problem = nullptr
	)

Same as setSinglePetscOption, but does not set the option if it doesn't make sense for the current simulation type, e.g.

if name is contained within dont_add_these_options

Definition at line 1219 of file PetscSupport.C.

{
  if (!dont_add_these_options.contains(name))
    setSinglePetscOption(name, value, problem);
}

Referenced by Moose::SlepcSupport::setEigenProblemOptions(), Moose::SlepcSupport::setSlepcEigenSolverTolerances(), setSolverOptions(), Moose::SlepcSupport::setWhichEigenPairsOptions(), and Moose::SlepcSupport::slepcSetOptions().

setSolverOptions()

void Moose::PetscSupport::setSolverOptions	(	const SolverParams &	solver_params,
		const MultiMooseEnum &	dont_add_these_options
	)

Definition at line 282 of file PetscSupport.C.

{
  const auto prefix_with_dash = '-' + solver_params._prefix;
  // set PETSc options implied by a solve type
  switch (solver_params._type)
  {
    case Moose::ST_PJFNK:
      setSinglePetscOptionIfAppropriate(dont_add_these_options,
                                        prefix_with_dash + "snes_mf_operator");
      setSinglePetscOptionIfAppropriate(dont_add_these_options,
                                        prefix_with_dash + "mat_mffd_type",
                                        stringify(solver_params._mffd_type));
      break;
 
    case Moose::ST_JFNK:
      setSinglePetscOptionIfAppropriate(dont_add_these_options, prefix_with_dash + "snes_mf");
      setSinglePetscOptionIfAppropriate(dont_add_these_options,
                                        prefix_with_dash + "mat_mffd_type",
                                        stringify(solver_params._mffd_type));
      break;
 
    case Moose::ST_NEWTON:
      break;
 
    case Moose::ST_FD:
      setSinglePetscOptionIfAppropriate(dont_add_these_options, prefix_with_dash + "snes_fd");
      break;
 
    case Moose::ST_LINEAR:
      setSinglePetscOptionIfAppropriate(
          dont_add_these_options, prefix_with_dash + "snes_type", "ksponly");
      setSinglePetscOptionIfAppropriate(dont_add_these_options,
                                        prefix_with_dash + "snes_monitor_cancel");
      break;
  }
 
  Moose::LineSearchType ls_type = solver_params._line_search;
  if (ls_type == Moose::LS_NONE)
    ls_type = Moose::LS_BASIC;
 
  if (ls_type != Moose::LS_DEFAULT && ls_type != Moose::LS_CONTACT && ls_type != Moose::LS_PROJECT)
    setSinglePetscOptionIfAppropriate(
        dont_add_these_options, prefix_with_dash + "snes_linesearch_type", stringify(ls_type));
}

Referenced by petscSetOptions(), and petscSetOptions().

setSolveTypeFromParams()

void Moose::PetscSupport::setSolveTypeFromParams	(	FEProblemBase &	fe_problem,
		const InputParameters &	params
	)

Sets the FE problem's solve type from the input params.

Definition at line 721 of file PetscSupport.C.

{
  // Note: Options set in the Preconditioner block will override those set in the Executioner block
  if (params.isParamValid("solve_type") && !params.isParamValid("_use_eigen_value"))
  {
    // Extract the solve type
    const std::string & solve_type = params.get<MooseEnum>("solve_type");
    for (const auto i : make_range(fe_problem.numNonlinearSystems()))
      fe_problem.solverParams(i)._type = Moose::stringToEnum<Moose::SolveType>(solve_type);
  }
}

Referenced by MoosePreconditioner::MoosePreconditioner(), and processSingletonMooseWrappedOptions().

storePetscOptions()

void Moose::PetscSupport::storePetscOptions	(	FEProblemBase &	fe_problem,
		const std::string &	prefix,
		const ParallelParamObject &	param_object
	)

Stores the PETSc options supplied from the parameter object on the problem.

Parameters

fe_problem	The problem on which we will store the parameters
prefix	A prefix to apply to all the parameter object's PETSc options. This should either be a single character '-' or a string like "-foo_" where the trailing '_' is required
param_object	The parameter object potentially holding PETSc options String prefixes may be used to select the system the parameters is applied to

Definition at line 696 of file PetscSupport.C.

{
  const auto & params = param_object.parameters();
  processSingletonMooseWrappedOptions(fe_problem, params);
 
  // The parameters contained in the Action
  const auto & petsc_options = params.get<MultiMooseEnum>("petsc_options");
  const auto & petsc_pair_options =
      params.get<MooseEnumItem, std::string>("petsc_options_iname", "petsc_options_value");
 
  // A reference to the PetscOptions object that contains the settings that will be used in the
  // solve
  auto & po = fe_problem.getPetscOptions();
 
  // First process the single petsc options/flags
  addPetscFlagsToPetscOptions(petsc_options, prefix, param_object, po);
 
  // Then process the option-value pairs
  addPetscPairsToPetscOptions(
      petsc_pair_options, fe_problem.mesh().dimension(), prefix, param_object, po);
}

Referenced by FEProblemSolve::FEProblemSolve(), MoosePreconditioner::initialSetup(), MooseStaticCondensationPreconditioner::initialSetup(), and Split::setup().

storePetscOptionsFromParams()

void Moose::PetscSupport::storePetscOptionsFromParams	(	FEProblemBase &	fe_problem,
		const InputParameters &	params
	)

Stores the Petsc flags and pair options fron the input params in the given PetscOptions object.

stringify() [1/2]

std::string Moose::PetscSupport::stringify

(

const LineSearchType &

t

)

Definition at line 238 of file PetscSupport.C.

{
  switch (t)
  {
    case LS_BASIC:
      return "basic";
    case LS_DEFAULT:
      return "default";
    case LS_NONE:
      return "none";
    case LS_SHELL:
      return "shell";
    case LS_L2:
      return "l2";
    case LS_BT:
      return "bt";
    case LS_CP:
      return "cp";
    case LS_CONTACT:
      return "contact";
    case LS_PROJECT:
      return "project";
    case LS_INVALID:
      mooseError("Invalid LineSearchType");
  }
  return "";
}

Referenced by setSolverOptions().

stringify() [2/2]

std::string Moose::PetscSupport::stringify

(

const MffdType &

t

)

Definition at line 267 of file PetscSupport.C.

{
  switch (t)
  {
    case MFFD_WP:
      return "wp";
    case MFFD_DS:
      return "ds";
    case MFFD_INVALID:
      mooseError("Invalid MffdType");
  }
  return "";
}