PetscSupport.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "libmesh/libmesh.h"
 
// MOOSE includes
#include "SolverParams.h"
#include "MultiMooseEnum.h"
 
#include "libmesh/petsc_macro.h"
#include "libmesh/linear_solver.h"
#include "libmesh/petsc_linear_solver.h"
 
#include <petscksp.h>
 
// Forward declarations
class FEProblemBase;
class NonlinearSystemBase;
class CommandLine;
class InputParameters;
class ParallelParamObject;
 
namespace libMesh
{
class DofMapBase;
}
 
namespace Moose
{
namespace PetscSupport
{
 
class PetscOptions
{
public:
  PetscOptions()
    : flags("", "", true), dont_add_these_options("", "", true), user_set_options("", "", true)
  {
  }
 
  std::vector<std::pair<std::string, std::string>> pairs;
 
  MultiMooseEnum flags;
 
  MultiMooseEnum dont_add_these_options;
 
  MultiMooseEnum user_set_options;
 
  std::string pc_description;
};
 
class PetscOptionsScope
{
public:
  explicit PetscOptionsScope(FEProblemBase & problem);
  ~PetscOptionsScope();
 
  PetscOptionsScope(const PetscOptionsScope &) = delete;
  PetscOptionsScope & operator=(const PetscOptionsScope &) = delete;
 
private:
  FEProblemBase & _problem;
 
  bool _pushed;
};
 
void petscSetOptions(const PetscOptions & po,
                     const SolverParams & solver_params,
                     FEProblemBase * const problem = nullptr);
 
void petscSetOptions(const PetscOptions & po,
                     const std::vector<SolverParams> & solver_params,
                     FEProblemBase * problem);
 
void petscSetKSPDefaults(FEProblemBase & problem, KSP ksp);
 
template <typename T>
void
setLinearSolverDefaults(FEProblemBase & problem, libMesh::LinearSolver<T> & linear_solver)
{
  petscSetKSPDefaults(problem,
                      libMesh::cast_ref<libMesh::PetscLinearSolver<T> &>(linear_solver).ksp());
}
 
void petscSetDefaults(FEProblemBase & problem);
 
PetscErrorCode petscSetupOutput(CommandLine * cmd_line);
 
void outputNorm(libMesh::Real old_norm, libMesh::Real norm, bool use_color = false);
 
PetscErrorCode petscLinearMonitor(KSP /*ksp*/, PetscInt its, PetscReal rnorm, void * void_ptr);
 
void processSingletonMooseWrappedOptions(FEProblemBase & fe_problem,
                                         const InputParameters & params);
 
void storePetscOptions(FEProblemBase & fe_problem,
                       const std::string & prefix,
                       const ParallelParamObject & param_object);
 
void setConvergedReasonFlags(FEProblemBase & fe_problem, std::string prefix);
 
void setSolveTypeFromParams(FEProblemBase & fe_problem, const InputParameters & params);
 
void setLineSearchFromParams(FEProblemBase & fe_problem, const InputParameters & params);
 
void setMFFDTypeFromParams(FEProblemBase & fe_problem, const InputParameters & params);
 
void storePetscOptionsFromParams(FEProblemBase & fe_problem, const InputParameters & params);
 
void addPetscFlagsToPetscOptions(const MultiMooseEnum & petsc_flags,
                                 std::string prefix,
                                 const ParallelParamObject & param_object,
                                 PetscOptions & petsc_options);
 
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);
 
std::set<std::string> getPetscValidLineSearches();
 
InputParameters getPetscValidParams();
 
MultiMooseEnum getCommonPetscFlags();
 
MultiMooseEnum getCommonSNESFlags();
 
MultiMooseEnum getCommonKSPFlags();
 
MultiMooseEnum getCommonPetscKeys();
 
MultiMooseEnum getCommonSNESKeys();
 
MultiMooseEnum getCommonKSPKeys();
 
bool isSNESVI(FEProblemBase & fe_problem);
 
void setSinglePetscOption(const std::string & name,
                          const std::string & value = "",
                          FEProblemBase * const problem = nullptr);
 
void setSinglePetscOptionIfAppropriate(const MultiMooseEnum & dont_add_these_options,
                                       const std::string & name,
                                       const std::string & value = "",
                                       FEProblemBase * const problem = nullptr);
 
void registerPetscCitation(const std::string & bibtex);
 
void addPetscOptionsFromCommandline(FEProblemBase * const problem = nullptr);
 
void petscSetDefaultPCSide(FEProblemBase & problem, KSP ksp);
 
void petscSetDefaultKSPNormType(FEProblemBase & problem, KSP ksp);
 
void colorAdjacencyMatrix(PetscScalar * adjacency_matrix,
                          unsigned int size,
                          unsigned int colors,
                          std::vector<unsigned int> & vertex_colors,
                          const char * coloring_algorithm);
 
void dontAddPetscFlag(const std::string & flag, PetscOptions & petsc_options);
 
void dontAddNonlinearConvergedReason(FEProblemBase & fe_problem);
 
void dontAddLinearConvergedReason(FEProblemBase & fe_problem);
 
void dontAddCommonKSPOptions(FEProblemBase & fe_problem);
 
void dontAddCommonSNESOptions(FEProblemBase & fe_problem);
 
void dontAddCommonSNESOptions(FEProblemBase & fe_problem, const std::string & prefix);
 
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);
 
#define SNESGETLINESEARCH SNESGetLineSearch
}
}