#include <solver.h>

Inheritance diagram for GRINS::Solver:

Public Member Functions
	Solver (const GetPot &input)

virtual	~Solver ()

virtual void	initialize (const GetPot &input, SharedPtr< 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...

void	print_scalar_vars (SolverContext &context)

void	print_qoi (SolverContext &context)

Protected Member Functions
void	set_solver_options (libMesh::DiffSolver &solver)

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

Protected Attributes
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

Detailed Description

Definition at line 51 of file solver.h.

Constructor & Destructor Documentation

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

Definition at line 48 of file solver.C.

     : _max_nonlinear_iterations( input("linear-nonlinear-solver/max_nonlinear_iterations", 10 ) ),
       _relative_step_tolerance( input("linear-nonlinear-solver/relative_step_tolerance", 1.e-6 ) ),
       _absolute_step_tolerance( input("linear-nonlinear-solver/absolute_step_tolerance", 0.0 ) ),
       _relative_residual_tolerance( input("linear-nonlinear-solver/relative_residual_tolerance", 1.e-15 ) ),
       _absolute_residual_tolerance( input("linear-nonlinear-solver/absolute_residual_tolerance", 0.0 ) ),
       _initial_linear_tolerance( input("linear-nonlinear-solver/initial_linear_tolerance", 1.e-3 ) ),
       _minimum_linear_tolerance( input("linear-nonlinear-solver/minimum_linear_tolerance", 1.e-3 ) ),
       _max_linear_iterations( input("linear-nonlinear-solver/max_linear_iterations", 500 ) ),
       _continue_after_backtrack_failure( input("linear-nonlinear-solver/continue_after_backtrack_failure", false ) ),
       _continue_after_max_iterations( input("linear-nonlinear-solver/continue_after_max_iterations", false ) ),
       _require_residual_reduction( input("linear-nonlinear-solver/require_residual_reduction", true ) ),
       _solver_quiet( input("screen-options/solver_quiet", false ) ),
       _solver_verbose( input("screen-options/solver_verbose", false ) )
   {
     return;
   }

GRINS::Solver::~Solver ( )

virtual

Definition at line 67 of file solver.C.

   {
     return;
   }

Member Function Documentation

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

inlinevirtual

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

Definition at line 64 of file solver.h.

69 { libmesh_not_implemented(); }

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

inlinevirtual

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

Definition at line 72 of file solver.h.

77 { libmesh_not_implemented(); }

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

protectedpure virtual

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

Referenced by initialize().

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

virtual

Definition at line 72 of file solver.C.

References init_time_solver(), and set_solver_options().

   {
 
     // 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::Solver::print_qoi ( SolverContext & context )

Definition at line 155 of file solver.C.

References GRINS::SolverContext::qoi_output, and GRINS::SolverContext::system.

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

   {
     context.system->assemble_qoi();
     const CompositeQoI* my_qoi = libMesh::cast_ptr<const CompositeQoI*>(context.system->get_qoi());
     context.qoi_output->output_qois(*my_qoi, context.system->comm());
   }

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

Definition at line 133 of file solver.C.

References GRINS::SolverContext::system.

Referenced by GRINS::SteadySolver::solve(), GRINS::UnsteadySolver::solve(), and GRINS::UnsteadyMeshAdaptiveSolver::solve().

   {
     for (unsigned int v=0; v != context.system->n_vars(); ++v)
       if (context.system->variable(v).type().family ==
           libMesh::SCALAR)
         {
           std::cout << context.system->variable_name(v) <<
             " = {";
           std::vector<libMesh::dof_id_type> scalar_indices;
           context.system->get_dof_map().SCALAR_dof_indices
             (scalar_indices, v);
           if (scalar_indices.size())
             std::cout <<
               context.system->current_solution(scalar_indices[0]);
           for (unsigned int i=1; i < scalar_indices.size();
                ++i)
             std::cout << ", " <<
               context.system->current_solution(scalar_indices[i]);
           std::cout << '}' << std::endl;
         }
   }

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

protected

Definition at line 92 of file solver.C.

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

Referenced by 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;
     if(dynamic_cast<libMesh::NewtonSolver*>(&solver))
       {
         dynamic_cast<libMesh::NewtonSolver&>(solver).require_residual_reduction = this->_require_residual_reduction;
       }
     else
       {
         // If the user tried to set require_residual_reduction flag to false
         // despite not having a NewtonSolver spit out a warning
         if(this->_require_residual_reduction == false)
           {
             libmesh_warning("GRINS can't change require_residual_reduction when not using NewtonSolver!");
           }
       }
 
     return;
   }

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

pure virtual

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

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

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 123 of file 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);
   }