#include <time_stepping_parsing.h>

Public Member Functions
	TimeSteppingParsing ()

	~TimeSteppingParsing ()

Static Public Member Functions
static unsigned int	parse_n_timesteps (const GetPot &input)

static unsigned int	parse_backtrack_deltat (const GetPot &input)
	Parse option to retry failed time steps with smaller $\Delta t$ . More...

static double	parse_theta (const GetPot &input)
	Parse value of $\theta$ for theta method time stepping. More...

static double	parse_deltat (const GetPot &input)

static std::string	parse_time_stepper_name (const GetPot &input)

Detailed Description

Definition at line 36 of file time_stepping_parsing.h.

Constructor & Destructor Documentation

GRINS::TimeSteppingParsing::TimeSteppingParsing ( )

inline

Definition at line 40 of file time_stepping_parsing.h.

40 {};

GRINS::TimeSteppingParsing::~TimeSteppingParsing ( )

inline

Definition at line 42 of file time_stepping_parsing.h.

42 {};

Member Function Documentation

unsigned int GRINS::TimeSteppingParsing::parse_backtrack_deltat ( const GetPot & input )

static

Parse option to retry failed time steps with smaller $\Delta t$ .

backtrack_deltat is the number of time the TimeSolver will try to resolve the timestep with a smaller $\Delta t$ . Default is 0.

Definition at line 62 of file time_stepping_parsing.C.

References GRINS::SolverParsing::dup_solver_option_check(), and grins_warning.

   {
     SolverParsing::dup_solver_option_check(input,
                                            "unsteady-solver/backtrack_deltat",
                                            "SolverOptions/TimeStepping/backtrack_deltat");
 
     unsigned int backtrack_deltat = 0;
 
     if( input.have_variable("unsteady-solver/backtrack_deltat") )
       {
         backtrack_deltat = input("unsteady-solver/backtrack_deltat",0);
 
         std::string warning = "WARNING: unsteady-solver/backtrack_deltat is DEPRECATED!\n";
         warning += "        Please use SolverOptions/TimeStepping/backtrack_deltat to set backtrack_deltat.\n";
         grins_warning(warning);
       }
     else
       backtrack_deltat = input("SolverOptions/TimeStepping/backtrack_deltat",0);
 
     return backtrack_deltat;
   }

double GRINS::TimeSteppingParsing::parse_deltat ( const GetPot & input )

static

Definition at line 109 of file time_stepping_parsing.C.

References grins_warning.

   {
     double delta_t = 0.0;
 
     if( input.have_variable("unsteady-solver/deltat") )
       {
         delta_t = input("unsteady-solver/deltat",0.0);
 
         std::string warning = "WARNING: unsteady-solver/deltat is DEPRECATED!\n";
         warning += "        Please use SolverOptions/TimeStepping/delta_t to set delta_t.\n";
         grins_warning(warning);
       }
     else if( input.have_variable("SolverOptions/TimeStepping/delta_t") )
       delta_t = input("SolverOptions/TimeStepping/delta_t",0.0);
     else
       libmesh_error_msg("ERROR: Could not find valid entry for delta_t!");
 
     return delta_t;
   }

unsigned int GRINS::TimeSteppingParsing::parse_n_timesteps ( const GetPot & input )

static

Definition at line 38 of file time_stepping_parsing.C.

References GRINS::SolverParsing::dup_solver_option_check(), and grins_warning.

   {
     SolverParsing::dup_solver_option_check(input,
                                            "unsteady-solver/n_timesteps",
                                            "SolverOptions/TimeStepping/n_timesteps");
 
     unsigned int n_timesteps = 0;
 
     if( input.have_variable("unsteady-solver/n_timesteps") )
       {
         n_timesteps = input("unsteady-solver/n_timesteps",0);
 
         std::string warning = "WARNING: unsteady-solver/n_timesteps is DEPRECATED!\n";
         warning += "        Please use SolverOptions/TimeStepping/n_timesteps to specify # of timesteps.\n";
         grins_warning(warning);
       }
     else if( input.have_variable("SolverOptions/TimeStepping/n_timesteps") )
         n_timesteps = input("SolverOptions/TimeStepping/n_timesteps",0);
     else
       libmesh_error_msg("ERROR: Could not find valid entry for n_timesteps!");
 
     return n_timesteps;
   }

double GRINS::TimeSteppingParsing::parse_theta ( const GetPot & input )

static

Parse value of $\theta$ for theta method time stepping.

$\theta \in [0,1]$ Option only used for theta method-based time solvers. Defaults to 0.5.

Definition at line 84 of file time_stepping_parsing.C.

References grins_warning.

   {
     double theta = 0.0;
 
     if( input.have_variable("unsteady-solver/theta") )
       {
         theta = input("unsteady-solver/theta",0.5);
 
         std::string warning = "WARNING: unsteady-solver/theta is DEPRECATED!\n";
         warning += "        Please use SolverOptions/TimeStepping/theta to set theta.\n";
         grins_warning(warning);
       }
     else
       theta = input("SolverOptions/TimeStepping/theta",0.5);
 
     if( theta < 0.0 || theta > 1.0 )
       {
         std::stringstream ts;
         ts << theta;
         libmesh_error_msg("ERROR: theta must be between 0.0 and 1.0. Found: "+ts.str());
       }
 
     return theta;
   }

std::string GRINS::TimeSteppingParsing::parse_time_stepper_name ( const GetPot & input )

static

Definition at line 129 of file time_stepping_parsing.C.

References grins_warning, and GRINS::SolverNames::libmesh_euler_solver().

   {
     std::string default_stepper = SolverNames::libmesh_euler_solver();
     std::string time_stepper = default_stepper;
 
     // Before, we didn't actually set the solver name, we just set whether we
     // were transient or not. So, if we see this option was set to true, then
     // we were time stepping with the only option available then (EulerSolver)
     if( input("unsteady-solver/transient", false) )
       {
         std::string warning = "WARNING: using unsteady-solver options is DEPRECATED!\n";
         warning += "        Please use SolverOptions/TimeStepping/solver_type to set the time\n";
         warning += "        stepping algorithm.\n";
         grins_warning(warning);
       }
     else
       time_stepper = input("SolverOptions/TimeStepping/solver_type", default_stepper);
 
     return time_stepper;
   }

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

src/solver/include/grins/time_stepping_parsing.h
src/solver/src/time_stepping_parsing.C

Public Member Functions

Static Public Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation