#include <mesh_adaptive_solver_base.h>

Inheritance diagram for GRINS::MeshAdaptiveSolverBase:

Collaboration diagram for GRINS::MeshAdaptiveSolverBase:

Public Member Functions
	MeshAdaptiveSolverBase (const GetPot &input)

virtual	~MeshAdaptiveSolverBase ()

virtual void	initialize (const GetPot &input, std::tr1::shared_ptr< libMesh::EquationSystems > equation_system, GRINS::MultiphysicsSystem *system)

virtual void	solve (SolverContext &context)=0

virtual void	adjoint_qoi_parameter_sensitivity (SolverContext &, const libMesh::QoISet &, const libMesh::ParameterVector &, libMesh::SensitivityData &) const

virtual void	forward_qoi_parameter_sensitivity (SolverContext &, const libMesh::QoISet &, const libMesh::ParameterVector &, libMesh::SensitivityData &) const

void	steady_adjoint_solve (SolverContext &context)
	Do steady version of adjoint solve. More...

Protected Types
enum	RefinementFlaggingType { INVALID = 0, ERROR_TOLERANCE, N_ELEM_TARGET, ERROR_FRACTION, ELEM_FRACTION, MEAN_STD_DEV }

Protected Member Functions
void	build_mesh_refinement (libMesh::MeshBase &mesh)

void	set_refinement_type (const GetPot &input, RefinementFlaggingType &refinement_type)

bool	check_for_convergence (SolverContext &context, const libMesh::ErrorVector &error) const

void	flag_elements_for_refinement (const libMesh::ErrorVector &error)

void	set_solver_options (libMesh::DiffSolver &solver)

virtual void	init_time_solver (GRINS::MultiphysicsSystem *system)=0

Protected Attributes
unsigned int	_max_refinement_steps

bool	_coarsen_by_parents

libMesh::Real	_absolute_global_tolerance

unsigned int	_nelem_target

libMesh::Real	_refine_fraction

libMesh::Real	_coarsen_fraction

libMesh::Real	_coarsen_threshold

bool	_plot_cell_errors

std::string	_error_plot_prefix

unsigned int	_node_level_mismatch_limit

unsigned int	_edge_level_mismatch_limit

unsigned int	_face_level_mismatch_limit

bool	_enforce_mismatch_limit_prior_to_refinement

RefinementFlaggingType	_refinement_type

boost::scoped_ptr< libMesh::MeshRefinement >	_mesh_refinement

unsigned int	_max_nonlinear_iterations

double	_relative_step_tolerance

double	_absolute_step_tolerance

double	_relative_residual_tolerance

double	_absolute_residual_tolerance

double	_initial_linear_tolerance

double	_minimum_linear_tolerance

unsigned int	_max_linear_iterations

bool	_continue_after_backtrack_failure

bool	_continue_after_max_iterations

bool	_solver_quiet

bool	_solver_verbose

std::map< std::string, GRINS::NBCContainer >	_neumann_bc_funcs

Private Member Functions
	MeshAdaptiveSolverBase ()

Detailed Description

Definition at line 51 of file mesh_adaptive_solver_base.h.

Member Enumeration Documentation

enum GRINS::MeshAdaptiveSolverBase::RefinementFlaggingType

protected

Enumerator
INVALID
ERROR_TOLERANCE
N_ELEM_TARGET
ERROR_FRACTION
ELEM_FRACTION
MEAN_STD_DEV

Definition at line 61 of file mesh_adaptive_solver_base.h.

                                { INVALID = 0,
                                  ERROR_TOLERANCE,
                                  N_ELEM_TARGET,
                                  ERROR_FRACTION,
                                  ELEM_FRACTION,
                                  MEAN_STD_DEV };

Constructor & Destructor Documentation

GRINS::MeshAdaptiveSolverBase::MeshAdaptiveSolverBase ( const GetPot & input )

Definition at line 39 of file mesh_adaptive_solver_base.C.

