multigrid/helmholtz_multigrid/unstructured_two_d_helmholtz.cc File Reference

#include <fenv.h>
#include "math.h"
#include <complex>
#include "generic.h"
#include "helmholtz.h"
#include "pml_helmholtz.h"
#include "meshes/quad_from_triangle_mesh.h"

Classes
class	GlobalParameters::TestPMLMapping
class	PMLHelmholtzMGProblem< ELEMENT >

Namespaces
	GlobalParameters
	Global parameters.
	Smoother_Factory_Function_Helper
	Returns a pointer to a smoother of the appropriate type.

Functions
void	GlobalParameters::update_parameters ()
	Update parameters. More...
void	GlobalParameters::get_exact_u (const Vector< double > &x, Vector< double > &u, const double &alpha=0.25 *MathematicalConstants::Pi)
void	GlobalParameters::get_exact_u_bessel (const Vector< double > &x, Vector< double > &u)
void	GlobalParameters::default_get_exact_u (const Vector< double > &x, Vector< double > &u)
HelmholtzSmoother *	Smoother_Factory_Function_Helper::set_pre_smoother ()
HelmholtzSmoother *	Smoother_Factory_Function_Helper::set_post_smoother ()
int	main (int argc, char **argv)
	Solve 2D Helmholtz problem. More...

Variables
unsigned	GlobalParameters::N_pml_element =1
	The number of elements in the PML layer. More...
unsigned	GlobalParameters::Disable_pml_flag =0
unsigned	GlobalParameters::N_boundary_segment =6
	The number of segments used to define the circular boundary. More...

Function Documentation

main()

int main	(	int argc	,
		char **	argv
	)

Solve 2D Helmholtz problem.

