GRINS::AdaptiveTimeSteppingOptions Class Reference

Container for adaptive time-stepping options. More...

#include <adaptive_time_stepping_options.h>

Public Member Functions
	AdaptiveTimeSteppingOptions (const GetPot &input)
	~AdaptiveTimeSteppingOptions ()
bool	is_time_adaptive () const
double	target_tolerance () const
double	upper_tolerance () const
double	max_growth () const
const libMesh::SystemNorm &	component_norm ()

Private Member Functions
void	check_dup_input_style (const GetPot &input) const
bool	is_old_style (const GetPot &input) const
void	parse_old_style (const GetPot &input)
void	parse_new_style (const GetPot &input)
void	parse_options (const GetPot &input, const std::string &section)

Private Attributes
bool	_is_time_adaptive
double	_target_tolerance
	0.0 means there is no adaptive time stepping enabled. More...
double	_upper_tolerance
double	_max_growth
libMesh::SystemNorm	_component_norm

Detailed Description

Container for adaptive time-stepping options.

Definition at line 40 of file adaptive_time_stepping_options.h.

Constructor & Destructor Documentation

GRINS::AdaptiveTimeSteppingOptions::AdaptiveTimeSteppingOptions

(

const GetPot &

input

)

Definition at line 37 of file adaptive_time_stepping_options.C.

References _is_time_adaptive, _target_tolerance, check_dup_input_style(), is_old_style(), parse_new_style(), and parse_old_style().

    : _is_time_adaptive(false),
      _target_tolerance(0.0),
      _upper_tolerance(0.0),
      _max_growth(0.0)
  {
    this->check_dup_input_style(input);

    if( this->is_old_style(input) )
      this->parse_old_style(input);
    else
      this->parse_new_style(input);

    if( _target_tolerance > 0 )
      _is_time_adaptive = true;
  }

GRINS::AdaptiveTimeSteppingOptions::~AdaptiveTimeSteppingOptions ( )

inline

Definition at line 44 of file adaptive_time_stepping_options.h.

{};

Member Function Documentation

void GRINS::AdaptiveTimeSteppingOptions::check_dup_input_style ( const GetPot &  input ) const

private

Definition at line 54 of file adaptive_time_stepping_options.C.

Referenced by AdaptiveTimeSteppingOptions().

  {
    if( (input.have_variable("unsteady-solver/target_tolerance") &&
         input.have_section("Strategies/AdaptiveTimeStepping/target_tolerance")) ||
        (input.have_variable("unsteady-solver/upper_tolerance") &&
         input.have_section("Strategies/AdaptiveTimeStepping/upper_tolerance")) ||
        (input.have_variable("unsteady-solver/max_growth") &&
         input.have_section("Strategies/AdaptiveTimeStepping/max_growth")) )
      libmesh_error_msg("ERROR: Cannot use both old and new style of options for AdaptiveTimeSteppingOptions!");
  }

const libMesh::SystemNorm& GRINS::AdaptiveTimeSteppingOptions::component_norm ( )

inline

Definition at line 58 of file adaptive_time_stepping_options.h.

References _component_norm.

Referenced by GRINS::UnsteadySolver::init_time_solver().

    { return _component_norm; }

bool GRINS::AdaptiveTimeSteppingOptions::is_old_style ( const GetPot &  input ) const

private

Definition at line 65 of file adaptive_time_stepping_options.C.

Referenced by AdaptiveTimeSteppingOptions().

  {
    return input.have_variable("unsteady-solver/target_tolerance");
  }

bool GRINS::AdaptiveTimeSteppingOptions::is_time_adaptive ( ) const

inline

Definition at line 46 of file adaptive_time_stepping_options.h.

References _is_time_adaptive.

Referenced by GRINS::UnsteadySolver::init_time_solver().

    { return _is_time_adaptive; }

double GRINS::AdaptiveTimeSteppingOptions::max_growth ( ) const

inline

Definition at line 55 of file adaptive_time_stepping_options.h.

References _max_growth.

Referenced by GRINS::UnsteadySolver::init_time_solver().

    { return _max_growth; }

void GRINS::AdaptiveTimeSteppingOptions::parse_new_style ( const GetPot &  input )

private

Definition at line 83 of file adaptive_time_stepping_options.C.

