#include <grins_unsteady_solver.h>

Inheritance diagram for GRINS::UnsteadySolver:

Collaboration diagram for GRINS::UnsteadySolver:

Public Member Functions
	UnsteadySolver (const GetPot &input)

virtual	~UnsteadySolver ()

virtual void	solve (SolverContext &context)

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

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 Member Functions
virtual void	init_time_solver (GRINS::MultiphysicsSystem *system)

void	set_solver_options (libMesh::DiffSolver &solver)

Protected Attributes
unsigned int	_n_timesteps

unsigned int	_backtrack_deltat

double	_theta

double	_deltat

double	_target_tolerance

double	_upper_tolerance

double	_max_growth

libMesh::SystemNorm	_component_norm

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 37 of file grins_unsteady_solver.h.

Constructor & Destructor Documentation

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

Todo:: Is this the best default for delta t?

Definition at line 47 of file grins_unsteady_solver.C.

References _component_norm.

     : Solver(input),
       _n_timesteps( input("unsteady-solver/n_timesteps", 1 ) ),
       _backtrack_deltat( input("unsteady-solver/backtrack_deltat", 0 ) ),
       _theta( input("unsteady-solver/theta", 0.5 ) ),
       _deltat( input("unsteady-solver/deltat", 0.0 ) ),
       _target_tolerance( input("unsteady-solver/target_tolerance", 0.0 ) ),
       _upper_tolerance( input("unsteady-solver/upper_tolerance", 0.0 ) ),
       _max_growth( input("unsteady-solver/max_growth", 0.0 ) )
   {
     const unsigned int n_component_norm =
       input.vector_variable_size("unsteady-solver/component_norm");
     for (unsigned int i=0; i != n_component_norm; ++i)
       {
         const std::string current_norm = input("component_norm", std::string("L2"), i);
         // TODO: replace this with string_to_enum with newer libMesh
         if (current_norm == "GRINSEnums::L2")
           _component_norm.set_type(i, libMesh::L2);
         else if (current_norm == "GRINSEnums::H1")
           _component_norm.set_type(i, libMesh::H1);
         else
           libmesh_not_implemented();
       }
 
 
   }

GRINS::UnsteadySolver::~UnsteadySolver ( )

virtual

Definition at line 75 of file grins_unsteady_solver.C.

   {
     return;
   }

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

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

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

protectedvirtual

Implements GRINS::Solver.

Definition at line 80 of file grins_unsteady_solver.C.

References _backtrack_deltat, _max_growth, _target_tolerance, _theta, and _upper_tolerance.

   {
     libMesh::EulerSolver* time_solver = new libMesh::EulerSolver( *(system) );
 
     if (_target_tolerance)
       {
         libMesh::TwostepTimeSolver *outer_solver = 
           new libMesh::TwostepTimeSolver(*system);
 
         outer_solver->target_tolerance = _target_tolerance;
         outer_solver->upper_tolerance = _upper_tolerance;
         outer_solver->max_growth = _max_growth;
         outer_solver->quiet = false;
 
         outer_solver->core_time_solver =
           libMesh::AutoPtr<libMesh::UnsteadySolver>(time_solver);
         system->time_solver = libMesh::AutoPtr<libMesh::TimeSolver>(outer_solver);
       } 
     else
       {
         system->time_solver = libMesh::AutoPtr<libMesh::TimeSolver>(time_solver);
       }
 
     // Set theta parameter for time-stepping scheme
     time_solver->theta = this->_theta;
     time_solver->reduce_deltat_on_diffsolver_failure = this->_backtrack_deltat;
 
     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::UnsteadySolver::solve ( SolverContext & context )

virtual

Implements GRINS::Solver.

Definition at line 110 of file grins_unsteady_solver.C.

References _deltat, _n_timesteps, GRINS::SolverContext::equation_system, GRINS::SolverContext::output_residual, GRINS::SolverContext::output_vis, GRINS::SolverContext::postprocessing, GRINS::SolverContext::print_perflog, GRINS::SolverContext::print_scalars, GRINS::SolverContext::system, GRINS::SolverContext::timesteps_per_perflog, GRINS::SolverContext::timesteps_per_vis, and GRINS::SolverContext::vis.

   {
     libmesh_assert( context.system );
 
     context.system->deltat = this->_deltat;
   
     libMesh::Real sim_time;
 
     if( context.output_vis ) 
       {
         context.postprocessing->update_quantities( *(context.equation_system) );
         context.vis->output( context.equation_system );
       }
 
     std::time_t first_wall_time = std::time(NULL);
     
     // Now we begin the timestep loop to compute the time-accurate
     // solution of the equations.
     for (unsigned int t_step=0; t_step < this->_n_timesteps; t_step++)
       {
         std::time_t latest_wall_time = std::time(NULL);
 
         std::cout << "==========================================================" << std::endl
                   << "   Beginning time step " << t_step  <<
                      ", t = " << context.system->time <<
                      ", dt = " << context.system->deltat <<
                      ", runtime = " << (latest_wall_time - first_wall_time) << 
                      std::endl
                   << "==========================================================" << std::endl;
 
         // If we have any solution-dependent Dirichlet boundaries, we
         // need to update them with the current solution.
         //
         // FIXME: This needs to be much more efficient and intuitive.
         bool have_nonlinear_dirichlet_bc = false;
         {
         const libMesh::DirichletBoundaries &db =
           *context.system->get_dof_map().get_dirichlet_boundaries();
         for (libMesh::DirichletBoundaries::const_iterator
                it = db.begin(); it != db.end(); ++it)
           {
             const libMesh::DirichletBoundary* bdy = *it;
             if (bdy->f_fem.get())
               {
                 have_nonlinear_dirichlet_bc = true;
                 break;
               }
           }
         }
         if (have_nonlinear_dirichlet_bc)
           context.system->get_equation_systems().reinit();
 
         // GRVY timers contained in here (if enabled)
         context.system->solve();
 
         sim_time = context.system->time;
 
         if( context.output_vis && !((t_step+1)%context.timesteps_per_vis) )
           {
             context.postprocessing->update_quantities( *(context.equation_system) );
             context.vis->output( context.equation_system, t_step, sim_time );
           }
 
         if( context.output_residual && !((t_step+1)%context.timesteps_per_vis) )
           context.vis->output_residual( context.equation_system, context.system,
                                         t_step, sim_time );
 
         if ( context.print_perflog && context.timesteps_per_perflog
              && !((t_step+1)%context.timesteps_per_perflog) )
           libMesh::perflog.print_log();
 
         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;
               }
 
         // Advance to the next timestep
         context.system->time_solver->advance_timestep();
       }
 
     std::time_t final_wall_time = std::time(NULL);
     std::cout << "==========================================================" << std::endl
               << "   Ending time stepping, t = " << context.system->time <<
                  ", runtime = " << (final_wall_time - first_wall_time) << 
                  std::endl
               << "==========================================================" << std::endl;
 
 
     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);
   }