optimisation/use_coarse_base_meshes/two_d_poisson_adapt.cc File Reference

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

Classes
class	SimpleRefineableRectangularQuadMesh< ELEMENT >
class	RefineablePoissonProblem< ELEMENT >

Namespaces
	TanhSolnForPoisson
	Namespace for exact solution for Poisson equation with "sharp step".

Functions
void	TanhSolnForPoisson::get_exact_u (const Vector< double > &x, Vector< double > &u)
	Exact solution as a Vector. 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[])
	Driver code for 2D Poisson problem. More...

Function Documentation

main()

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

Driver code for 2D Poisson problem.

{
 
 
 // Number of uniform refinements relative to a 2x2 base mesh
 unsigned n_refine;
 
 // Get number of refinement levels from command line or use default
 if (argc==1)
  {
   n_refine=5;
  }
 else if (argc==2)
  {
   n_refine=atoi(argv[1]);
  }
 else
  {
   std::string error_message =
    "Wrong number of input arguments. The options are: \n";
   error_message +=
    "No args: Default number of refinements\n";
   error_message +=
    "One arg: Required number of refinements\n";
 
   throw OomphLibError(error_message,
                       OOMPH_CURRENT_FUNCTION,
                       OOMPH_EXCEPTION_LOCATION);
  }
 
 
 // Loop over two versions of refinement: Build a fine base mesh
 // or refine coarse base mesh uniformly. The former version is
 // much more expensive because the black-box quadtree forest generator
 // creates the quadtree forest in the base mesh.
 for (unsigned i=0;i<2;i++)
  {
 
   // Exponent for number of elements in base mesh
   int n_power;
   if (i==0)
    {
     cout << std::endl;
     cout << "/////////////////////////////////////////////////////////" 
          << std::endl;
     cout << "Building problem with a coarse base mesh" << std::endl;
     cout << "followed by uniform refinements." << std::endl;
     cout << "/////////////////////////////////////////////////////////" 
          << std::endl;
     cout << std::endl;
     n_power=-n_refine;
    }
   else
    {
     cout << std::endl;
     cout << "/////////////////////////////////////////////////////////" 
          << std::endl;
     cout << "Building problem with a fine base mesh" << std::endl;
     cout << "/////////////////////////////////////////////////////////" 
          << std::endl;
     cout << std::endl;
     n_power=n_refine+1;
    }
   
   //Set up the problem
   //------------------
   
   //  Initialise timers
   clock_t t_start = clock();
   
   // Create the problem with 2D nine-node refineable elements from the
   // RefineableQuadPoissonElement family. Pass pointer to source function. 
   RefineablePoissonProblem<RefineableQPoissonElement<2,3> > 
    problem(&TanhSolnForPoisson::get_source,n_power);
   
   // Finish/doc timing
   clock_t t_end = clock();
   double total_time=double(t_end-t_start)/CLOCKS_PER_SEC;
   cout << std::endl;
   cout << "======================================================= " << std::endl;
   cout << "Total time for Problem setup [sec]: " << total_time << std::endl;
   cout << "======================================================= " << std::endl;
   cout << std::endl;
   
   
   // Create label for output
   //------------------------
   DocInfo doc_info;
   
   // Set output directory
   doc_info.set_directory("RESLT");
   
   // Step number
   doc_info.number()=0;
      
   // Set the orientation of the "step" to 45 degrees
   TanhSolnForPoisson::TanPhi=1.0;
   
   // Choose a large value for the steepness of the "step"
   TanhSolnForPoisson::Alpha=1.0; 
   
   
   // Solve as linear and nonlinear problem
   //--------------------------------------
   problem.set_problem_is_nonlinear();
   
   unsigned nstep=2;
   for (unsigned istep=0;istep<nstep;istep++)
    {
     
     //  Initialise timers
     clock_t t_start = clock();
     
     if (problem.is_problem_nonlinear())
      {
       cout << std::endl << std::endl;
       cout << "============================ " << std::endl;
       cout << "Solving as nonlinear problem " << std::endl;
       cout << "============================ " << std::endl;
       cout << std::endl << std::endl;
      }
     else
      {
       cout << std::endl << std::endl;
       cout << "============================ " << std::endl;
       cout << "Solving as linear problem " << std::endl;
       cout << "============================ " << std::endl;
       cout << std::endl << std::endl;
      }
     
     // Solve the problem
     problem.newton_solve();
     
     // Finish/doc timing
     clock_t t_end = clock();
     double total_time=double(t_end-t_start)/CLOCKS_PER_SEC;
     cout << "======================================================= " 
          << std::endl;
     cout << "Total time for Newton solve [sec]: " << total_time << std::endl;
     cout << "======================================================= " 
          << std::endl;
     
     //Output the solution
     problem.doc_solution(doc_info);
     
     //Increment counter for solutions 
     doc_info.number()++;
     
     // Next time around solve as linear problem
     problem.set_problem_is_linear();
     
    }
 
   // Give user a chance to check the memory usage
   cout << std::endl << std::endl;
   cout << "Execution is paused while problem is in core" << std::endl;
   pause("Have a look at the memory usage now"); 
   
  }
 
} //end of main

References TanhSolnForPoisson::Alpha, TanhSolnForPoisson::get_source(), i, oomph::DocInfo::number(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::pause(), problem, oomph::DocInfo::set_directory(), oomph::Global_string_for_annotation::string(), and TanhSolnForPoisson::TanPhi.