References _refinement_type, and set_refinement_type().

     : Solver( input ),
       _max_refinement_steps( input("MeshAdaptivity/max_refinement_steps", 5) ),
       _coarsen_by_parents(true),
       _absolute_global_tolerance( input("MeshAdaptivity/absolute_global_tolerance", 0) ),
       _nelem_target( input("MeshAdaptivity/nelem_target", 0) ),
       _refine_fraction( input("MeshAdaptivity/refine_percentage", 0.2) ),
       _coarsen_fraction( input("MeshAdaptivity/coarsen_percentage", 0.2) ),
       _coarsen_threshold( input("MeshAdaptivity/coarsen_threshold", 0) ),
       _plot_cell_errors( input("MeshAdaptivity/plot_cell_errors", false) ),
       _error_plot_prefix( input("MeshAdaptivity/error_plot_prefix", "cell_error") ),
       _node_level_mismatch_limit( input("MeshAdaptivity/node_level_mismatch_limit", 0) ),
       _edge_level_mismatch_limit( input("MeshAdaptivity/edge_level_mismatch_limit", 0 ) ),
       _face_level_mismatch_limit( input("MeshAdaptivity/face_level_mismatch_limit", 1 ) ),
       _enforce_mismatch_limit_prior_to_refinement( input("MeshAdaptivity/enforce_mismatch_limit_prior_to_refinement", false ) ),
       _refinement_type(INVALID),
       _mesh_refinement(NULL)
   {
     this->set_refinement_type( input, _refinement_type );
 
     return;
   }

GRINS::MeshAdaptiveSolverBase::~MeshAdaptiveSolverBase ( )

virtual

Definition at line 62 of file mesh_adaptive_solver_base.C.

   {
     return;
   }

GRINS::MeshAdaptiveSolverBase::MeshAdaptiveSolverBase ( )

private

Member Function Documentation

virtual void GRINS::Solver::adjoint_qoi_parameter_sensitivity	(	SolverContext &	,
		const libMesh::QoISet &	,
		const libMesh::ParameterVector &	,
		libMesh::SensitivityData &
	)		const

inlinevirtualinherited

Reimplemented in GRINS::SteadyMeshAdaptiveSolver, and GRINS::SteadySolver.

Definition at line 71 of file grins_solver.h.

76 { libmesh_not_implemented(); }

void GRINS::MeshAdaptiveSolverBase::build_mesh_refinement ( libMesh::MeshBase & mesh )

protected

Definition at line 67 of file mesh_adaptive_solver_base.C.

References _absolute_global_tolerance, _coarsen_by_parents, _coarsen_fraction, _coarsen_threshold, _edge_level_mismatch_limit, _enforce_mismatch_limit_prior_to_refinement, _face_level_mismatch_limit, _mesh_refinement, _nelem_target, _node_level_mismatch_limit, and _refine_fraction.

Referenced by GRINS::SteadyMeshAdaptiveSolver::solve().

   {
     _mesh_refinement.reset( new libMesh::MeshRefinement( mesh ) );
     _mesh_refinement->coarsen_by_parents() = _coarsen_by_parents;
     _mesh_refinement->absolute_global_tolerance() = _absolute_global_tolerance;
     _mesh_refinement->nelem_target() = _nelem_target;
     _mesh_refinement->refine_fraction() = _refine_fraction;
     _mesh_refinement->coarsen_fraction() = _coarsen_fraction;  
     _mesh_refinement->coarsen_threshold() = _coarsen_threshold;
     _mesh_refinement->node_level_mismatch_limit() = _node_level_mismatch_limit;
     _mesh_refinement->edge_level_mismatch_limit() = _edge_level_mismatch_limit;
     _mesh_refinement->face_level_mismatch_limit() = _face_level_mismatch_limit;
     _mesh_refinement->set_enforce_mismatch_limit_prior_to_refinement(_enforce_mismatch_limit_prior_to_refinement);
 
     return; 
   }

bool GRINS::MeshAdaptiveSolverBase::check_for_convergence	(	SolverContext &	context,
		const libMesh::ErrorVector &	error
	)		const

protected

Definition at line 148 of file mesh_adaptive_solver_base.C.

References _absolute_global_tolerance, and GRINS::SolverContext::do_adjoint_solve.

Referenced by GRINS::SteadyMeshAdaptiveSolver::solve().

   {
     bool converged = false;
 
     libMesh::Real error_estimate = 0.0;
 
     if( context.do_adjoint_solve )
       {
         error_estimate = std::accumulate( error.begin(), error.end(), 0.0 );
       }
     else
       {
         error_estimate = error.l2_norm();
       }
 
     std::cout << "==========================================================" << std::endl
               << "Error estimate = " << error_estimate << std::endl
               << "==========================================================" << std::endl;
 
     // For now, we just check the norm
     if( std::fabs(error_estimate) <= _absolute_global_tolerance )
       {
         converged = true;
       }
 
     return converged;
   }

void GRINS::MeshAdaptiveSolverBase::flag_elements_for_refinement ( const libMesh::ErrorVector & error )

protected

Definition at line 177 of file mesh_adaptive_solver_base.C.

References _mesh_refinement, _refinement_type, ELEM_FRACTION, ERROR_FRACTION, ERROR_TOLERANCE, INVALID, MEAN_STD_DEV, and N_ELEM_TARGET.

Referenced by GRINS::SteadyMeshAdaptiveSolver::solve().

   {
     switch(_refinement_type)
       {
       case(ERROR_TOLERANCE):
         {
           _mesh_refinement->flag_elements_by_error_tolerance( error );
         }
         break;
 
       case(N_ELEM_TARGET):
         {
           _mesh_refinement->flag_elements_by_nelem_target( error );
         }
         break;
         
       case( ERROR_FRACTION ):
         {
           _mesh_refinement->flag_elements_by_error_fraction( error );
         }
         break;
         
       case( ELEM_FRACTION ):
         {
           _mesh_refinement->flag_elements_by_elem_fraction( error );
         }
         break;
 
       case( MEAN_STD_DEV ):
         {
           _mesh_refinement->flag_elements_by_mean_stddev( error );
         }
         break;
 
       case(INVALID):
         {
           std::cerr << "Error: Invalid refinement option!" << std::endl;
           libmesh_error();
         }
         break;
 
       // Wat?!
       default:
         {
           libmesh_error();
         }
 
       } // switch(_refinement_type)
 
     return;
   }

virtual void GRINS::Solver::forward_qoi_parameter_sensitivity	(	SolverContext &	,
		const libMesh::QoISet &	,
		const libMesh::ParameterVector &	,
		libMesh::SensitivityData &
	)		const

inlinevirtualinherited

Reimplemented in GRINS::SteadyMeshAdaptiveSolver, and GRINS::SteadySolver.

Definition at line 79 of file grins_solver.h.

84 { libmesh_not_implemented(); }

virtual void GRINS::Solver::init_time_solver ( GRINS::MultiphysicsSystem * system )

protectedpure virtualinherited

Implemented in GRINS::SteadyMeshAdaptiveSolver, GRINS::SteadySolver, and GRINS::UnsteadySolver.

Referenced by GRINS::Solver::initialize().

void GRINS::Solver::initialize	(	const GetPot &	input,
		std::tr1::shared_ptr< libMesh::EquationSystems >	equation_system,
		GRINS::MultiphysicsSystem *	system
	)

virtualinherited

Reimplemented in GRINS::DisplacementContinuationSolver.

Definition at line 67 of file grins_solver.C.

References GRINS::Solver::init_time_solver(), and GRINS::Solver::set_solver_options().

Referenced by GRINS::DisplacementContinuationSolver::initialize().

   {
  
     // Defined in subclasses depending on the solver used.
     this->init_time_solver(system);
 
     // Initialize the system
     equation_system->init();
 
     // Get diff solver to set options
     libMesh::DiffSolver &solver = *(system->time_solver->diff_solver().get());
 
     // Set linear/nonlinear solver options
     this->set_solver_options( solver );
 
     return;
   }

void GRINS::MeshAdaptiveSolverBase::set_refinement_type	(	const GetPot &	input,
		MeshAdaptiveSolverBase::RefinementFlaggingType &	refinement_type
	)

protected

Definition at line 84 of file mesh_adaptive_solver_base.C.

References ELEM_FRACTION, ERROR_FRACTION, ERROR_TOLERANCE, MEAN_STD_DEV, and N_ELEM_TARGET.

