#include <steady_mesh_adaptive_solver.h>

Inheritance diagram for GRINS::SteadyMeshAdaptiveSolver:

Collaboration diagram for GRINS::SteadyMeshAdaptiveSolver:

Public Member Functions
	SteadyMeshAdaptiveSolver (const GetPot &input)

virtual	~SteadyMeshAdaptiveSolver ()

virtual void	solve (SolverContext &context)

virtual void	adjoint_qoi_parameter_sensitivity (SolverContext &context, const libMesh::QoISet &qoi_indices, const libMesh::ParameterVector &parameters_in, libMesh::SensitivityData &sensitivities) const

virtual void	forward_qoi_parameter_sensitivity (SolverContext &context, const libMesh::QoISet &qoi_indices, const libMesh::ParameterVector &parameters_in, libMesh::SensitivityData &sensitivities) const

Public Member Functions inherited from GRINS::Solver
	Solver (const GetPot &input)

virtual	~Solver ()

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

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

void	print_scalar_vars (SolverContext &context)

void	print_qoi (SolverContext &context)

Public Member Functions inherited from GRINS::MeshAdaptiveSolverBase
	MeshAdaptiveSolverBase (const GetPot &input)

virtual	~MeshAdaptiveSolverBase ()

Protected Member Functions
virtual void	init_time_solver (MultiphysicsSystem *system)

void	check_qoi_error_option_consistency (SolverContext &context)

Protected Member Functions inherited from GRINS::Solver
void	set_solver_options (libMesh::DiffSolver &solver)

Protected Member Functions inherited from GRINS::MeshAdaptiveSolverBase
void	build_mesh_refinement (libMesh::MeshBase &mesh)

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

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

void	flag_elements_for_refinement (const libMesh::ErrorVector &error)

void	estimate_error_for_amr (SolverContext &context, libMesh::ErrorVector &error)

void	perform_amr (SolverContext &context, const libMesh::ErrorVector &error)

Additional Inherited Members
Protected Types inherited from GRINS::MeshAdaptiveSolverBase
enum	RefinementFlaggingType { INVALID = 0, ERROR_TOLERANCE, N_ELEM_TARGET, ERROR_FRACTION, ELEM_FRACTION, MEAN_STD_DEV }

Protected Attributes inherited from GRINS::Solver
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	_require_residual_reduction

bool	_solver_quiet

bool	_solver_verbose

Protected Attributes inherited from GRINS::MeshAdaptiveSolverBase
ErrorEstimatorOptions	_error_estimator_options

MeshAdaptivityOptions	_mesh_adaptivity_options

RefinementFlaggingType	_refinement_type

libMesh::UniquePtr< libMesh::MeshRefinement >	_mesh_refinement

Detailed Description

Definition at line 38 of file steady_mesh_adaptive_solver.h.

Constructor & Destructor Documentation

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

Definition at line 44 of file steady_mesh_adaptive_solver.C.

     : Solver(input),
       MeshAdaptiveSolverBase( input )
   {
     return;
   }

GRINS::SteadyMeshAdaptiveSolver::~SteadyMeshAdaptiveSolver ( )

virtual

Definition at line 51 of file steady_mesh_adaptive_solver.C.

   {
     return;
   }

Member Function Documentation

void GRINS::SteadyMeshAdaptiveSolver::adjoint_qoi_parameter_sensitivity	(	SolverContext &	context,
		const libMesh::QoISet &	qoi_indices,
		const libMesh::ParameterVector &	parameters_in,
		libMesh::SensitivityData &	sensitivities
	)		const

virtual

Reimplemented from GRINS::Solver.

Definition at line 164 of file steady_mesh_adaptive_solver.C.

References GRINS::SolverContext::system.

   {
     context.system->adjoint_qoi_parameter_sensitivity
       (qoi_indices, parameters_in, sensitivities);
   }

void GRINS::SteadyMeshAdaptiveSolver::check_qoi_error_option_consistency ( SolverContext & context )

protected

Definition at line 65 of file steady_mesh_adaptive_solver.C.

References GRINS::MeshAdaptiveSolverBase::_error_estimator_options, GRINS::ErrorEstimatorOptions::compute_qoi_error_estimate(), and GRINS::SolverContext::error_estimator.

Referenced by solve().

   {
     // If we are computing QoI error estimates, we have to be using
     // the Adjoint Refinement Error Estimator
     if( _error_estimator_options.compute_qoi_error_estimate() )
       if(context.error_estimator->type() != libMesh::ADJOINT_REFINEMENT)
         {
           std::string error_message = "You asked for QoI error estimates but did not use an Adjoint Refinement Error Estimator!\n";
           error_message += "Please use the ADJOINT_REFINEMENT option for the estimator_type if you want QoI error estimates.\n";
           std::cout<<error_message<<std::endl;
           libmesh_error();
         }
   }

