structured_cubic_point_source.cc File Reference

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

Classes
class	GlobalParameters::TestPMLMapping
class	PMLStructuredCubicHelmholtz< ELEMENT >
	Problem class. More...

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_simple_exact_u (const Vector< double > &x, Vector< double > &u)
	Get the exact solution, u, at the spatial position, x. More...
bool	GlobalParameters::is_in_pinned_region (const Vector< double > &x)
HelmholtzSmoother *	Smoother_Factory_Function_Helper::set_pre_smoother ()
HelmholtzSmoother *	Smoother_Factory_Function_Helper::set_post_smoother ()
int	main (int argc, char **argv)
	Solve 3D Helmholtz problem for a point source in a unit cube. More...

Variables
unsigned	GlobalParameters::Nnode_1d =2
	The number of nodes in one direction (default=2) More...
unsigned	GlobalParameters::Min_refinement_level =1
	The minimum level of uniform refinement. More...
unsigned	GlobalParameters::Add_refinement_level =0
	The additional levels of uniform refinement. More...
unsigned	GlobalParameters::N_adaptations =1
	The number of adaptations allowed by the Newton solver. More...
unsigned	GlobalParameters::Use_adaptation_flag =0
unsigned	GlobalParameters::Pre_smoother_flag =0
unsigned	GlobalParameters::Post_smoother_flag =0
unsigned	GlobalParameters::Linear_solver_flag =1
unsigned	GlobalParameters::Output_management_flag =0
unsigned	GlobalParameters::Doc_convergence_flag =0
std::ostream *	GlobalParameters::Stream_pt
double	GlobalParameters::Lx =1.0
double	GlobalParameters::Ly =1.0
double	GlobalParameters::Lz =1.0
unsigned	GlobalParameters::Nx =7
	Number of elements in each direction (used by SimpleCubicMesh) More...
unsigned	GlobalParameters::Ny =7
unsigned	GlobalParameters::Nz =7
double	GlobalParameters::Element_width =Lx/double(Nx)
	The element width. More...
double	GlobalParameters::Pml_thickness =Element_width
	Length of cube in each direction. More...
double	GlobalParameters::Pi =MathematicalConstants::Pi
	Store the value of Pi. More...
double	GlobalParameters::Alpha_shift =0.0
double	GlobalParameters::Wavenumber =sqrt(K_squared)
	Wavenumber (also known as k),k=omega/c. More...
double	GlobalParameters::Centre =Lx/2.0
	The x and y coordinate of the centre of the cube. More...
FiniteElement::SteadyExactSolutionFctPt	GlobalParameters::simple_exact_u_pt =&get_simple_exact_u
TestPMLMapping *	GlobalParameters::Test_pml_mapping_pt =new TestPMLMapping
	Set the new PML mapping. More...
unsigned	GlobalParameters::Enable_test_pml_mapping_flag =0
double	GlobalParameters::Eps =1.0e-12
	The tolerance for a point relative to the bounding inner square. More...
double	Smoother_Factory_Function_Helper::Omega =0.4
	The value of the damping factor for the damped Jacobi smoother. More...

Function Documentation

main()

int main	(	int argc	,
		char **	argv
	)

Solve 3D Helmholtz problem for a point source in a unit cube.

{
 //------------------------
 // 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);
 
 // 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);
 
 // Parse command line
 CommandLineArgs::parse_and_assign();
  
 // Document what has been specified on the command line
 CommandLineArgs::doc_specified_flags();
 
 // Update any parameters that need to be updated
 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 3D eight-noded elements from the
  // QPMLHelmholtzElement family
  typedef RefineableQPMLHelmholtzElement<3,2> ELEMENT;
    
  // Set the problem pointer
  problem_pt=new PMLStructuredCubicHelmholtz<ELEMENT>;
 }
 else if (GlobalParameters::Nnode_1d==3)
 {
  // Set up the problem with refineable 3D twenty-seven-noded elements from
  // the QPMLHelmholtzElement family
  typedef RefineableQPMLHelmholtzElement<3,3> ELEMENT;
  
  // Set the problem pointer
  problem_pt=new PMLStructuredCubicHelmholtz<ELEMENT>;
 }  
 else if (GlobalParameters::Nnode_1d==4)
 {
  // Set up the problem with refineable 3D sixty-four-noded elements from
  // the QPMLHelmholtzElement family
  typedef RefineableQPMLHelmholtzElement<3,4> ELEMENT;
  
  // Set the problem pointer
  problem_pt=new PMLStructuredCubicHelmholtz<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"
          << "====================\n"
          << 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"
          << "====================\n"
          << 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"
          << "==================\n"
          << 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::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, 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::Post_smoother_flag, GlobalParameters::Pre_smoother_flag, oomph::Problem::refine_uniformly(), oomph::DocInfo::set_directory(), Flag_definition::setup(), oomph::CommandLineArgs::specify_command_line_flag(), GlobalParameters::Stream_pt, oomph::OomphInfo::stream_pt(), GlobalParameters::update_parameters(), and GlobalParameters::Use_adaptation_flag.