Referenced by MeshAdaptiveSolverBase().

   {
     std::string refinement_stategy = input("MeshAdaptivity/refinement_strategy", "elem_fraction" ); 
 
     if( !input.have_variable("MeshAdaptivity/absolute_global_tolerance" ) )
       {
         std::cerr << "Error: Must specify absolute_global_tolerance for" << std::endl
                   << "       adaptive refinement algorithms."
                   << std::endl;
         
         libmesh_error();
       }
 
     if( refinement_stategy == std::string("error_tolerance") )
       {
         refinement_type = ERROR_TOLERANCE;
       }
 
     else if( refinement_stategy == std::string("nelem_target") )
       {
         refinement_type = N_ELEM_TARGET;
 
         if( !input.have_variable("MeshAdaptivity/nelem_target") )
           {
             std::cerr << "Error: Must specify nelem_target for" << std::endl
                       << "       for error_tolerance refinement strategy."
                       << std::endl;
 
             libmesh_error();
           }
       }
     
     else if( refinement_stategy == std::string("error_fraction") )
       {
         refinement_type = ERROR_FRACTION;
       }
 
     else if( refinement_stategy == std::string("elem_fraction") )
       {
         refinement_type = ELEM_FRACTION;
       }
 
     else if( refinement_stategy == std::string("mean_std_dev") )
       {
         refinement_type = MEAN_STD_DEV;
       }
 
     else
       {
         std::cerr << "Error: Invalid refinement strategy " << refinement_stategy << std::endl
                   << "       Valid refinement strategy options are: absolute_global_tolerance" << std::endl
                   << "                                              error_tolerance" << std::endl
                   << "                                              nelem_target" << std::endl
                   << "                                              error_fraction" << std::endl
                   << "                                              elem_fraction" << std::endl
                   << "                                              mean_std_dev" << std::endl;
 
         libmesh_error();
       }
 
     return;
   }

void GRINS::Solver::set_solver_options ( libMesh::DiffSolver & solver )

protectedinherited

Definition at line 87 of file grins_solver.C.

References GRINS::Solver::_absolute_residual_tolerance, GRINS::Solver::_absolute_step_tolerance, GRINS::Solver::_continue_after_backtrack_failure, GRINS::Solver::_continue_after_max_iterations, GRINS::Solver::_initial_linear_tolerance, GRINS::Solver::_max_linear_iterations, GRINS::Solver::_max_nonlinear_iterations, GRINS::Solver::_minimum_linear_tolerance, GRINS::Solver::_relative_residual_tolerance, GRINS::Solver::_relative_step_tolerance, GRINS::Solver::_solver_quiet, and GRINS::Solver::_solver_verbose.

Referenced by GRINS::Solver::initialize().

   {
     solver.quiet                       = this->_solver_quiet;
     solver.verbose                     = this->_solver_verbose;
     solver.max_nonlinear_iterations    = this->_max_nonlinear_iterations;
     solver.relative_step_tolerance     = this->_relative_step_tolerance;
     solver.absolute_step_tolerance     = this->_absolute_step_tolerance;
     solver.relative_residual_tolerance = this->_relative_residual_tolerance;
     solver.absolute_residual_tolerance = this->_absolute_residual_tolerance;
     solver.max_linear_iterations       = this->_max_linear_iterations;
     solver.continue_after_backtrack_failure = this->_continue_after_backtrack_failure;
     solver.initial_linear_tolerance    = this->_initial_linear_tolerance;
     solver.minimum_linear_tolerance    = this->_minimum_linear_tolerance;
     solver.continue_after_max_iterations    = this->_continue_after_max_iterations;
 
     return;
   }

virtual void GRINS::Solver::solve ( SolverContext & context )

pure virtualinherited

Implemented in GRINS::SteadyMeshAdaptiveSolver, GRINS::DisplacementContinuationSolver, GRINS::UnsteadySolver, and GRINS::SteadySolver.

void GRINS::Solver::steady_adjoint_solve ( SolverContext & context )

inherited

Do steady version of adjoint solve.

We put this here since we may want to reuse this in multiple different steady solves.

Definition at line 105 of file grins_solver.C.

References GRINS::SolverContext::system.

Referenced by GRINS::SteadySolver::solve(), and GRINS::SteadyMeshAdaptiveSolver::solve().

   {
     libMesh::out << "==========================================================" << std::endl
                  << "Solving adjoint problem." << std::endl
                  << "==========================================================" << std::endl;
 
     context.system->adjoint_solve();
     context.system->set_adjoint_already_solved(true);
   }