GRINS::UnsteadyMeshAdaptiveSolver Class Reference

#include <unsteady_mesh_adaptive_solver.h>

Inheritance diagram for GRINS::UnsteadyMeshAdaptiveSolver:

Collaboration diagram for GRINS::UnsteadyMeshAdaptiveSolver:

Public Member Functions
	UnsteadyMeshAdaptiveSolver (const GetPot &input)
virtual	~UnsteadyMeshAdaptiveSolver ()
virtual void	solve (SolverContext &context)
Public Member Functions inherited from GRINS::UnsteadySolver
	UnsteadySolver (const GetPot &input)
virtual	~UnsteadySolver ()
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, std::ostream &output)
Public Member Functions inherited from GRINS::MeshAdaptiveSolverBase
	MeshAdaptiveSolverBase (const GetPot &input)
virtual	~MeshAdaptiveSolverBase ()

Additional Inherited Members
Protected Types inherited from GRINS::MeshAdaptiveSolverBase
enum	RefinementFlaggingType {   INVALID = 0, ERROR_TOLERANCE, N_ELEM_TARGET, ERROR_FRACTION,   ELEM_FRACTION, MEAN_STD_DEV }
Protected Member Functions inherited from GRINS::UnsteadySolver
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 Member Functions inherited from GRINS::MeshAdaptiveSolverBase
void	build_mesh_refinement (libMesh::MeshBase &mesh)
void	set_refinement_type (const GetPot &input, const MeshAdaptivityOptions &mesh_adaptivity_options, RefinementFlaggingType &refinement_type)
bool	check_for_convergence (SolverContext &context, const libMesh::ErrorVector &error) const
void	flag_elements_for_refinement (const libMesh::ErrorVector &error)
void	estimate_error_for_amr (SolverContext &context, libMesh::ErrorVector &error)
void	perform_amr (SolverContext &context, const libMesh::ErrorVector &error)
Protected Attributes inherited from GRINS::UnsteadySolver
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
Protected Attributes inherited from GRINS::MeshAdaptiveSolverBase
ErrorEstimatorOptions	_error_estimator_options
MeshAdaptivityOptions	_mesh_adaptivity_options
RefinementFlaggingType	_refinement_type
libMesh::UniquePtr< libMesh::MeshRefinement >	_mesh_refinement

Detailed Description

Definition at line 38 of file unsteady_mesh_adaptive_solver.h.

Constructor & Destructor Documentation

GRINS::UnsteadyMeshAdaptiveSolver::UnsteadyMeshAdaptiveSolver

(

const GetPot &

input

)

Definition at line 40 of file unsteady_mesh_adaptive_solver.C.

    : UnsteadySolver(input),
      MeshAdaptiveSolverBase( input )
  {}

virtual GRINS::UnsteadyMeshAdaptiveSolver::~UnsteadyMeshAdaptiveSolver ( )

inlinevirtual

Definition at line 45 of file unsteady_mesh_adaptive_solver.h.

{};

Member Function Documentation

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

virtual

Reimplemented from GRINS::UnsteadySolver.

Definition at line 45 of file unsteady_mesh_adaptive_solver.C.

References GRINS::UnsteadySolver::_deltat, GRINS::MeshAdaptiveSolverBase::_mesh_adaptivity_options, GRINS::UnsteadySolver::_n_timesteps, GRINS::MeshAdaptiveSolverBase::build_mesh_refinement(), GRINS::MeshAdaptiveSolverBase::check_for_convergence(), GRINS::SolverContext::equation_system, GRINS::MeshAdaptiveSolverBase::estimate_error_for_amr(), GRINS::MeshAdaptivityOptions::max_refinement_steps(), GRINS::SolverContext::output_residual, GRINS::SolverContext::output_vis, GRINS::MeshAdaptiveSolverBase::perform_amr(), GRINS::SolverContext::postprocessing, GRINS::SolverContext::print_perflog, GRINS::SolverContext::print_qoi, GRINS::Solver::print_qoi(), GRINS::Solver::print_scalar_vars(), GRINS::SolverContext::print_scalars, GRINS::SolverContext::system, GRINS::SolverContext::timesteps_per_perflog, GRINS::SolverContext::timesteps_per_vis, GRINS::UnsteadySolver::update_dirichlet_bcs(), and GRINS::SolverContext::vis.

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

    // Setup MeshRefinement
    libMesh::MeshBase& mesh = context.equation_system->get_mesh();
    this->build_mesh_refinement( mesh );

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

        for ( unsigned int r_step = 0; r_step < _mesh_adaptivity_options.max_refinement_steps(); r_step++ )
          {
            std::cout << "==========================================================" << std::endl
                      << "Adaptive Refinement Step " << r_step << std::endl
                      << "==========================================================" << std::endl;

            // 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 )
              this->print_scalar_vars(context);


             // Now we construct the data structures for the mesh refinement process
            libMesh::ErrorVector error;
            this->estimate_error_for_amr(context,error);

            // Check for convergence of error
            bool converged = this->check_for_convergence( context, error );

            if( converged )
              {
                // Break out of adaptive loop
                std::cout << "==========================================================" << std::endl
                          << "Convergence detected!" << std::endl
                          << "==========================================================" << std::endl;
                break;
              }
            else
              {
                // Only bother refining if we're not on the last step.
                if( r_step < _mesh_adaptivity_options.max_refinement_steps() )
                  this->perform_amr(context,error);
              }

          } // End mesh adaptive loop

        // Advance to the next timestep
        context.system->time_solver->advance_timestep();

      } // End time step loop

    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;

    // Print out the QoI, but only do it if the user asks for it
    if( context.print_qoi )
      this->print_qoi(context,std::cout);
  }

---

The documentation for this class was generated from the following files:

• src/solver/include/grins/unsteady_mesh_adaptive_solver.h
• src/solver/src/unsteady_mesh_adaptive_solver.C