{ 
 //------------------------
 // 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",&GlobalParameters::Nnode_1d);
 
 // Set the number of elements in the PML layer
 CommandLineArgs::specify_command_line_flag(
  "--npml_element",&GlobalParameters::N_pml_element);
 
 // Set the thickness of the pml
 CommandLineArgs::specify_command_line_flag(
  "--pml_thickness",&GlobalParameters::Pml_thickness);
 
 // Decide whether or not to display convergence information
 CommandLineArgs::specify_command_line_flag(
  "--nboundary_segment",&GlobalParameters::N_boundary_segment);
 
 // Choose the minimum level of uniform refinement
 CommandLineArgs::specify_command_line_flag(
  "--min_ref",&GlobalParameters::Min_refinement_level);
 
 // Choose the additional levels of uniform refinement
 CommandLineArgs::specify_command_line_flag(
  "--add_ref",&GlobalParameters::Add_refinement_level);
 
 // Choose the maximum number of adaptive refinements
 CommandLineArgs::specify_command_line_flag(
  "--n_adapt",&GlobalParameters::N_adaptations);
 
 // Choose how many additional levels of uniform refinement to use
 CommandLineArgs::specify_command_line_flag(
  "--use_adapt",&GlobalParameters::Use_adaptation_flag);
  
 // Choose the value of k^2
 CommandLineArgs::specify_command_line_flag(
  "--k_sq",&GlobalParameters::K_squared);
 
 // Choose the value of the shift in the CSLP
 CommandLineArgs::specify_command_line_flag(
  "--alpha",&GlobalParameters::Alpha_shift);
 
 // Choose the value of the damping factor in the damped Jacobi solver
 CommandLineArgs::specify_command_line_flag(
  "--omega",&Smoother_Factory_Function_Helper::Omega);
  
 // Choose the pre-smoother
 CommandLineArgs::specify_command_line_flag(
  "--presmoother",&GlobalParameters::Pre_smoother_flag);
  
 // Choose the post-smoother
 CommandLineArgs::specify_command_line_flag(
  "--postsmoother",&GlobalParameters::Post_smoother_flag);
  
 // Choose the linear solver
 CommandLineArgs::specify_command_line_flag(
  "--linear_solver",&GlobalParameters::Linear_solver_flag);
 
 // Decide whether or not to suppress all or some of the MG solver output
 CommandLineArgs::specify_command_line_flag(
  "--output_flag",&GlobalParameters::Output_management_flag);
     
 // Decide whether or not to display convergence information
 CommandLineArgs::specify_command_line_flag(
  "--conv_flag",&GlobalParameters::Doc_convergence_flag); 
 
 // Decide whether or not to display convergence information
 CommandLineArgs::specify_command_line_flag(
  "--test_pml_mapping",&GlobalParameters::Enable_test_pml_mapping_flag);
 
 // Decide whether or not to display convergence information
 CommandLineArgs::specify_command_line_flag(
  "--disable_pml",&GlobalParameters::Disable_pml_flag); 
 
 // Parse command line
 CommandLineArgs::parse_and_assign();
  
 // Document what has been specified on the command line
 CommandLineArgs::doc_specified_flags();
 
 // Update parameters
 GlobalParameters::update_parameters();
 
 //--------------------------------
 // Set the documentation directory
 //--------------------------------
 // Set output directory
 GlobalParameters::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 (GlobalParameters::Nnode_1d==2)
 {  
  // Set up the problem with refineable 2D four-node elements from the
  // QPMLHelmholtzElement family
  typedef RefineableQPMLHelmholtzElement<2,2> ELEMENT;
    
  // Set the problem pointer
  problem_pt=new PMLHelmholtzMGProblem<ELEMENT>;
 }
 else if (GlobalParameters::Nnode_1d==3)
 {
  // Set up the problem with refineable 2D nine-node elements from the
  // QPMLHelmholtzElement family
  typedef RefineableQPMLHelmholtzElement<2,3> ELEMENT;
  
  // Set the problem pointer
  problem_pt=new PMLHelmholtzMGProblem<ELEMENT>;
 }  
 else if (GlobalParameters::Nnode_1d==4)
 {
  // Set up the problem with refineable 2D sixteen-node elements from the
  // QPMLHelmholtzElement family
  typedef RefineableQPMLHelmholtzElement<2,4> ELEMENT;
  
  // Set the problem pointer
  problem_pt=new PMLHelmholtzMGProblem<ELEMENT>;
 }
 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 to use
 if (GlobalParameters::Use_adaptation_flag)
 {
  // If the user wishes to silence everything
  if (GlobalParameters::Output_management_flag==3)
  {
   // Store the output stream pointer
   GlobalParameters::Stream_pt=oomph_info.stream_pt();
 
   // Now set the oomph_info stream pointer to the null stream to
   // disable all possible output
   oomph_info.stream_pt()=&oomph_nullstream;
  }
    
  // Keep refining until the minimum refinement level is reached
  for (unsigned i=0;i<GlobalParameters::Min_refinement_level;i++)
  { 
   oomph_info << "\n===================="
          << "Initial Refinement"
          << "===================="
          << std::endl;
   
   // Add additional refinement
   problem_pt->refine_uniformly();
  }
 
  // If we silenced the adaptation, allow output again
  if (GlobalParameters::Output_management_flag==3)
  {
   // Now set the oomph_info stream pointer to the null stream to
   // disable all possible output
   oomph_info.stream_pt()=GlobalParameters::Stream_pt;
  }
  
  // Solve the problem
  problem_pt->newton_solve();
   
  // Keep refining until the minimum refinement level is reached
  for (unsigned i=0;i<GlobalParameters::N_adaptations;i++)
  { 
   // If the user wishes to silence everything
   if (GlobalParameters::Output_management_flag==3)
   {
    // Store the output stream pointer
    GlobalParameters::Stream_pt=oomph_info.stream_pt();
 
    // Now set the oomph_info stream pointer to the null stream to
    // disable all possible output
    oomph_info.stream_pt()=&oomph_nullstream;
   }
   
   // Adapt the problem
   problem_pt->adapt();
   
   // If we silenced the adaptation, allow output again
   if (GlobalParameters::Output_management_flag==3)
   {
    // Now set the oomph_info stream pointer to the null stream to
    // disable all possible output
    oomph_info.stream_pt()=GlobalParameters::Stream_pt;
   }
  
   // Solve the problem
   problem_pt->newton_solve();
  }
 }
 // If the user instead wishes to use uniform refinement
 else
 {
  // If the user wishes to silence everything
  if (GlobalParameters::Output_management_flag==3)
  {
   // Store the output stream pointer
   GlobalParameters::Stream_pt=oomph_info.stream_pt();
 
   // Now set the oomph_info stream pointer to the null stream to
   // disable all possible output
   oomph_info.stream_pt()=&oomph_nullstream;
  }
  
  // Keep refining until the minimum refinement level is reached
  for (unsigned i=0;i<GlobalParameters::Min_refinement_level;i++)
  { 
   oomph_info << "\n===================="
          << "Initial Refinement"
          << "===================="
          << std::endl;
   
   // Add additional refinement
   problem_pt->refine_uniformly();
  }
 
  // If we silenced the adaptation, allow output again
  if (GlobalParameters::Output_management_flag==3)
  {
   // Now set the oomph_info stream pointer to the null stream to
   // disable all possible output
   oomph_info.stream_pt()=GlobalParameters::Stream_pt;
  }
  
  // Solve the problem
  problem_pt->newton_solve();
 
  // Refine and solve until the additional refinements have been completed
  for (unsigned i=0;i<GlobalParameters::Add_refinement_level;i++)
  {
   // If the user wishes to silence everything
   if (GlobalParameters::Output_management_flag==3)
   {
    // Store the output stream pointer
    GlobalParameters::Stream_pt=oomph_info.stream_pt();
 
    // Now set the oomph_info stream pointer to the null stream to
    // disable all possible output
    oomph_info.stream_pt()=&oomph_nullstream;
   }
  
   oomph_info << "==================="
          << "Additional Refinement"
          << "=================="
          << std::endl;
    
   // Add additional refinement
   problem_pt->refine_uniformly();
  
   // If we silenced the adaptation, allow output again
   if (GlobalParameters::Output_management_flag==3)
   {
    // Now set the oomph_info stream pointer to the null stream to
    // disable all possible output
    oomph_info.stream_pt()=GlobalParameters::Stream_pt;
   }
  
   // Solve the problem
   problem_pt->newton_solve();
  }
 } // if (GlobalParameters::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(), GlobalParameters::Add_refinement_level, GlobalParameters::Alpha_shift, GlobalParameters::Disable_pml_flag, GlobalParameters::Doc_convergence_flag, GlobalParameters::Doc_info, oomph::CommandLineArgs::doc_specified_flags(), GlobalParameters::Enable_test_pml_mapping_flag, i, GlobalParameters::K_squared, GlobalParameters::Linear_solver_flag, GlobalParameters::Min_refinement_level, GlobalParameters::N_adaptations, GlobalParameters::N_boundary_segment, GlobalParameters::N_pml_element, oomph::Problem::newton_solve(), GlobalParameters::Nnode_1d, Smoother_Factory_Function_Helper::Omega, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, oomph::oomph_nullstream, GlobalParameters::Output_management_flag, oomph::CommandLineArgs::parse_and_assign(), GlobalParameters::Pml_thickness, GlobalParameters::Post_smoother_flag, GlobalParameters::Pre_smoother_flag, oomph::Problem::refine_uniformly(), oomph::DocInfo::set_directory(), oomph::CommandLineArgs::setup(), oomph::CommandLineArgs::specify_command_line_flag(), GlobalParameters::Stream_pt, oomph::OomphInfo::stream_pt(), GlobalParameters::update_parameters(), and GlobalParameters::Use_adaptation_flag.