Detailed Description

A class of linear solver based on PETSc routines.

All command-line options that are not recognized by OGS are passed on to PETSc, i.e., they potentially affect the linear solver. The linear solver options in the project file take precedence over the command-line options, because the former are processed at a later stage.

Definition at line 38 of file PETScLinearSolver.h.

#include <PETScLinearSolver.h>

Public Member Functions
	PETScLinearSolver (const std::string prefix, BaseLib::ConfigTree const *const option)

	~PETScLinearSolver ()

bool	solve (PETScMatrix &A, PETScVector &b, PETScVector &x)

PetscInt	getNumberOfIterations () const
	Get number of iterations. More...

double	getElapsedTime () const
	Get elapsed wall clock time. More...

Private Attributes
KSP	solver_
	Solver type. More...

PC	pc_
	Preconditioner type. More...

double	elapsed_ctime_ = 0.0
	Clock time. More...

Constructor & Destructor Documentation

◆ PETScLinearSolver()

MathLib::PETScLinearSolver::PETScLinearSolver	(	const std::string	prefix,
		BaseLib::ConfigTree const *const	option
	)

Constructor

Parameters

prefix	Name used to distinguish the options in the command line for this solver. It can be the name of the PDE that owns an instance of this class.
option	Petsc options, which will be inserted into the global petsc options database.

Input File Parameter:: prj__linear_solvers__linear_solver__petsc

Input File Parameter:: prj__linear_solvers__linear_solver__petsc__parameters

Input File Parameter:: prj__linear_solvers__linear_solver__petsc__prefix

Definition at line 24 of file PETScLinearSolver.cpp.

 {
     // Insert options into petsc database. Default options are given in the
     // string below.
     std::string petsc_options =
         "-ksp_type cg -pc_type bjacobi -ksp_rtol 1e-16 -ksp_max_it 10000";
  
     std::string prefix;
  
     if (option)
     {
         ignoreOtherLinearSolvers(*option, "petsc");
  
         if (auto const subtree = option->getConfigSubtreeOptional("petsc"))
         {
             if (auto const parameters =
                 subtree->getConfigParameterOptional<std::string>("parameters"))
             {
                 petsc_options = *parameters;
             }
  
             if (auto const pre =
                 subtree->getConfigParameterOptional<std::string>("prefix"))
             {
                 if (!pre->empty())
                     prefix = *pre + "_";
             }
         }
     }
 #if PETSC_VERSION_LT(3, 7, 0)
     PetscOptionsInsertString(petsc_options.c_str());
 #else
     PetscOptionsInsertString(nullptr, petsc_options.c_str());
 #endif
  
     KSPCreate(PETSC_COMM_WORLD, &solver_);
  
     KSPGetPC(solver_, &pc_);
  
     if (!prefix.empty())
     {
         KSPSetOptionsPrefix(solver_, prefix.c_str());
     }
  
     KSPSetInitialGuessNonzero(solver_, PETSC_TRUE);
     KSPSetFromOptions(solver_);  // set run-time options
 }

References BaseLib::ConfigTree::getConfigSubtreeOptional(), MathLib::ignoreOtherLinearSolvers(), pc_, and solver_.

◆ ~PETScLinearSolver()

MathLib::PETScLinearSolver::~PETScLinearSolver ( )

inline

Definition at line 52 of file PETScLinearSolver.h.

52 { KSPDestroy(&solver_); }

References solver_.

Member Function Documentation

◆ getElapsedTime()

double MathLib::PETScLinearSolver::getElapsedTime ( ) const

inline

Get elapsed wall clock time.

Definition at line 65 of file PETScLinearSolver.h.

65 { return elapsed_ctime_; }

MathLib::PETScLinearSolver::elapsed_ctime_

double elapsed_ctime_

Clock time.

Definition: PETScLinearSolver.h:71

References elapsed_ctime_.

◆ getNumberOfIterations()

PetscInt MathLib::PETScLinearSolver::getNumberOfIterations ( ) const

inline

Get number of iterations.

Definition at line 57 of file PETScLinearSolver.h.

     {
         PetscInt its = 0;
         KSPGetIterationNumber(solver_, &its);
         return its;
     }

References solver_.

◆ solve()

bool MathLib::PETScLinearSolver::solve	(	PETScMatrix &	A,
		PETScVector &	b,
		PETScVector &	x
	)

Definition at line 76 of file PETScLinearSolver.cpp.

 {
     BaseLib::RunTime wtimer;
     wtimer.start();
  
 // define TEST_MEM_PETSC
 #ifdef TEST_MEM_PETSC
     PetscLogDouble mem1, mem2;
     PetscMemoryGetCurrentUsage(&mem1);
 #endif
  
     KSPSetOperators(solver_, A.getRawMatrix(), A.getRawMatrix());
  
     KSPSolve(solver_, b.getRawVector(), x.getRawVector());
  
     KSPConvergedReason reason;
     KSPGetConvergedReason(solver_, &reason);
  
     bool converged = true;
     if (reason > 0)
     {
         const char* ksp_type;
         const char* pc_type;
         KSPGetType(solver_, &ksp_type);
         PCGetType(pc_, &pc_type);
  
         PetscPrintf(PETSC_COMM_WORLD,
                     "\n================================================");
         PetscPrintf(PETSC_COMM_WORLD,
                     "\nLinear solver %s with %s preconditioner", ksp_type,
                     pc_type);
  
         PetscInt its;
         KSPGetIterationNumber(solver_, &its);
         PetscPrintf(PETSC_COMM_WORLD, "\nconverged in %d iterations", its);
         switch (reason)
         {
             case KSP_CONVERGED_RTOL:
                 PetscPrintf(PETSC_COMM_WORLD,
                             " (relative convergence criterion fulfilled).");
                 break;
             case KSP_CONVERGED_ATOL:
                 PetscPrintf(PETSC_COMM_WORLD,
                             " (absolute convergence criterion fulfilled).");
                 break;
             default:
                 PetscPrintf(PETSC_COMM_WORLD, ".");
         }
  
         PetscPrintf(PETSC_COMM_WORLD,
                     "\n================================================\n");
     }
     else if (reason == KSP_DIVERGED_ITS)
     {
         const char* ksp_type;
         const char* pc_type;
         KSPGetType(solver_, &ksp_type);
         PCGetType(pc_, &pc_type);
         PetscPrintf(PETSC_COMM_WORLD,
                     "\nLinear solver %s with %s preconditioner", ksp_type,
                     pc_type);
         PetscPrintf(PETSC_COMM_WORLD,
                     "\nWarning: maximum number of iterations reached.\n");
     }
     else
     {
         converged = false;
         if (reason == KSP_DIVERGED_INDEFINITE_PC)
         {
             PetscPrintf(PETSC_COMM_WORLD,
                         "\nDivergence because of indefinite preconditioner,");
             PetscPrintf(PETSC_COMM_WORLD,
                         "\nTry to run again with "
                         "-pc_factor_shift_positive_definite option.\n");
         }
         else if (reason == KSP_DIVERGED_BREAKDOWN_BICG)
         {
             PetscPrintf(PETSC_COMM_WORLD,
                         "\nKSPBICG method was detected so the method could not "
                         "continue to enlarge the Krylov space.");
             PetscPrintf(PETSC_COMM_WORLD,
                         "\nTry to run again with another solver.\n");
         }
         else if (reason == KSP_DIVERGED_NONSYMMETRIC)
         {
             PetscPrintf(PETSC_COMM_WORLD,
                         "\nMatrix or preconditioner is unsymmetric but KSP "
                         "requires symmetric.\n");
         }
         else
         {
             PetscPrintf(PETSC_COMM_WORLD,
                         "\nDivergence detected, use command option "
                         "-ksp_monitor or -log_summary to check the details.\n");
         }
     }
  
 #ifdef TEST_MEM_PETSC
     PetscMemoryGetCurrentUsage(&mem2);
     PetscPrintf(
         PETSC_COMM_WORLD,
         "###Memory usage by solver. Before: %f After: %f Increase: %d\n", mem1,
         mem2, (int)(mem2 - mem1));
 #endif
  
     elapsed_ctime_ += wtimer.elapsed();
  
     return converged;
 }

References BaseLib::RunTime::elapsed(), elapsed_ctime_, MathLib::PETScMatrix::getRawMatrix(), MathLib::PETScVector::getRawVector(), pc_, solver_, and BaseLib::RunTime::start().

Member Data Documentation

◆ elapsed_ctime_

double MathLib::PETScLinearSolver::elapsed_ctime_ = 0.0

private

Clock time.

Definition at line 71 of file PETScLinearSolver.h.

Referenced by getElapsedTime(), and solve().

◆ pc_

PC MathLib::PETScLinearSolver::pc_

private

Preconditioner type.

Definition at line 69 of file PETScLinearSolver.h.

Referenced by PETScLinearSolver(), and solve().

◆ solver_

KSP MathLib::PETScLinearSolver::solver_

private

Solver type.

Definition at line 68 of file PETScLinearSolver.h.

Referenced by PETScLinearSolver(), ~PETScLinearSolver(), getNumberOfIterations(), and solve().

The documentation for this class was generated from the following files:

MathLib/LinAlg/PETSc/PETScLinearSolver.h
MathLib/LinAlg/PETSc/PETScLinearSolver.cpp

Detailed Description

Public Member Functions

Private Attributes

Constructor & Destructor Documentation

◆ PETScLinearSolver()

◆ ~PETScLinearSolver()

Member Function Documentation

◆ getElapsedTime()

◆ getNumberOfIterations()

◆ solve()

Member Data Documentation

◆ elapsed_ctime_

◆ pc_

◆ solver_