Moose::PetscSupport Namespace Reference

Classes
class	PetscOptions
	A struct for storing the various types of petsc options and values. 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. More...
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. More...
void	petscSetKSPDefaults (FEProblemBase &problem, KSP ksp)
	Set the default options for a KSP. More...
template<typename T >
void	setLinearSolverDefaults (FEProblemBase &problem, libMesh::LinearSolver< T > &linear_solver)
	Set the defaults for a libMesh LinearSolver. More...
void	petscSetDefaults (FEProblemBase &problem)
	Sets the default options for PETSc. More...
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. More...
PetscErrorCode	petscLinearMonitor (KSP, PetscInt its, PetscReal rnorm, void *void_ptr)
	Helper function for displaying the linear residual during PETSC solve. More...
void	processSingletonMooseWrappedOptions (FEProblemBase &fe_problem, const InputParameters &params)
	Process some MOOSE-wrapped PETSc options. More...
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. More...
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. More...
void	setSolveTypeFromParams (FEProblemBase &fe_problem, const InputParameters &params)
	Sets the FE problem's solve type from the input params. More...
void	setLineSearchFromParams (FEProblemBase &fe_problem, const InputParameters &params)
	Sets the FE problem's line search from the input params. More...
void	setMFFDTypeFromParams (FEProblemBase &fe_problem, const InputParameters &params)
	Sets the FE problem's matrix-free finite difference type from the input params. More...
void	storePetscOptionsFromParams (FEProblemBase &fe_problem, const InputParameters &params)
	Stores the Petsc flags and pair options fron the input params in the given PetscOptions object. More...
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. More...
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. More...
std::set< std::string >	getPetscValidLineSearches ()
	Returns the valid petsc line search options as a set of strings. More...
InputParameters	getPetscValidParams ()
	Returns the PETSc options that are common between Executioners and Preconditioners. More...
MultiMooseEnum	getCommonPetscFlags ()
	A helper function to produce a MultiMooseEnum with commonly used PETSc single options (flags) More...
MultiMooseEnum	getCommonSNESFlags ()
	A helper function to produce a MultiMooseEnum with commonly used PETSc snes single options (flags) More...
MultiMooseEnum	getCommonKSPFlags ()
	A helper function to produce a MultiMooseEnum with commonly used PETSc ksp single options (flags) More...
MultiMooseEnum	getCommonPetscKeys ()
	A helper function to produce a MultiMooseEnum with commonly used PETSc iname options (keys in key-value pairs) More...
MultiMooseEnum	getCommonSNESKeys ()
	A helper function to produce a MultiMooseEnum with commonly used PETSc snes option names (keys) More...
MultiMooseEnum	getCommonKSPKeys ()
	A helper function to produce a MultiMooseEnum with commonly used PETSc ksp option names (keys) More...
bool	isSNESVI (FEProblemBase &fe_problem)
	check if SNES type is variational inequalities (VI) solver More...
void	setSinglePetscOption (const std::string &name, const std::string &value="", FEProblemBase *const problem=nullptr)
	A wrapper function for dealing with different versions of PetscOptionsSetValue. More...
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. More...
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. More...
void	addPetscOptionsFromCommandline (FEProblemBase *const problem=nullptr)
	Insert command-line PETSc options into the active PETSc options database. More...
void	petscSetDefaultPCSide (FEProblemBase &problem, KSP ksp)
	Setup which side we want to apply preconditioner. More...
void	petscSetDefaultKSPNormType (FEProblemBase &problem, KSP ksp)
	Set norm type. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
