two_d_poisson_tanh_flux_bc_validate.cc File Reference

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

Classes
class	FluxPoissonMGProblem< ELEMENT, MESH >

Namespaces
	Global_Parameters
	Namespace for global parameters.
	Smoother_Factory_Function_Helper
	Returns a pointer to a smoother of the appropriate type.
	SolnForPoisson
	Namespace for exact solution for Poisson equation.

Functions
HelmholtzSmoother *	Smoother_Factory_Function_Helper::set_pre_smoother ()
HelmholtzSmoother *	Smoother_Factory_Function_Helper::set_post_smoother ()
void	SolnForPoisson::get_exact_u (const Vector< double > &x, Vector< double > &u)
	Exact solution as a Vector. More...
void	SolnForPoisson::source_function (const Vector< double > &x, double &source)
	Source function required to make the solution above an exact solution. More...
void	SolnForPoisson::prescribed_flux_on_fixed_x_boundary (const Vector< double > &x, double &flux)
	Flux required by the exact solution on a boundary on which x is fixed. More...
int	main (int argc, char **argv)

Variables
unsigned	Global_Parameters::Nnode_1d =2
	The number of nodes in one direction (default=2) More...
unsigned	Global_Parameters::Min_refinement_level =2
	The minimum level of uniform refinement. More...
unsigned	Global_Parameters::Add_refinement_level =1
	The additional levels of uniform refinement. More...
unsigned	Global_Parameters::N_adaptations =1
	The number of adaptations allowed by the Newton solver. More...
unsigned	Global_Parameters::Use_adaptation_flag =0
unsigned	Global_Parameters::Pre_smoother_flag =0
unsigned	Global_Parameters::Post_smoother_flag =0
unsigned	Global_Parameters::Linear_solver_flag =1
unsigned	Global_Parameters::Output_management_flag =0
unsigned	Global_Parameters::Doc_convergence_flag =0
DocInfo	Global_Parameters::Doc_info
	DocInfo object used for documentation of the solution. More...
double	SolnForPoisson::Alpha =4.0
	Parameter for steepness of "step". More...
double	SolnForPoisson::TanPhi =1.0
	Parameter for angle Phi of "step". More...

Function Documentation

main()

int main	(	int argc	,
		char **	argv
	)

Demonstrate how to solve 2D Poisson problem with flux boundary conditions

