steady_axisym_advection_diffusion.cc File Reference

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

Classes
class	TwoMeshFluxSteadyAxisymAdvectionDiffusionProblem< ELEMENT >

Namespaces
	TanhSolnForSteadyAxisymAdvectionDiffusion

Functions
Exact solution as a Vector void	TanhSolnForSteadyAxisymAdvectionDiffusion::get_exact_u (const Vector< double > &x, Vector< double > &u)
Exact solution as a scalar void	TanhSolnForSteadyAxisymAdvectionDiffusion::get_exact_u (const Vector< double > &x, double &u)
Source function required to make the solution above an exact solution void	TanhSolnForSteadyAxisymAdvectionDiffusion::source_function (const Vector< double > &x_vect, double &source)
Beta required by the exact solution on a boundary on which r is fixed void	TanhSolnForSteadyAxisymAdvectionDiffusion::prescribed_beta_on_fixed_r_boundary (const Vector< double > &x_vect, double &beta)
Alfa required by the exact solution on a boundary on which r is fixed void	TanhSolnForSteadyAxisymAdvectionDiffusion::prescribed_alpha_on_fixed_r_boundary (const Vector< double > &x_vect, double &alpha)
Wind void	TanhSolnForSteadyAxisymAdvectionDiffusion::wind_function (const Vector< double > &x, Vector< double > &wind)
Constructor for SteadyAxisymAdvectionDiffusion SteadyAxisymAdvectionDiffusionEquations::SteadyAxisymAdvectionDiffusionWindFctPt	Wind_fct_pt (wind_fct_pt)
	for (unsigned ibound=0;ibound< num_bound-1;ibound++)
Driver code for SteadyAxisymAdvectionDiffusion problem int	main ()

Variables
double	TanhSolnForSteadyAxisymAdvectionDiffusion::Peclet = 0.0
	Peclet number. More...
double	TanhSolnForSteadyAxisymAdvectionDiffusion::TanPhi = 0.5
	Parameter for angle of step. More...
double	TanhSolnForSteadyAxisymAdvectionDiffusion::Omega = 0.5
	Parameter for switch z-dependence. More...
double	TanhSolnForSteadyAxisymAdvectionDiffusion::Epsilon = 0.1
	Amplitude of boundary deflection (Epsilon<R!!!) More...
