#include <grins_steady_solver.h>

Inheritance diagram for GRINS::SteadySolver:

Collaboration diagram for GRINS::SteadySolver:

Public Member Functions
	SteadySolver (const GetPot &input)

virtual	~SteadySolver ()

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

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

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

Protected Member Functions
virtual void	init_time_solver (GRINS::MultiphysicsSystem *system)

void	set_solver_options (libMesh::DiffSolver &solver)

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	_solver_quiet

bool	_solver_verbose

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

Detailed Description

Definition at line 34 of file grins_steady_solver.h.

Constructor & Destructor Documentation

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

Definition at line 43 of file grins_steady_solver.C.

     : Solver( input )
   {
     return;
   }

GRINS::SteadySolver::~SteadySolver ( )

virtual

Definition at line 49 of file grins_steady_solver.C.

   {
     return;
   }

Member Function Documentation

void GRINS::SteadySolver::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 113 of file grins_steady_solver.C.

References GRINS::SolverContext::system.

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

void GRINS::SteadySolver::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 123 of file grins_steady_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::SteadySolver::init_time_solver ( GRINS::MultiphysicsSystem * system )

protectedvirtual

Implements GRINS::Solver.

Definition at line 54 of file grins_steady_solver.C.

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

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::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;
   }

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

virtual

Implements GRINS::Solver.

Reimplemented in GRINS::DisplacementContinuationSolver.

Definition at line 62 of file grins_steady_solver.C.

References GRINS::SolverContext::do_adjoint_solve, GRINS::SolverContext::equation_system, GRINS::SolverContext::output_adjoint, GRINS::SolverContext::output_residual, GRINS::SolverContext::output_vis, GRINS::SolverContext::postprocessing, GRINS::SolverContext::print_scalars, GRINS::Solver::steady_adjoint_solve(), GRINS::SolverContext::system, and GRINS::SolverContext::vis.

   {
     libmesh_assert( context.system );
 
     if( context.output_vis ) 
       {
         context.postprocessing->update_quantities( *(context.equation_system) );
         context.vis->output( context.equation_system );
       }
 
     // GRVY timers contained in here (if enabled)
     context.system->solve();
 
     if ( context.print_scalars )
       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;
           }
 
     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_vis )
       {
         context.postprocessing->update_quantities( *(context.equation_system) );
         context.vis->output( context.equation_system );
       }
 
     if( context.output_residual ) context.vis->output_residual( context.equation_system, context.system );
 
     return;
   }

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 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);
   }