void	dontAddCommonSNESOptions (FEProblemBase &fe_problem, const std::string &prefix)
	Prefixed variant: suppress common SNES options for the system identified by prefix (e.g. More...
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. More...
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 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 767 of file PetscSupport.C.

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

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

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 309 of file PetscSupport.C.

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

{
  // 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));
}

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 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 831 of file PetscSupport.C.

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

{
  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;
}

checkUserProvidedPetscOption()

template<typename T >

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

Definition at line 759 of file PetscSupport.C.

Referenced by addPetscFlagsToPetscOptions(), and addPetscPairsToPetscOptions().

{
  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 '-'");
}

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 1210 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 1320 of file PetscSupport.C.

Referenced by MatrixSymmetryCheck::execute().

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

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 1294 of file PetscSupport.C.

Referenced by ExplicitTimeIntegrator::ExplicitTimeIntegrator().

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

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 1304 of file PetscSupport.C.

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

{
  dontAddCommonSNESOptions(fe_problem, "");
}

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 1310 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 1288 of file PetscSupport.C.

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

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

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 1282 of file PetscSupport.C.

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

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

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 1275 of file PetscSupport.C.

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

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

getCommonKSPFlags()

MultiMooseEnum Moose::PetscSupport::getCommonKSPFlags

(

)

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

Definition at line 1066 of file PetscSupport.C.

Referenced by dontAddCommonKSPOptions(), and getCommonPetscFlags().

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

getCommonKSPKeys()

MultiMooseEnum Moose::PetscSupport::getCommonKSPKeys

(

)

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

Definition at line 1091 of file PetscSupport.C.

Referenced by dontAddCommonKSPOptions(), and getCommonPetscKeys().

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

getCommonPetscFlags()

MultiMooseEnum Moose::PetscSupport::getCommonPetscFlags

(

)

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

Definition at line 1073 of file PetscSupport.C.

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

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

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 1099 of file PetscSupport.C.

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

{
  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;
}

getCommonSNESFlags()

MultiMooseEnum Moose::PetscSupport::getCommonSNESFlags

(

)

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

Definition at line 1055 of file PetscSupport.C.

Referenced by dontAddCommonSNESOptions(), and getCommonPetscFlags().

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

getCommonSNESKeys()

MultiMooseEnum Moose::PetscSupport::getCommonSNESKeys

(

)

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

Definition at line 1082 of file PetscSupport.C.

Referenced by dontAddCommonSNESOptions(), and getCommonPetscKeys().

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

getPetscKSPNormType()

KSPNormType Moose::PetscSupport::getPetscKSPNormType

(

Moose::MooseKSPNormType

kspnorm

)

Definition at line 531 of file PetscSupport.C.

Referenced by petscSetDefaultKSPNormType().

{
  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;
  }
}

getPetscPCSide()

PCSide Moose::PetscSupport::getPetscPCSide

(

Moose::PCSideType

pcs

)

Definition at line 514 of file PetscSupport.C.

Referenced by petscSetDefaultPCSide().

{
  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;
  }
}

getPetscValidLineSearches()

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

(

)

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

Definition at line 1014 of file PetscSupport.C.

Referenced by FEProblemSolve::validParams().

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

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 1020 of file PetscSupport.C.

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

{
  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;
}

isSNESVI()

bool Moose::PetscSupport::isSNESVI

(

FEProblemBase &

fe_problem

)

check if SNES type is variational inequalities (VI) solver

Definition at line 1115 of file PetscSupport.C.

Referenced by BoundsBase::initialSetup().

{
  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;
}

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 464 of file PetscSupport.C.

Referenced by petscSetDefaults().

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

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 416 of file PetscSupport.C.

Referenced by petscSetDefaults().

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

petscSetDefaultKSPNormType()

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

Set norm type.

Definition at line 552 of file PetscSupport.C.

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

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

petscSetDefaultPCSide()

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

Setup which side we want to apply preconditioner.

Definition at line 563 of file PetscSupport.C.

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

{
  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())));
  }
}

petscSetDefaults()

void Moose::PetscSupport::petscSetDefaults

(

FEProblemBase &

problem

)

Sets the default options for PETSc.

Definition at line 598 of file PetscSupport.C.

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

{
  // 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
  }
}

petscSetKSPDefaults()

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

Set the default options for a KSP.

Definition at line 576 of file PetscSupport.C.

Referenced by petscSetDefaults(), and setLinearSolverDefaults().

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

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 378 of file PetscSupport.C.

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

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

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 388 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 358 of file PetscSupport.C.

Referenced by petscSetOptions().

{
  // 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);
}

petscSetupOutput()

PetscErrorCode Moose::PetscSupport::petscSetupOutput

(

CommandLine *

cmd_line

)

Definition at line 399 of file PetscSupport.C.

Referenced by MooseApp::executeExecutioner().

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

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 662 of file PetscSupport.C.

Referenced by storePetscOptions().

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

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 1338 of file PetscSupport.C.

Referenced by MooseApp::requestCitations().

{
  // 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));
}

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 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 804 of file PetscSupport.C.

Referenced by FEProblemSolve::FEProblemSolve().

{
  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
}

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 98 of file PetscSupport.h.

Referenced by ExplicitTimeIntegrator::setupSolver().

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

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 715 of file PetscSupport.C.

Referenced by processSingletonMooseWrappedOptions().

{
  // 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);
        }
      }
  }
}

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 747 of file PetscSupport.C.

Referenced by processSingletonMooseWrappedOptions().

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

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 1139 of file PetscSupport.C.

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

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

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 1200 of file PetscSupport.C.

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

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

setSolverOptions()

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

Definition at line 263 of file PetscSupport.C.

Referenced by petscSetOptions().

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

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 702 of file PetscSupport.C.

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

{
  // 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);
  }
}

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 677 of file PetscSupport.C.

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

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

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 219 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 "";
}

stringify() [2/2]

std::string Moose::PetscSupport::stringify

(

const MffdType &

t

)

Definition at line 248 of file PetscSupport.C.

Referenced by setSolverOptions().

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