double	TanhSolnForSteadyAxisymAdvectionDiffusion::K_Alpha = 1.0
	Relation between alfa and beta (. More...
SteadyAxisymAdvectionDiffusion problem on rectangular	domain
Constructor for SteadyAxisymAdvectionDiffusion	problem
Constructor for SteadyAxisymAdvectionDiffusion SteadyAxisymAdvectionDiffusionEquations::SteadyAxisymAdvectionDiffusionWindFctPt	wind_fct_pt
Update the problem specs before	solve

Function Documentation

for()

for

(

)

  {
   // Only update the Dirichlet conditions!
   if (ibound==0 || ibound==2)
    {
     // How many nodes are there on this boundary?
     unsigned num_nod = Bulk_mesh_pt->nboundary_node(ibound);
 
     // Loop over the nodes on boundary
     for (unsigned inod=0;inod<num_nod;inod++)
      {
       // Get pointer to node
       Node* nod_pt = Bulk_mesh_pt->boundary_node_pt(ibound,inod);
 
       // Extract nodal coordinates from node:
       Vector<double> x(2);
       x[0] = nod_pt->x(0);
       x[1] = nod_pt->x(1);
 
       // Compute the value of the exact solution at the nodal point
       Vector<double> u(1);
       TanhSolnForSteadyAxisymAdvectionDiffusion::get_exact_u(x,u);
 
       // Assign the value to the one (and only) nodal value at this node
       nod_pt->set_value(0,u[0]);
 
      }
    }
  } 

References TanhSolnForSteadyAxisymAdvectionDiffusion::get_exact_u(), oomph::Data::set_value(), plotDoE::x, and oomph::Node::x().

main()

Driver code for SteadyAxisymAdvectionDiffusion problem int main

(

)

{
 
 //Set up the problem
 //------------------
 
 // Create the problem with 2D nine-node elements from the
 // QSteadyAxisymAdvectionDiffusionElement family. Pass pointer to 
 // source and wind function. 
 
 TwoMeshFluxSteadyAxisymAdvectionDiffusionProblem<QSteadyAxisymAdvectionDiffusionElement<3> > 
 problem(&TanhSolnForSteadyAxisymAdvectionDiffusion::source_function,
         &TanhSolnForSteadyAxisymAdvectionDiffusion::wind_function);
 
 // Create label for output
 //------------------------
 DocInfo doc_info;
 
 // Set output directory
 doc_info.set_directory("RESLT");
 
 // Step number
 doc_info.number() = 0;
 
 // Check if we're ready to go:
 //----------------------------
 cout << "\n\n\nProblem self-test ";
 if (problem.self_test()==0) 
  {
   cout << "passed: Problem can be solved." << std::endl;
  }
 else 
  {
   throw OomphLibError("Self test failed",
                       OOMPH_CURRENT_FUNCTION,
                       OOMPH_EXCEPTION_LOCATION);
  }
 
 // Solve the problem
 problem.newton_solve();
 
 //Output the solution
 problem.doc_solution(doc_info);
 
} // end of main

References oomph::DocInfo::number(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, problem, oomph::DocInfo::set_directory(), TanhSolnForSteadyAxisymAdvectionDiffusion::source_function(), and TanhSolnForSteadyAxisymAdvectionDiffusion::wind_function().

Wind_fct_pt()

Constructor for SteadyAxisymAdvectionDiffusion SteadyAxisymAdvectionDiffusionEquations::SteadyAxisymAdvectionDiffusionWindFctPt Wind_fct_pt

(

wind_fct_pt

)

       :  Source_fct_pt(source_fct_pt), Wind_fct_pt(wind_fct_pt)
{ 
 
 // Setup "bulk" mesh
 
 // # of elements in r-direction
 unsigned n_r = 20;
 
 // # of elements in z-direction
 unsigned n_z = 20;
 
 // Domain length in r-direction
 double l_r = 1.0;
 
 // Domain length in z-direction
 double l_z = 2.0*MathematicalConstants::Pi;
 
 // Build and assign "bulk" mesh
 
 Bulk_mesh_pt = new RectangularQuadMesh<ELEMENT>(n_r,n_z,l_r,l_z);
 
 // MODIFY THE MESH 
 // ---------------
 
 // Determine number of nodes in mesh
 const unsigned n_node = Bulk_mesh_pt->nnode();
 
 // Loop over nodes
 for(unsigned i=0;i<n_node;i++)
  {
     
   // Determine z and r coordinate of node
   double z_value = Bulk_mesh_pt->node_pt(i)->x(1);
   double r_value = Bulk_mesh_pt->node_pt(i)->x(0);
 
   // Set mesh using the external surface
   double epsilon = TanhSolnForSteadyAxisymAdvectionDiffusion::Epsilon;
 
   Bulk_mesh_pt->node_pt(i)->x(0) = r_value - (r_value/l_r)*epsilon*sin(z_value);
 
  } // End of loop over nodes
   
 // Update nodes in bulk mesh
 Bulk_mesh_pt->node_update(); 
 
 // Create "surface mesh" that will contain only the prescribed-flux 
 // elements. The constructor just creates the mesh without
 // giving it any elements, nodes, etc.
 Surface_mesh_pt = new Mesh;
 
 // Create prescribed-flux elements from all elements that are 
 // adjacent to boundary 1, but add them to a separate mesh.
 // Note that this is exactly the same function as used in the 
 // single mesh version of the problem, we merely pass different Mesh pointers.
 create_flux_elements(1,Bulk_mesh_pt,Surface_mesh_pt);
 
 // Add the two sub meshes to the problem
 add_sub_mesh(Bulk_mesh_pt);
 add_sub_mesh(Surface_mesh_pt);
 
 // Combine all submeshes into a single Mesh
 build_global_mesh();
 
 // BOUNDARY CONDITIONS
 // ------------------- 
 
 // Set the boundary conditions for this problem: All nodes are
 // free by default -- only need to pin the ones that have Dirichlet 
 // conditions here
 unsigned num_bound = Bulk_mesh_pt->nboundary();
 
 //Leave nodes on boundary 3 (symmetry axis) free
 for(unsigned ibound=0;ibound<num_bound-1;ibound++)
  {
   //Leave nodes on boundary 1 free
   if (ibound==0 || ibound==2)
    {
     unsigned num_nod= mesh_pt()->nboundary_node(ibound);
     for (unsigned inod=0;inod<num_nod;inod++)
      {
       Bulk_mesh_pt->boundary_node_pt(ibound,inod)->pin(0); 
      }
    }
  } // end loop over boundaries
 
 // Complete the build of all elements so they are fully functional 
 
 // Loop over the elements to set up element-specific 
 // things that cannot be handled by the (argument-free!) ELEMENT 
 // constructor: Pass pointer to source function
 unsigned n_element = Bulk_mesh_pt->nelement();
 for(unsigned i=0;i<n_element;i++)
  {
   // Upcast from GeneralsedElement to the present element
   ELEMENT *el_pt = dynamic_cast<ELEMENT*>(Bulk_mesh_pt->element_pt(i));
 
   //Set the source function pointer
   el_pt->source_fct_pt() = Source_fct_pt;
 
   //Set the wind function pointer
   el_pt->wind_fct_pt() = Wind_fct_pt;
 
   // Set the Peclet number pointer
   el_pt->pe_pt() = &TanhSolnForSteadyAxisymAdvectionDiffusion::Peclet;
  }
 
 // Loop over the flux elements to pass pointer to prescribed flux function
 n_element = Surface_mesh_pt->nelement();
 for(unsigned e=0;e<n_element;e++)
  {
   // Upcast from GeneralisedElement to AdvectionDiffusion flux element
   SteadyAxisymAdvectionDiffusionFluxElement<ELEMENT> *el_pt = 
    dynamic_cast< SteadyAxisymAdvectionDiffusionFluxElement<ELEMENT>*>(
     Surface_mesh_pt->element_pt(e));
 
   // Set the pointer to the prescribed beta function
   el_pt->beta_fct_pt() = 
    &TanhSolnForSteadyAxisymAdvectionDiffusion::prescribed_beta_on_fixed_r_boundary;
   // Set the pointer to the prescribed alpha function
   el_pt->alpha_fct_pt() = 
    &TanhSolnForSteadyAxisymAdvectionDiffusion::prescribed_alpha_on_fixed_r_boundary;
  }
 
 // Setup equation numbering scheme
 cout <<"Number of equations: " << assign_eqn_numbers() << std::endl; 
 
} // end of constructor

References oomph::SteadyAxisymAdvectionDiffusionFluxElement< ELEMENT >::alpha_fct_pt(), oomph::SteadyAxisymAdvectionDiffusionFluxElement< ELEMENT >::beta_fct_pt(), e(), oomph::SarahBL::epsilon, TanhSolnForSteadyAxisymAdvectionDiffusion::Epsilon, i, TanhSolnForSteadyAxisymAdvectionDiffusion::Peclet, BiharmonicTestFunctions2::Pi, TanhSolnForSteadyAxisymAdvectionDiffusion::prescribed_alpha_on_fixed_r_boundary(), TanhSolnForSteadyAxisymAdvectionDiffusion::prescribed_beta_on_fixed_r_boundary(), sin(), and oomph::Source_fct_pt.

Variable Documentation

domain

SteadyAxisymAdvectionDiffusion problem on rectangular domain

Referenced by DomainHandler::createDomains(), DomainHandler::createMesh(), DPMBase::decompose(), PeriodicBoundaryHandler::getMPIFlags(), oomph::HermiteQuadMesh< ELEMENT >::HermiteQuadMesh(), DomainHandler::initialise(), DPMBase::mpiInsertParticleCheck(), DomainHandler::setInteractionDistance(), and DPMBase::updateGhostGrid().

problem

Constructor for SteadyAxisymAdvectionDiffusion problem

Referenced by construct_and_solve_problem(), demo_elastic_fish_poisson(), demo_fish_poisson(), ElasticCollapsibleChannelMesh< ELEMENT >::ElasticCollapsibleChannelMesh(), ElasticRefineableCollapsibleChannelMesh< ELEMENT >::ElasticRefineableCollapsibleChannelMesh(), HGridOptimiser::initialise(), main(), particleParticleTest(), PointIsAboveCurve(), run(), run_it(), run_prescribed_flux(), run_prescribed_pressure_gradient(), run_test(), oomph::SolidICProblem::set_newmark_initial_condition_consistently(), set_pseudo_elastic_fsi_solver(), setCGHandler(), solve_with_fully_automatic_adaptation(), solve_with_incremental_adaptation(), solve_with_selected_refinement_pattern(), statistics_while_running< T >::statistics_while_running(), testCGHandler(), and wallParticleTest().

solve

Update the problem specs before solve

Referenced by VolumeCoupling::computeOneTimeStepForVCoupling(), Eigen::internal::evaluator< Solve< Decomposition, RhsType > >::evaluator(), Eigen::internal::evaluator< SolveWithGuess< Decomposition, RhsType, GuessType > >::evaluator(), CLiveStatistics< T >::getLiveStatistics(), Eigen::HybridNonLinearSolver< FunctorType, Scalar >::hybrj1(), main(), parallel_test(), oomph::CG< MATRIX >::resolve(), oomph::BiCGStab< MATRIX >::resolve(), oomph::GMRES< MATRIX >::resolve(), FlowRule::run(), statistics_while_running< T >::run(), AngleOfRepose::run(), SilbertHstop::solve_analytic(), and test_unaryview_solve().

wind_fct_pt

Constructor for SteadyAxisymAdvectionDiffusion SteadyAxisymAdvectionDiffusionEquations::SteadyAxisymAdvectionDiffusionWindFctPt wind_fct_pt