void GRINS::SteadyMeshAdaptiveSolver::forward_qoi_parameter_sensitivity	(	SolverContext &	context,
		const libMesh::QoISet &	qoi_indices,
		const libMesh::ParameterVector &	parameters_in,
		libMesh::SensitivityData &	sensitivities
	)		const

virtual

Reimplemented from GRINS::Solver.

Definition at line 174 of file steady_mesh_adaptive_solver.C.

References GRINS::SolverContext::equation_system, GRINS::SolverContext::output_residual_sensitivities, GRINS::SolverContext::output_solution_sensitivities, GRINS::SolverContext::system, and GRINS::SolverContext::vis.

   {
     context.system->forward_qoi_parameter_sensitivity
       (qoi_indices, parameters_in, sensitivities);
 
     if( context.output_residual_sensitivities )
       context.vis->output_residual_sensitivities
         ( context.equation_system, context.system, parameters_in );
 
     if( context.output_solution_sensitivities )
       context.vis->output_solution_sensitivities
         ( context.equation_system, context.system, parameters_in );
   }

void GRINS::SteadyMeshAdaptiveSolver::init_time_solver ( MultiphysicsSystem * system )

protectedvirtual

Implements GRINS::Solver.

Definition at line 56 of file steady_mesh_adaptive_solver.C.

   {
     libMesh::SteadySolver* time_solver = new libMesh::SteadySolver( *(system) );
 
     system->time_solver = libMesh::UniquePtr<libMesh::TimeSolver>( time_solver );
 
     return;
   }

void GRINS::SteadyMeshAdaptiveSolver::solve ( SolverContext & context )

virtual

Todo:: This output cannot be toggled in the input file, but it should be able to be.

Implements GRINS::Solver.

Definition at line 79 of file steady_mesh_adaptive_solver.C.

   {
     // Check that our error estimator options are consistent
     this->check_qoi_error_option_consistency(context);
 
     // Mesh and mesh refinement
     libMesh::MeshBase& mesh = context.equation_system->get_mesh();
     this->build_mesh_refinement( mesh );
 
     std::cout << "==========================================================" << std::endl
               << "Performing " << _mesh_adaptivity_options.max_refinement_steps()
               << " adaptive refinements" << std::endl
               << "==========================================================" << std::endl;
 
     for ( unsigned int r_step = 0; r_step < _mesh_adaptivity_options.max_refinement_steps(); r_step++ )
       {
         std::cout << "==========================================================" << std::endl
                   << "Adaptive Refinement Step " << r_step << std::endl
                   << "==========================================================" << std::endl;
 
         // Solve the forward problem
         context.system->solve();
 
         if( context.output_vis )
           {
             context.postprocessing->update_quantities( *(context.equation_system) );
             context.vis->output( context.equation_system );
           }
 
         // Solve adjoint system
         if(context.do_adjoint_solve)
           this->steady_adjoint_solve(context);
 
         if(context.output_adjoint)
           context.vis->output_adjoint(context.equation_system, context.system);
 
         if( context.output_residual )
           {
             context.vis->output_residual( context.equation_system, context.system );
           }
 
         // Now we construct the data structures for the mesh refinement process
         libMesh::ErrorVector error;
         this->estimate_error_for_amr( context, error );
 
         // Get the global error estimate if you can and are asked to
         if( _error_estimator_options.compute_qoi_error_estimate() )
           for(unsigned int i = 0; i != context.system->qoi.size(); i++)
             {
               libMesh::AdjointRefinementEstimator* adjoint_ref_error_estimator = libMesh::cast_ptr<libMesh::AdjointRefinementEstimator*>( context.error_estimator.get() );
               std::cout<<"The error estimate for QoI("<<i<<") is: "<<adjoint_ref_error_estimator->get_global_QoI_error_estimate(i)<<std::endl;
             }
 
         // Check for convergence of error
         bool converged = this->check_for_convergence( context, error );
 
         if( converged )
           {
             // Break out of adaptive loop
             std::cout << "==========================================================" << std::endl
                       << "Convergence detected!" << std::endl
                       << "==========================================================" << std::endl;
             break;
           }
         else
           {
             // Only bother refining if we're on the last step.
             if( r_step < _mesh_adaptivity_options.max_refinement_steps() -1 )
               {
                 this->perform_amr(context, error);
 
                 // It's helpful to print the qoi along the way, but only do it if the user
                 // asks for it
                 if( context.qoi_output->output_qoi_set() )
                   this->print_qoi(context);
               }
           }
 
       } // r_step for-loop
 
     return;
   }

The documentation for this class was generated from the following files:

src/solver/include/grins/steady_mesh_adaptive_solver.h
src/solver/src/steady_mesh_adaptive_solver.C

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation