two_d_poisson_tanh_flux_bc.cc File Reference

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

Classes
class	FluxPoissonMGProblem< ELEMENT, MESH >

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

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...
void	TanhSolnForPoisson::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...
Smoother *	Smoother_Factory_Function_Helper::set_smoother ()
int	main (int argc, char **argv)

Function Documentation

main()

int main	(	int argc	,
		char **	argv
	)

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

{
 //------------------------------------
 // Sort out documentation information:
 //------------------------------------
 // Create a DocInfo object to document the solution
 DocInfo doc_info;
 
 // Set output directory
 doc_info.set_directory("RESLT");
 
 // Step number
 doc_info.number()=0;
 
 //--------------------
 // Set up the problem:
 //--------------------
 // Use 2D quad elements with quadratic interpolation
 typedef RefineableQPoissonElement<2,3> ELEMENT;
 
 // Use a rectangular quad mesh templated by the chosen element type
 typedef RefineableRectangularQuadMesh<ELEMENT> MESH;
 
 // Set up the problem with the chosen element and mesh type
 FluxPoissonMGProblem<ELEMENT,MESH> problem
  (&TanhSolnForPoisson::source_function);
 
 //-------------------
 // Solve the problem:
 //-------------------
 // Set the number of times to initially refine the problem. Must be at
 // least 1 otherwise the multigrid solver uses SuperLU to solve the problem
 unsigned n_refine=1;
 
 // Keep refining until the minimum refinement level is reached
 for (unsigned i=0;i<n_refine;i++)
 {
  // Indicate the problem is about to be refined
  oomph_info << "\n===================="
         << "Initial Refinement"
         << "====================\n"
         << std::endl;
 
  // Refine the problem
  problem.refine_uniformly();
 }
 
 // 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;
 
 // Do a couple of solutions for different forcing functions
 //---------------------------------------------------------
 // Choose the number of choices of Alpha to use
 unsigned nstep=4;
 
 // Loop over the different choices of Alpha
 for (unsigned istep=0;istep<nstep;istep++)
 {
  // Increase the steepness of the step:
  TanhSolnForPoisson::Alpha+=2.0;
 
  // Tell the user what problem we're solving
  std::cout << "\n\nSolving for TanhSolnForPoisson::Alpha="
        << TanhSolnForPoisson::Alpha << "\n" << std::endl;
   
  // Solve the problem
  problem.newton_solve();
   
  // Document the solution
  problem.doc_solution(doc_info);
 }
} // End of main

References TanhSolnForPoisson::Alpha, i, oomph::DocInfo::number(), oomph::oomph_info, problem, oomph::DocInfo::set_directory(), TanhSolnForPoisson::source_function(), and TanhSolnForPoisson::TanPhi.