#include <displacement_continuation_solver.h>

Inheritance diagram for GRINS::DisplacementContinuationSolver:

Collaboration diagram for GRINS::DisplacementContinuationSolver:

Public Member Functions
	DisplacementContinuationSolver (const GetPot &input)

virtual	~DisplacementContinuationSolver ()

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

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

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

Protected Member Functions
void	increment_displacement (GRINS::MultiphysicsSystem &system, libMesh::EquationSystems &equation_system, const libMesh::Real displacement)

virtual void	init_time_solver (GRINS::MultiphysicsSystem *system)

void	set_solver_options (libMesh::DiffSolver &solver)

Protected Attributes
libMesh::boundary_id_type	_bc_id
	Boundary on which we want to increment the displacement. More...

unsigned int	_bc_index
	Cache index into libMesh::DirichletBoundaries. More...

std::vector< libMesh::Real >	_displacements

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 33 of file displacement_continuation_solver.h.

Constructor & Destructor Documentation

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

Definition at line 42 of file displacement_continuation_solver.C.

References _displacements.

     : SteadySolver(input),
       _bc_id( input("SolverOptions/DisplacementContinuation/boundary", -1) )
   {
     if( !input.have_variable("SolverOptions/DisplacementContinuation/boundary") )
       {
         std::cerr << "Error: Did not find boundary id for DisplacementContinuationSolver" << std::endl
                   << "       Must specify SolverOptions/DisplacementContinuation/boundary in input." << std::endl;
         libmesh_error();
       }
 
     if( !input.have_variable("SolverOptions/DisplacementContinuation/final_displacement") )
       {
         std::cerr << "Error: Did not find final_displacement value for DisplacementContinuationSolver" << std::endl
                   << "       Must specify SolverOptions/DisplacementContinuation/final_displacement" << std::endl;
         libmesh_error();
       }
     libMesh::Real disp_value = input("SolverOptions/DisplacementContinuation/final_displacement", 0.0);
 
 
     if( !input.have_variable("SolverOptions/DisplacementContinuation/n_increments") )
       {
         std::cerr << "Error: Did not find final_displacement value for DisplacementContinuationSolver" << std::endl
                   << "       Must specify SolverOptions/DisplacementContinuation/n_increments" << std::endl;
         libmesh_error();
       }
     unsigned int n_increments = input("SolverOptions/DisplacementContinuation/n_increments", 1);
 
     _displacements.resize(n_increments);
 
     libMesh::Real increment = disp_value/n_increments;
 
     for( unsigned int i = 0; i < n_increments; i++ )
       {
         _displacements[i] = (i+1)*increment;
       }
 
     return;
   }

GRINS::DisplacementContinuationSolver::~DisplacementContinuationSolver ( )

virtual

Definition at line 82 of file displacement_continuation_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

virtualinherited

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

virtualinherited

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::DisplacementContinuationSolver::increment_displacement	(	GRINS::MultiphysicsSystem &	system,
		libMesh::EquationSystems &	equation_system,
		const libMesh::Real	displacement
	)

protected

Definition at line 144 of file displacement_continuation_solver.C.

References _bc_index.

Referenced by solve().

   {
     // Get DirichetBoundaries vector.
     libMesh::DirichletBoundaries* d_vector = system.get_dof_map().get_dirichlet_boundaries();
 
     // Get the DirichletBoundary we want
     libMesh::DirichletBoundary* dirichlet = (*d_vector)[_bc_index];
 
     // Kill the old FunctionBase object and put in our new one.
     dirichlet->f.reset( new libMesh::ConstFunction<libMesh::Real>( displacement ) );
 
     // Need to reinit system
     equation_system.reinit();
 
     return;
   }

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

protectedvirtualinherited

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::DisplacementContinuationSolver::initialize	(	const GetPot &	input,
		std::tr1::shared_ptr< libMesh::EquationSystems >	equation_system,
		GRINS::MultiphysicsSystem *	system
	)

virtual

Reimplemented from GRINS::Solver.

Definition at line 87 of file displacement_continuation_solver.C.

References _bc_id, _bc_index, and GRINS::Solver::initialize().

   {
     // First init everything on the base class side, which will reinit equation_system
     Solver::initialize(input,equation_system,system);
 
     // Now search for the index for the DirichletBoundary we want to increment
     libMesh::DirichletBoundaries* d_vector = system->get_dof_map().get_dirichlet_boundaries();
 
     bool found_bc_id = false;
     for( libMesh::DirichletBoundaries::const_iterator it = d_vector->begin(); it != d_vector->end(); ++it )
       {
         if( (*it)->b.find(_bc_id) != (*it)->b.end() )
           {
             found_bc_id = true;
             _bc_index = it - d_vector->begin();
             // We're assuming that there's only one boundary
             break;
           }
       }
 
     if( !found_bc_id )
       {
         std::cerr << "Error: Did not find prescribed boundary for DisplacementContinuationSolver" << std::endl
                   << "       Was searching for bc_id = " << _bc_id << 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;
   }

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

virtual

Reimplemented from GRINS::SteadySolver.

Definition at line 119 of file displacement_continuation_solver.C.

References _displacements, GRINS::SolverContext::equation_system, increment_displacement(), GRINS::SolverContext::output_vis, GRINS::SolverContext::postprocessing, GRINS::SolverContext::system, and GRINS::SolverContext::vis.

   {
     for( unsigned int s = 0; s < _displacements.size(); s++ )
       {
 
         libMesh::Real disp = _displacements[s];
         
         std::cout << "==========================================================" << std::endl
                   << "   Displacement step " << s  << ", displacement = " << disp << std::endl
                   << "==========================================================" << std::endl;
 
         this->increment_displacement(*(context.system), *(context.equation_system), disp);
 
         context.system->solve();
 
         if( context.output_vis )
           {
             context.postprocessing->update_quantities( *(context.equation_system) );
             context.vis->output( context.equation_system, s, disp );
           }
       }
 
     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 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);
   }

Member Data Documentation

double GRINS::Solver::_absolute_residual_tolerance

protectedinherited

Definition at line 103 of file grins_solver.h.

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

double GRINS::Solver::_absolute_step_tolerance

protectedinherited

Definition at line 96 of file grins_solver.h.

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

libMesh::boundary_id_type GRINS::DisplacementContinuationSolver::_bc_id

protected

Boundary on which we want to increment the displacement.

Definition at line 53 of file displacement_continuation_solver.h.

Referenced by initialize().

unsigned int GRINS::DisplacementContinuationSolver::_bc_index

protected

Cache index into libMesh::DirichletBoundaries.

libMesh::DirichletBoundaries subclasses std::vector. So, we cache the index to the particular libMesh::DirichletBoundary we want. This way, we search at the beginning and reuse.

Definition at line 61 of file displacement_continuation_solver.h.

Referenced by increment_displacement(), and initialize().

bool GRINS::Solver::_continue_after_backtrack_failure

protectedinherited

Definition at line 107 of file grins_solver.h.

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

bool GRINS::Solver::_continue_after_max_iterations

protectedinherited

Definition at line 108 of file grins_solver.h.

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

std::vector<libMesh::Real> GRINS::DisplacementContinuationSolver::_displacements

protected