unit_cube_poisson_validate.cc File Reference

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

Classes
class	UnitCubePoissonMGProblem< ELEMENT, MESH >

Namespaces
	Global_Parameters
	Namespace for global parameters.
	Smoother_Factory_Function_Helper
	Returns a pointer to a smoother of the appropriate type.
	TanhSolnForPoisson
	Namespace for exact solution for Poisson equation with "sharp step".

Functions
HelmholtzSmoother *	Smoother_Factory_Function_Helper::set_pre_smoother ()
HelmholtzSmoother *	Smoother_Factory_Function_Helper::set_post_smoother ()
void	TanhSolnForPoisson::get_exact_u (const Vector< double > &x, Vector< double > &u)
	Exact solution as a Vector. More...
void	TanhSolnForPoisson::get_exact_u (const Vector< double > &x, double &u)
	Exact solution as a scalar. More...
void	TanhSolnForPoisson::get_source (const Vector< double > &x, double &source)
	Source function to make it an exact solution. More...
int	main (int argc, char *argv[])

Function Documentation

main()

int main	(	int argc	,
		char *	argv[]
	)

///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// Driver for 3D Poisson problem in a unit cube. Solution has a sharp step.

{
 //------------------------
 // Command line arguments
 //------------------------
 // Store command line arguments
 CommandLineArgs::setup(argc,argv);
 
 // Number of nodes in one direction of an element. Setting nnode_1d to 2
 // corresponds to using linear interpolation. Setting nnode_1d=3 corresponds
 // to quadratic interpolation and setting nnode_1d to 4 corresponds to cubic
 // interpolation
 CommandLineArgs::specify_command_line_flag(
  "--nnode_1d",&Global_Parameters::Nnode_1d);
 
 // The minimum level of uniform refinement
 CommandLineArgs::specify_command_line_flag(
  "--min_ref",&Global_Parameters::Min_refinement_level);
 
 // The additional levels of uniform refinement
 CommandLineArgs::specify_command_line_flag(
  "--add_ref",&Global_Parameters::Add_refinement_level);
 
 // The maximum number of adaptive refinements
 CommandLineArgs::specify_command_line_flag(
  "--n_adapt",&Global_Parameters::N_adaptations);
 
 // The additional levels of uniform refinement
 CommandLineArgs::specify_command_line_flag(
  "--use_adapt",&Global_Parameters::Use_adaptation_flag);
 
 // The choice of pre-smoother
 CommandLineArgs::specify_command_line_flag(
  "--presmoother",&Global_Parameters::Pre_smoother_flag);
 
 // The choice of post-smoother
 CommandLineArgs::specify_command_line_flag(
  "--postsmoother",&Global_Parameters::Post_smoother_flag);
 
 // The choice of linear solver
 CommandLineArgs::specify_command_line_flag(
  "--linear_solver",&Global_Parameters::Linear_solver_flag);
 
 // The choice 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<3,2> ELEMENT;
  
  // Typedef the mesh and template it by the chosen element type
  typedef RefineableSimpleCubicMesh<ELEMENT> MESH;
 
  // Set the problem pointer
  problem_pt=new UnitCubePoissonMGProblem<ELEMENT,MESH>
   (&TanhSolnForPoisson::get_source);
 }
 else if (Global_Parameters::Nnode_1d==3)
 {
  // Using quadratic interpolation
  typedef RefineableQPoissonElement<3,3> ELEMENT;
  
  // Typedef the mesh and template it by the chosen element type
  typedef RefineableSimpleCubicMesh<ELEMENT> MESH;
 
  // Set the problem pointer
  problem_pt=new UnitCubePoissonMGProblem<ELEMENT,MESH>
   (&TanhSolnForPoisson::get_source);
 }  
 else if (Global_Parameters::Nnode_1d==4)
 {
  // Using cubic interpolation
  typedef RefineableQPoissonElement<3,4> ELEMENT;
  
  // Typedef the mesh and template it by the chosen element type
  typedef RefineableSimpleCubicMesh<ELEMENT> MESH;
 
  // Set the problem pointer
  problem_pt=new UnitCubePoissonMGProblem<ELEMENT,MESH>
   (&TanhSolnForPoisson::get_source);
 }
 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====================\n"
          << std::endl;
  }
 
  // 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(Global_Parameters::N_adaptations);
 }
 // 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)
} // end of main

References Global_Parameters::Add_refinement_level, Global_Parameters::Doc_convergence_flag, Global_Parameters::Doc_info, oomph::CommandLineArgs::doc_specified_flags(), TanhSolnForPoisson::get_source(), 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(), oomph::CommandLineArgs::specify_command_line_flag(), and Global_Parameters::Use_adaptation_flag.