#include <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)

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)

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

template<typename T >
void	set_theta (libMesh::UnsteadySolver *time_solver)

void	update_dirichlet_bcs (SolverContext &context)
	Updates Dirichlet boundary conditions. More...

void	init_second_order_in_time_solvers (SolverContext &context)

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

Protected Attributes
std::string	_time_solver_name

unsigned int	_n_timesteps

unsigned int	_backtrack_deltat

double	_theta

double	_deltat

AdaptiveTimeSteppingOptions	_adapt_time_step_options

bool	_is_second_order_in_time
	Track whether is this a second order (in time) solver or not. More...

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

Detailed Description

Definition at line 39 of file unsteady_solver.h.

Constructor & Destructor Documentation

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

Definition at line 54 of file unsteady_solver.C.

     : Solver(input),
       _time_solver_name(TimeSteppingParsing::parse_time_stepper_name(input)),
       _n_timesteps( TimeSteppingParsing::parse_n_timesteps(input) ),
       _backtrack_deltat( TimeSteppingParsing::parse_backtrack_deltat(input) ),
       _theta( TimeSteppingParsing::parse_theta(input) ),
       _deltat( TimeSteppingParsing::parse_deltat(input) ),
       _adapt_time_step_options(input),
       _is_second_order_in_time(false)
   {}

virtual GRINS::UnsteadySolver::~UnsteadySolver ( )

inlinevirtual

Definition at line 44 of file unsteady_solver.h.

44 {};

Member Function Documentation

void GRINS::UnsteadySolver::init_second_order_in_time_solvers ( SolverContext & context )

protected

Definition at line 227 of file unsteady_solver.C.

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

Referenced by solve().

   {
     // Right now, only Newmark is available so we cast directly to that
     libMesh::TimeSolver& base_time_solver = context.system->get_time_solver();
 
     libMesh::NewmarkSolver& time_solver = libMesh::cast_ref<libMesh::NewmarkSolver&>(base_time_solver);
 
     // If there's a restart, the acceleration should already be there
     if( context.have_restart )
       time_solver.set_initial_accel_avail(true);
 
     // Otherwise, we need to compute it
     else
       {
         libMesh::out << "==========================================================" << std::endl
                      << "            Computing Initital Acceleration" << std::endl
                      << "==========================================================" << std::endl;
 
         time_solver.compute_initial_accel();
       }
   }

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

protectedvirtual

Implements GRINS::Solver.

Definition at line 65 of file unsteady_solver.C.

References _adapt_time_step_options, _backtrack_deltat, _is_second_order_in_time, _time_solver_name, GRINS::AdaptiveTimeSteppingOptions::component_norm(), GRINS::AdaptiveTimeSteppingOptions::is_time_adaptive(), GRINS::SolverNames::libmesh_euler2_solver(), GRINS::SolverNames::libmesh_euler_solver(), GRINS::SolverNames::libmesh_newmark_solver(), GRINS::AdaptiveTimeSteppingOptions::max_growth(), GRINS::AdaptiveTimeSteppingOptions::target_tolerance(), and GRINS::AdaptiveTimeSteppingOptions::upper_tolerance().

   {
     libMesh::UnsteadySolver* time_solver = NULL;
 
     if( _time_solver_name == SolverNames::libmesh_euler_solver() )
       {
         time_solver = new libMesh::EulerSolver( *(system) );
 
         this->set_theta<libMesh::EulerSolver>(time_solver);
       }
     else if( _time_solver_name == SolverNames::libmesh_euler2_solver() )
       {
         time_solver = new libMesh::Euler2Solver( *(system) );
 
         this->set_theta<libMesh::Euler2Solver>(time_solver);
       }
     else if( _time_solver_name == SolverNames::libmesh_newmark_solver() )
       {
         time_solver = new libMesh::NewmarkSolver( *(system) );
         _is_second_order_in_time = true;
       }
     else
       libmesh_error_msg("ERROR: Unsupported time stepper "+_time_solver_name);
 
     if( _adapt_time_step_options.is_time_adaptive() )
       {
         libMesh::TwostepTimeSolver *outer_solver =
           new libMesh::TwostepTimeSolver(*system);
 
         outer_solver->target_tolerance = _adapt_time_step_options.target_tolerance();
         outer_solver->upper_tolerance = _adapt_time_step_options.upper_tolerance();
         outer_solver->max_growth = _adapt_time_step_options.max_growth();
         outer_solver->component_norm = _adapt_time_step_options.component_norm();
         outer_solver->quiet = false;
 
         outer_solver->core_time_solver =
           libMesh::UniquePtr<libMesh::UnsteadySolver>(time_solver);
         system->time_solver = libMesh::UniquePtr<libMesh::TimeSolver>(outer_solver);
       }
     else
       {
         system->time_solver = libMesh::UniquePtr<libMesh::TimeSolver>(time_solver);
       }
 
     time_solver->reduce_deltat_on_diffsolver_failure = this->_backtrack_deltat;
   }

template<typename T >

void GRINS::UnsteadySolver::set_theta ( libMesh::UnsteadySolver * time_solver )

inlineprotected

Definition at line 80 of file unsteady_solver.h.

References _theta.

   {
     T* deriv_solver = libMesh::cast_ptr<T*>(time_solver);
     deriv_solver->theta = this->_theta;
   }

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

virtual

Implements GRINS::Solver.

Reimplemented in GRINS::UnsteadyMeshAdaptiveSolver.

Definition at line 112 of file unsteady_solver.C.

   {
     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 );
       }
 
     // We may need to initialize acceleration for second order solvers
     if( _is_second_order_in_time )
       this->init_second_order_in_time_solvers(context);
 
     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.
         this->update_dirichlet_bcs(context);
 
         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 )
           this->print_scalar_vars(context);
 
         // 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::UnsteadySolver::update_dirichlet_bcs ( SolverContext & context )

protected

Updates Dirichlet boundary conditions.

If the Dirichlet boundary condition is nonlinear or time-dependent, we need to update the constraints with the new solution.

Definition at line 186 of file unsteady_solver.C.

References GRINS::SolverContext::system.

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

   {
     // FIXME: This needs to be much more efficient and intuitive.
     bool have_nonlinear_dirichlet_bc = false;
     bool have_time_dependence = 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 we have a FEMFunctionBase, we assume nonlinearity
           if (bdy->f_fem.get())
             have_nonlinear_dirichlet_bc = true;
 
           // Check for time-dependence of FunctionBase
           if( bdy->f.get() )
             if( bdy->f->is_time_dependent() )
               have_time_dependence = true;
 
           if( have_nonlinear_dirichlet_bc || have_time_dependence )
             break;
 
         } // End loop over DirichletBoundaries
     }
 
 
     // Nonlinear Dirichlet constraints change as the solution does
     // and time-dependent constraints have to be updated
     if (have_nonlinear_dirichlet_bc || have_time_dependence )
       {
         context.system->reinit_constraints();
         context.system->get_dof_map().enforce_constraints_exactly(*context.system);
         context.system->get_dof_map().enforce_constraints_exactly(*context.system,
                                                                   dynamic_cast<libMesh::UnsteadySolver*>(context.system->time_solver.get())->old_local_nonlinear_solution.get());
       }
   }