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

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 addPetscOptionsFromCommandline();

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

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