GRINS::SolverParsing Class Reference

#include <solver_parsing.h>

Public Member Functions
	SolverParsing ()
	~SolverParsing ()

Static Public Member Functions
static std::string	solver_type (const GetPot &input)
static bool	is_transient (const GetPot &input)
static void	dup_solver_option_check (const GetPot &input, const std::string &option1, const std::string &option2)

Detailed Description

Definition at line 36 of file solver_parsing.h.

Constructor & Destructor Documentation

GRINS::SolverParsing::SolverParsing ( )

inline

Definition at line 40 of file solver_parsing.h.

{};

GRINS::SolverParsing::~SolverParsing ( )

inline

Definition at line 42 of file solver_parsing.h.

{};

Member Function Documentation

void GRINS::SolverParsing::dup_solver_option_check ( const GetPot &  input, const std::string &  option1, const std::string &  option2  )

static

Definition at line 99 of file solver_parsing.C.

Referenced by is_transient(), GRINS::TimeSteppingParsing::parse_backtrack_deltat(), and GRINS::TimeSteppingParsing::parse_n_timesteps().

  {
    // Can't specify both old and new version
    if( input.have_variable(option1) && input.have_variable(option2) )
      {
        libmesh_error_msg("ERROR: Cannot specify both "+option1+" and "+option2);
      }
  }

bool GRINS::SolverParsing::is_transient ( const GetPot &  input )

static

Definition at line 72 of file solver_parsing.C.

References dup_solver_option_check(), and grins_warning.

Referenced by solver_type().

  {
    // Can't specify both old and new version
    SolverParsing::dup_solver_option_check(input,
                                           "unsteady-solver/transient",
                                           "SolverOptions/TimeStepping/solver_type");

    bool transient = false;

    if( input.have_variable("unsteady-solver/transient") )
      {
        transient = input("unsteady-solver/transient",false);

        std::string warning = "WARNING: unsteady-solver/transient is DEPRECATED!\n";
        warning += "        Please use SolverOptions/TimeStepping/solver_type to specify time stepping solver.\n";
        grins_warning(warning);
      }

    // In the new version, we set the solver type so we just need to
    // check if the variable is present. Solver class will figure
    // out the type.
    if( input.have_variable("SolverOptions/TimeStepping/solver_type") )
      transient = true;

    return transient;
  }

std::string GRINS::SolverParsing::solver_type ( const GetPot &  input )

static

Todo:

We should just pass this object in from the calling function

Definition at line 38 of file solver_parsing.C.

References GRINS::MeshAdaptivityOptions::is_mesh_adaptive(), is_transient(), GRINS::SolverNames::steady_mesh_adaptive_solver(), GRINS::SolverNames::steady_solver(), GRINS::SolverNames::unsteady_mesh_adaptive_solver(), and GRINS::SolverNames::unsteady_solver().

Referenced by GRINS::SolverFactory::build().

  {
    MeshAdaptivityOptions mesh_adaptivity_options(input);
    bool mesh_adaptive = mesh_adaptivity_options.is_mesh_adaptive();

    bool transient = SolverParsing::is_transient(input);

    std::string solver_type = input("SolverOptions/solver_type", "DIE!");

    if(transient && !mesh_adaptive)
      {
        solver_type = SolverNames::unsteady_solver();
      }
    else if( !transient && !mesh_adaptive )
      {
        solver_type = SolverNames::steady_solver();
      }
    else if( !transient && mesh_adaptive )
      {
        solver_type = SolverNames::steady_mesh_adaptive_solver();
      }
    else if( transient && mesh_adaptive )
      {
        solver_type = SolverNames::unsteady_mesh_adaptive_solver();
      }
    else
      {
        libmesh_error_msg("Unsupported combination of solver options!");
      }

    return solver_type;
  }

---

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

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