HypreSolver_test.cc File Reference

#include "generic.h"
#include "poisson.h"
#include "meshes/rectangular_quadmesh.h"

Classes
class	PoissonProblem< ELEMENT >
	Micky mouse Poisson problem. More...

Namespaces
	TanhSolnForPoisson
	Namespace for exact solution for Poisson equation with "sharp step".

Functions
void	TanhSolnForPoisson::get_exact_u (const Vector< double > &x, Vector< double > &u)
	Exact solution as a Vector. More...
void	TanhSolnForPoisson::source_function (const Vector< double > &x, double &source)
	Source function required to make the solution above an exact solution. More...
int	main (int argc, char **argv)
	Driver code for 2D Poisson problem. More...

Variables
double	TanhSolnForPoisson::TanPhi =0.0
	Parameter for angle Phi of "step". More...

Function Documentation

main()

int main	(	int argc	,
		char **	argv
	)

Driver code for 2D Poisson problem.

{
 // Set the orientation of the "step" to 45 degrees
 TanhSolnForPoisson::TanPhi=1.0;
 
 // Initial value for the steepness of the "step"
 TanhSolnForPoisson::Alpha=1.0;
 
 // Create the problem with 2D nine-node elements from the
 // QPoissonElement family. Pass pointer to source function.
 PoissonProblem<RefineableQPoissonElement<2,2> >
  problem(&TanhSolnForPoisson::source_function);
    
 DocInfo doc_info;
 doc_info.set_directory("RESLT");
 
 // File to report the number of Newton iterations
 ofstream conv_file;
 char filename[100];
 sprintf(filename,"%s/conv.dat",doc_info.directory().c_str());
 conv_file.open(filename);
 
 // Test the Hypre linear solvers
 cout << "=====================" << endl;
 cout << "Testing Hypre solvers" << endl;
 cout << "=====================" << endl;
 
 // Create a new Hypre linear solver
 HypreSolver* hypre_linear_solver_pt = new HypreSolver;
 
 // Set the linear solver for problem
 problem.linear_solver_pt() = hypre_linear_solver_pt;
 
 // Set some solver parameters
 hypre_linear_solver_pt->max_iter() = 100;
 hypre_linear_solver_pt->tolerance() = 1e-10;
 hypre_linear_solver_pt->amg_simple_smoother() = 1;
 hypre_linear_solver_pt->disable_doc_time();
 hypre_linear_solver_pt->enable_hypre_error_messages();
 hypre_linear_solver_pt->amg_print_level() = 0;
 hypre_linear_solver_pt->krylov_print_level() = 0;
 
 // Loop over hypre solvers
 //------------------------
 for (unsigned s=0; s<=3; s++)
  {
   // Select the actual iterative linear solver
   switch(s)
    {
    case 0: 
     hypre_linear_solver_pt->hypre_method() = HypreSolver::BoomerAMG;
     break;
    case 1: 
     hypre_linear_solver_pt->hypre_method() = HypreSolver::CG;
     break;
    case 2:
     hypre_linear_solver_pt->hypre_method() = HypreSolver::GMRES;
     break;
    case 3:
     hypre_linear_solver_pt->hypre_method() = HypreSolver::BiCGStab;
     break;
    default: cout << "Error selecting solver" << endl;
    }
 
 
   // Loop over preconditioners (except for AMG solver which is not
   // preconditioned)
   unsigned tests;
   if (s==0)
    {
     tests = 1;
    }
   else
    {
     tests = 4;
    }
  
   for (unsigned p=0; p<tests; p++)
    {
     // set the preconditioner
     switch(p)
      {
      case 0:
       hypre_linear_solver_pt->internal_preconditioner()=HypreSolver::None;
       break;
      case 1:
       hypre_linear_solver_pt->internal_preconditioner()=HypreSolver::BoomerAMG;
       break;
      case 2:
       hypre_linear_solver_pt->internal_preconditioner()=HypreSolver::Euclid;
       break;
      case 3:
       hypre_linear_solver_pt->internal_preconditioner()=HypreSolver::ParaSails;
       break;
      default: cout << "Error selecting preconditioner" << endl;
      }
    
     // Solve the problem
     problem.newton_solve(); 
    
     // Doc
     problem.doc_solution(doc_info);
     doc_info.number()++;
     oomph_info << "Number of Newton iterations: " << problem.newton_count() 
                << std::endl << std::endl;
     conv_file << problem.newton_count() << std::endl;
 
    } // end of loop over preconditioner
  } // end of loop over solvers
 
 // delete the Hypre solver
 delete hypre_linear_solver_pt;
 
 
 
 
 // Test the oomph-lib iterative linear solvers with the hypre preconditioners
 //---------------------------------------------------------------------------
 
 cout
  << "=====================================================================" 
  << endl;
 cout 
  << "Testing oomph-lib iterative linear solvers with Hypre preconditioners"
  << endl;
 cout
  << "=====================================================================" 
  << endl;
 
 // Create a new Hypre preconditioner
 HyprePreconditioner* hypre_preconditioner_pt = new HyprePreconditioner;
 
 // Set preconditioner parameters
 hypre_preconditioner_pt->enable_hypre_error_messages();
 
 // Test CG
 //========
 
 cout << "CG iterative solver" << endl;
 cout << "-------------------" << endl;
 
 
 IterativeLinearSolver* oomph_linear_solver_pt = new CG<CRDoubleMatrix>;
 problem.linear_solver_pt() = oomph_linear_solver_pt;
 oomph_linear_solver_pt->tolerance()=1.0e-10;
 
 
 // Run through the different hypre solver methods suitable for preconditioning
 for (unsigned p=1; p<=3; p++)
  {
   unsigned prec_method=0;
   
   switch(p)
    {
    case 1:
     prec_method = HyprePreconditioner::BoomerAMG;
     break;
     
    case 2:
     prec_method = HyprePreconditioner::Euclid;
     break;
     
    case 3:
     prec_method = HyprePreconditioner::ParaSails;
     break;
     
    default: cout << "Error selecting preconditioner" << endl;
    }
   
   // set the preconditioning method within the hypre solver
   hypre_preconditioner_pt->hypre_method() = prec_method;
   
   // set the preconditioner in the iterative solver
   oomph_linear_solver_pt->preconditioner_pt()=hypre_preconditioner_pt;
   
   // Solve the problem
   problem.newton_solve(); 
 
   // Doc
   problem.doc_solution(doc_info);
   doc_info.number()++;
   oomph_info << "Number of Newton iterations: " << problem.newton_count() 
              << std::endl << std::endl;
   conv_file << problem.newton_count() << std::endl;
  }
 delete oomph_linear_solver_pt;
 
 
 // Test BiCGStab
 //==============
 
 cout << "BiCGStab iterative solver" << endl;
 cout << "-------------------------" << endl;
 
 // Build and instance of BiCGStab and pass it to the problem
 oomph_linear_solver_pt = new BiCGStab<CRDoubleMatrix>;
 
 problem.linear_solver_pt() = oomph_linear_solver_pt;
 
 oomph_linear_solver_pt->tolerance()=1.0e-10;
 
 
 // Run through the different hypre methods suitable for preconditioning
 for (unsigned p=1; p<=3; p++)
  {
   // set the preconditioning method 
   switch(p)
    {
    case 1:
     hypre_preconditioner_pt->hypre_method() = HyprePreconditioner::BoomerAMG;
     break;
     
    case 2:
     hypre_preconditioner_pt->hypre_method() = HyprePreconditioner::Euclid;
     break;
     
    case 3:
     hypre_preconditioner_pt->hypre_method() = HyprePreconditioner::ParaSails;
     break;
     
    default: cout << "Error selecting preconditioner" << endl;
    }
 
 
   
   // set the preconditioner in the iterative solver
   oomph_linear_solver_pt->preconditioner_pt()=hypre_preconditioner_pt;
   
   // Solve the problem
   problem.newton_solve(); 
 
   // Doc
   problem.doc_solution(doc_info);
   doc_info.number()++;
   oomph_info << "Number of Newton iterations: " << problem.newton_count() 
              << std::endl << std::endl;
   conv_file << problem.newton_count() << std::endl;
 
  }
 delete oomph_linear_solver_pt;
 
 
 // Test GMRES
 //===========
 
 cout << "GMRES iterative solver" << endl;
 cout << "----------------------" << endl;
 oomph_linear_solver_pt = new GMRES<CRDoubleMatrix>;
 oomph_linear_solver_pt->tolerance()=1.0e-10;
 problem.linear_solver_pt() = oomph_linear_solver_pt;
 
 
 // run through the different hypre solver methods suitable for preconditioning
 for (unsigned p=1; p<=3; p++)
  {
   unsigned prec_method=0;
  
  
   switch(p)
    {
    case 1:
     prec_method = HyprePreconditioner::BoomerAMG;
     break;
    
    case 2:
     prec_method = HyprePreconditioner::Euclid;
     break;
    
    case 3:
     prec_method = HyprePreconditioner::ParaSails;
     break;
    
    default: cout << "Error selecting preconditioner" << endl;
    }
  
   // set the preconditioning method within the hypre solver
   hypre_preconditioner_pt->hypre_method() = prec_method;
  
   // set the preconditioner in the iterative solver
   oomph_linear_solver_pt->preconditioner_pt() = hypre_preconditioner_pt;
  
   // Solve the problem
   problem.newton_solve();
 
   // Doc
   problem.doc_solution(doc_info);
   doc_info.number()++;
   oomph_info << "Number of Newton iterations: " << problem.newton_count() 
              << std::endl << std::endl;
   conv_file << problem.newton_count() << std::endl;
  }
 delete oomph_linear_solver_pt;
 delete hypre_preconditioner_pt;
 
 conv_file.close();
 
} //end of main

References TanhSolnForPoisson::Alpha, oomph::HypreSolver::amg_print_level(), oomph::HypreSolver::amg_simple_smoother(), oomph::DocInfo::directory(), oomph::LinearSolver::disable_doc_time(), e(), oomph::HypreInterface::enable_hypre_error_messages(), MergeRestartFiles::filename, oomph::HypreSolver::hypre_method(), oomph::HyprePreconditioner::hypre_method(), oomph::HypreSolver::internal_preconditioner(), oomph::HypreSolver::krylov_print_level(), oomph::HypreSolver::max_iter(), oomph::DocInfo::number(), oomph::oomph_info, p, oomph::IterativeLinearSolver::preconditioner_pt(), problem, s, oomph::DocInfo::set_directory(), TanhSolnForPoisson::source_function(), TanhSolnForPoisson::TanPhi, oomph::HypreSolver::tolerance(), and oomph::IterativeLinearSolver::tolerance().