{ 
 //------------------------
 // Command line arguments
 //------------------------
 // Store command line arguments
 CommandLineArgs::setup(argc,argv);
 
 // Choose the number of nodes in one direction of an element;
 // Values of nnode_1d:
 //        2: Bilinear interpolation 
 //        3: Biquadratic interpolation 
 //        4: Bicubic interpolation 
 CommandLineArgs::specify_command_line_flag(
  "--nnode_1d",&Global_Parameters::Nnode_1d);
 
 // Choose the minimum level of uniform refinement
 CommandLineArgs::specify_command_line_flag(
  "--min_ref",&Global_Parameters::Min_refinement_level);
 
 // Choose the additional levels of uniform refinement
 CommandLineArgs::specify_command_line_flag(
  "--add_ref",&Global_Parameters::Add_refinement_level);
 
 // Choose the maximum number of adaptive refinements
 CommandLineArgs::specify_command_line_flag(
  "--n_adapt",&Global_Parameters::N_adaptations);
 
 // Choose how many additional levels of uniform refinement to use
 CommandLineArgs::specify_command_line_flag(
  "--use_adapt",&Global_Parameters::Use_adaptation_flag);
 
 // Choose the pre-smoother
 CommandLineArgs::specify_command_line_flag(
  "--presmoother",&Global_Parameters::Pre_smoother_flag);
 
 // Choose the post-smoother
 CommandLineArgs::specify_command_line_flag(
  "--postsmoother",&Global_Parameters::Post_smoother_flag);
 
 // Choose the linear solver
 CommandLineArgs::specify_command_line_flag(
  "--linear_solver",&Global_Parameters::Linear_solver_flag);
 
 // Decide whether or not to suppress all or some of the MG solver output
 CommandLineArgs::specify_command_line_flag(
  "--output_flag",&Global_Parameters::Output_management_flag);
     
 // Decide whether or not to display convergence information
 CommandLineArgs::specify_command_line_flag(
  "--conv_flag",&Global_Parameters::Doc_convergence_flag);
  
 // Parse command line
 CommandLineArgs::parse_and_assign();
  
 // Document what has been specified on the command line
 CommandLineArgs::doc_specified_flags();
 
 //--------------------------------
 // Set the documentation directory
 //--------------------------------
 // Set output directory
 Global_Parameters::Doc_info.set_directory("RESLT");
 
 //--------------------
 // Set up the problem
 //--------------------
 // Initialise a null pointer to the class Problem 
 Problem* problem_pt=0;
 
 // Set the problem pointer depending on the input (defaulted to nnode_1d=2)
 if (Global_Parameters::Nnode_1d==2)
 {
  // Using linear interpolation
  typedef RefineableQPoissonElement<2,2> ELEMENT;
  
  // Typedef the mesh and template it by the chosen element type
  typedef RefineableRectangularQuadMesh<ELEMENT> MESH;
 
  // Set the problem pointer
  problem_pt=new FluxPoissonMGProblem<ELEMENT,MESH>
   (&SolnForPoisson::source_function);
 }
 else if (Global_Parameters::Nnode_1d==3)
 {
  // Using quadratic interpolation
  typedef RefineableQPoissonElement<2,3> ELEMENT;
  
  // Typedef the mesh and template it by the chosen element type
  typedef RefineableRectangularQuadMesh<ELEMENT> MESH;
 
  // Set the problem pointer
  problem_pt=new FluxPoissonMGProblem<ELEMENT,MESH>
   (&SolnForPoisson::source_function);
 }  
 else if (Global_Parameters::Nnode_1d==4)
 {
  // Using cubic interpolation
  typedef RefineableQPoissonElement<2,4> ELEMENT;
  
  // Typedef the mesh and template it by the chosen element type
  typedef RefineableRectangularQuadMesh<ELEMENT> MESH;
 
  // Set the problem pointer
  problem_pt=new FluxPoissonMGProblem<ELEMENT,MESH>
   (&SolnForPoisson::source_function);
 }
 else
 {
  // Throw an error otherwise
  throw OomphLibError("nnode_1d can only be 2,3 or 4.",
              OOMPH_CURRENT_FUNCTION,
              OOMPH_EXCEPTION_LOCATION);
 }
 
 //-------------------
 // Solve the problem!
 //-------------------
 // If the user wishes to use adaptive refinement then we use the
 // Newton solver with a given argument to indicate how many
 // adaptations can be done
 if (Global_Parameters::Use_adaptation_flag)
 {
  // If the user did not choose to suppress everything
  if (Global_Parameters::Output_management_flag!=4)
  {
   oomph_info << "\n====================Initial Refinement===================="
          << std::endl;
   
#ifndef PARANOID
   // If PARANOID isn't enabled we need an extra line
   oomph_info << std::endl;
#endif
  }
 
  // Refine once at least otherwise the V-cycle only uses SuperLU and converges
  // instantly
  problem_pt->refine_uniformly();
   
  // Solve the problem
  problem_pt->newton_solve();
   
  // Keep refining until the minimum refinement level is reached
  for (unsigned i=0;i<Global_Parameters::N_adaptations;i++)
  { 
   // Adapt the problem
   problem_pt->adapt();
   
   // Solve the problem
   problem_pt->newton_solve();
  }
 }
 // If the user instead wishes to use uniform refinement
 else
 {
  // Keep refining until the minimum refinement level is reached
  for (unsigned i=0;i<Global_Parameters::Min_refinement_level;i++)
  { 
   // If the user did not choose to suppress everything
   if (Global_Parameters::Output_management_flag!=4)
   {
    oomph_info << "\n====================Initial Refinement====================\n"
           << std::endl;
   }
 
   // Add additional refinement
   problem_pt->refine_uniformly();
  }
 
  // Solve the problem
  problem_pt->newton_solve();
 
  // Refine and solve until the additional refinements have been completed
  for (unsigned i=0;i<Global_Parameters::Add_refinement_level;i++)
  {
   // If the user did not choose to suppress everything
   if (Global_Parameters::Output_management_flag!=4)
   {
    oomph_info << "===================Additional Refinement==================\n"
           << std::endl;
   }
 
   // Add additional refinement
   problem_pt->refine_uniformly();
  
   // Solve the problem
   problem_pt->newton_solve();
  }
 } // if (Global_Parameters::Use_adaptation_flag)
 
 // Delete the problem pointer
 delete problem_pt;
 
 // Make it a null pointer
 problem_pt=0;
} // End of main

References oomph::Problem::adapt(), Global_Parameters::Add_refinement_level, Global_Parameters::Doc_convergence_flag, Global_Parameters::Doc_info, oomph::CommandLineArgs::doc_specified_flags(), i, Global_Parameters::Linear_solver_flag, Global_Parameters::Min_refinement_level, Global_Parameters::N_adaptations, oomph::Problem::newton_solve(), Global_Parameters::Nnode_1d, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, Global_Parameters::Output_management_flag, oomph::CommandLineArgs::parse_and_assign(), Global_Parameters::Post_smoother_flag, Global_Parameters::Pre_smoother_flag, oomph::Problem::refine_uniformly(), oomph::DocInfo::set_directory(), Flag_definition::setup(), SolnForPoisson::source_function(), oomph::CommandLineArgs::specify_command_line_flag(), and Global_Parameters::Use_adaptation_flag.