optimisation/disable_ALE/unsteady_heat/two_d_unsteady_heat_adapt.cc File Reference

#include "generic.h"
#include "unsteady_heat.h"
#include "meshes/quarter_circle_sector_mesh.h"

Classes
class	MyUnitCircle
class	RefineableUnsteadyHeatProblem< ELEMENT >
	Unsteady heat problem in deformable ellipse domain. More...

Namespaces
	TanhSolnForUnsteadyHeat

Functions
double	TanhSolnForUnsteadyHeat::step_position (const double &time)
	Position of step (x-axis intercept) More...
void	TanhSolnForUnsteadyHeat::get_exact_u (const double &time, const Vector< double > &x, Vector< double > &u)
	Exact solution as a Vector. More...
void	TanhSolnForUnsteadyHeat::get_exact_u (const double &time, const Vector< double > &x, double &u)
	Exact solution as a scalar. More...
void	TanhSolnForUnsteadyHeat::get_source (const double &time, const Vector< double > &x, double &source)
	Source function to make it an exact solution. More...
void	TanhSolnForUnsteadyHeat::prescribed_flux_on_fixed_y_boundary (const double &time, const Vector< double > &x, double &flux)
	Flux required by the exact solution on a boundary on which y is fixed. More...
void	run_it (const bool &use_ale)
int	main (int argc, char *argv[])

Variables
double	TanhSolnForUnsteadyHeat::Alpha
	Parameter for steepness of step. More...
double	TanhSolnForUnsteadyHeat::Beta
	Parameter for amplitude of step translation. More...
double	TanhSolnForUnsteadyHeat::Gamma
	Parameter for timescale of step translation. More...
double	TanhSolnForUnsteadyHeat::TanPhi
	Parameter for angle of step. More...

Function Documentation

main()

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

Demonstrate how to solve an unsteady heat problem with mesh adaptation. Command line arguments specify the name of the restart file.

{
 
 // Store command line arguments
 CommandLineArgs::setup(argc,argv);
 
 // Run it with ALE
 run_it(true);
 
 // Run it without ALE
 run_it(false);
 
}; // end of main

References run_it(), and Flag_definition::setup().

run_it()

void run_it

(

const bool &

use_ale

)

///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// Solve an unsteady heat problem with mesh adaptation with and without ALE terms

{
 
 // Build problem
 RefineableUnsteadyHeatProblem<RefineableQUnsteadyHeatElement<2,3> >
  problem(&TanhSolnForUnsteadyHeat::get_source,use_ale);
 
 // Specify duration of the simulation
 //double t_max=3.0;
 
 // Set targets for spatial adaptivity
 problem.bulk_mesh_pt()->max_permitted_error()=0.001;
 problem.bulk_mesh_pt()->min_permitted_error()=0.0001;
 
 // First timestep?
 bool first=true;
 
 // Max. number of spatial adaptations per timestep. Allow plenty
 // of adaptations at first timestep as the initial conditions
 // can be reset "exactly" from without any interpolation error.
 unsigned max_adapt=10; 
 
 // Set IC
 problem.set_initial_condition();
 
 // Initial timestep: Use the one used when setting up the initial
 // condition
 double dt=problem.time_pt()->dt();
 
 // If restart: The first step isn't really the first step,
 // i.e. initial condition should not be re-set when 
 // adaptive refinement has been performed. Also, limit
 // the max. number of refinements per timestep to the
 // normal value straightaway.
 if (CommandLineArgs::Argc==2)
  {
   first=false;
   max_adapt=1;
  }
 // If no restart, refine mesh uniformly before we get started
 else
  {
   problem.refine_uniformly();
   problem.refine_uniformly();
   // Solution is automatically interpolated from the coarse initial mesh
   // onto the refined mesh but this provides a very poor representation
   // of the intial condition: Re-assign the initial conditions
   problem.set_initial_condition();
  }
 
 //Output FE representation of the initial condition
 problem.doc_solution();
 
 // Find number of steps
 unsigned nstep = 6; // unsigned(t_max/dt);
 
 // Initialise timer
 clock_t t_start = clock();
 
 // Timestepping loop
 for (unsigned istep=0;istep<nstep;istep++)
  { 
   // Take timestep 
   problem.unsteady_newton_solve(dt,max_adapt,first);
   
   // Now we've done the first timestep -- don't re-set the IC
   // in subsequent steps
   first=false;
   
   // Reduce the number of spatial adaptations to one per 
   // timestep
   max_adapt=1;
   
   //Output solution
   //problem.doc_solution();
   
  }
 
 // Stop timer
 clock_t t_end = clock();
 
 std::cout << "Total time for solution: " 
           << double(t_end-t_start)/CLOCKS_PER_SEC
           << std::endl;
 
 //Output final solution for check
 problem.doc_solution();
 
};

References oomph::CommandLineArgs::Argc, TanhSolnForUnsteadyHeat::get_source(), and problem.

Referenced by main().