References parse_options().

Referenced by AdaptiveTimeSteppingOptions().

  {
    std::string section = "Strategies/AdaptiveTimeStepping";
    this->parse_options(input,section);
  }

void GRINS::AdaptiveTimeSteppingOptions::parse_old_style ( const GetPot &  input )

private

Definition at line 70 of file adaptive_time_stepping_options.C.

References grins_warning, and parse_options().

Referenced by AdaptiveTimeSteppingOptions().

  {
    {
      std::string warning = "WARNING: Using [MeshAdaptivity/<options>] is a DEPRECATED\n";
      warning += "         style of input for ErrorEstimator options. Please\n";
      warning += "         update to use the [Strategies/ErrorEstimation/<options> style.\n";
      grins_warning(warning);
    }

    std::string section = "unsteady-solver";
    this->parse_options(input,section);
  }

void GRINS::AdaptiveTimeSteppingOptions::parse_options ( const GetPot &  input, const std::string &  section  )

private

Definition at line 89 of file adaptive_time_stepping_options.C.

References _component_norm, _max_growth, _target_tolerance, and _upper_tolerance.

Referenced by parse_new_style(), and parse_old_style().

  {
    // If the user set the target tolerance, for them to set the other values too
    if( input.have_variable(section+"/target_tolerance") )
      {
        if( !input.have_variable(section+"/upper_tolerance") )
          libmesh_error_msg("ERROR: Must specify "+section+"/upper_tolerance for adaptive time stepping!");

        if( !input.have_variable(section+"/max_growth") )
          libmesh_error_msg("ERROR: Must specify "+section+"/max_growth for adaptive time stepping!");
      }

    _target_tolerance = input(section+"/target_tolerance", 0.0 );
    _upper_tolerance = input(section+"/upper_tolerance", 0.0 );
    _max_growth = input(section+"/max_growth", 0.0 );

    // parse component_norm
    const unsigned int n_component_norm =
      input.vector_variable_size(section+"/component_norm");

    for (unsigned int i=0; i != n_component_norm; ++i)
      {
        const std::string current_norm = input(section+"/component_norm", std::string("L2"), i);
        _component_norm.set_type(i, libMesh::Utility::string_to_enum<libMesh::FEMNormType>(current_norm) );
      }
  }

double GRINS::AdaptiveTimeSteppingOptions::target_tolerance ( ) const

inline

Definition at line 49 of file adaptive_time_stepping_options.h.

References _target_tolerance.

Referenced by GRINS::UnsteadySolver::init_time_solver().

    { return _target_tolerance; }

double GRINS::AdaptiveTimeSteppingOptions::upper_tolerance ( ) const

inline

Definition at line 52 of file adaptive_time_stepping_options.h.

References _upper_tolerance.

Referenced by GRINS::UnsteadySolver::init_time_solver().

    { return _upper_tolerance; }

Member Data Documentation

libMesh::SystemNorm GRINS::AdaptiveTimeSteppingOptions::_component_norm

private

Definition at line 84 of file adaptive_time_stepping_options.h.

Referenced by component_norm(), and parse_options().

bool GRINS::AdaptiveTimeSteppingOptions::_is_time_adaptive

private

Definition at line 73 of file adaptive_time_stepping_options.h.

Referenced by AdaptiveTimeSteppingOptions(), and is_time_adaptive().

double GRINS::AdaptiveTimeSteppingOptions::_max_growth

private

Definition at line 81 of file adaptive_time_stepping_options.h.

Referenced by max_growth(), and parse_options().

double GRINS::AdaptiveTimeSteppingOptions::_target_tolerance

private

0.0 means there is no adaptive time stepping enabled.

To enable adaptive time stepping with the libMesh::TwostepTimeSolver, this parameter should be positive.

Definition at line 79 of file adaptive_time_stepping_options.h.

Referenced by AdaptiveTimeSteppingOptions(), parse_options(), and target_tolerance().

double GRINS::AdaptiveTimeSteppingOptions::_upper_tolerance

private

Definition at line 80 of file adaptive_time_stepping_options.h.

Referenced by parse_options(), and upper_tolerance().

---

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

• src/strategies/include/grins/adaptive_time_stepping_options.h
• src/strategies/src/adaptive_time_stepping_options.C