GRINS::Simulation Class Reference

#include <simulation.h>

Collaboration diagram for GRINS::Simulation:

Public Member Functions
	Simulation (const GetPot &input, SimulationBuilder &sim_builder, const libMesh::Parallel::Communicator &comm LIBMESH_CAN_DEFAULT_TO_COMMWORLD)
	Simulation (const GetPot &input, GetPot &command_line, SimulationBuilder &sim_builder, const libMesh::Parallel::Communicator &comm LIBMESH_CAN_DEFAULT_TO_COMMWORLD)
virtual	~Simulation ()
void	run ()
void	print_sim_info ()
SharedPtr< libMesh::EquationSystems >	get_equation_system ()
MultiphysicsSystem *	get_multiphysics_system ()
const MultiphysicsSystem *	get_multiphysics_system () const
libMesh::Number	get_qoi_value (unsigned int qoi_index) const
const std::string &	get_multiphysics_system_name () const

Protected Member Functions
void	read_restart (const GetPot &input)
void	init_multiphysics_system (const GetPot &input)
	Helper function. More...
void	init_qois (const GetPot &input, SimulationBuilder &sim_builder)
	Helper function. More...
void	init_params (const GetPot &input, SimulationBuilder &sim_builder)
	Helper function. More...
void	init_restart (const GetPot &input, SimulationBuilder &sim_builder, const libMesh::Parallel::Communicator &comm)
	Helper function. More...
bool	check_for_adjoint_solve (const GetPot &input) const
	Helper function. More...
void	init_adjoint_solve (const GetPot &input, bool output_adjoint)
	Helper function. More...
void	build_error_estimator (const GetPot &input)
void	build_solver (const GetPot &input)

Protected Attributes
SharedPtr< libMesh::UnstructuredMesh >	_mesh
SharedPtr< libMesh::EquationSystems >	_equation_system
libMesh::UniquePtr< GRINS::Solver >	_solver
std::string	_system_name
	GRINS::Multiphysics system name. More...
GRINS::MultiphysicsSystem *	_multiphysics_system
SharedPtr< GRINS::Visualization >	_vis
SharedPtr< PostProcessedQuantities< libMesh::Real > >	_postprocessing
bool	_print_mesh_info
bool	_print_log_info
bool	_print_equation_system_info
bool	_print_constraint_info
bool	_print_perflog
bool	_print_scalars
SharedPtr< QoIOutput >	_qoi_output
bool	_output_vis
bool	_output_adjoint
bool	_output_residual
bool	_output_residual_sensitivities
bool	_output_solution_sensitivities
unsigned int	_timesteps_per_vis
unsigned int	_timesteps_per_perflog
ErrorEstimatorOptions	_error_estimator_options
SharedPtr< libMesh::ErrorEstimator >	_error_estimator
ParameterManager	_adjoint_parameters
ParameterManager	_forward_parameters
bool	_do_adjoint_solve
bool	_have_restart

Private Member Functions
	Simulation ()

Detailed Description

Definition at line 58 of file simulation.h.

Constructor & Destructor Documentation

GRINS::Simulation::Simulation	(	const GetPot &	input,
		SimulationBuilder &	sim_builder,
		const libMesh::Parallel::Communicator &comm	LIBMESH_CAN_DEFAULT_TO_COMMWORLD
	)

GRINS::Simulation::Simulation	(	const GetPot &	input,
		GetPot &	command_line,
		SimulationBuilder &	sim_builder,
		const libMesh::Parallel::Communicator &comm	LIBMESH_CAN_DEFAULT_TO_COMMWORLD
	)

virtual GRINS::Simulation::~Simulation ( )

inlinevirtual

Definition at line 73 of file simulation.h.

{};

GRINS::Simulation::Simulation ( )

private

Member Function Documentation

void GRINS::Simulation::build_error_estimator ( const GetPot &  input )

protected

Definition at line 491 of file simulation.C.

References _error_estimator, _error_estimator_options, _multiphysics_system, GRINS::FactoryAbstract< libMesh::ErrorEstimator >::build(), GRINS::ErrorEstimatorOptions::estimator_type(), GRINS::ErrorEstimatorFactoryBase::set_estimator_options(), GRINS::FactoryWithGetPot< libMesh::ErrorEstimator >::set_getpot(), and GRINS::ErrorEstimatorFactoryBase::set_system().

  {
    std::string estimator_type = _error_estimator_options.estimator_type();
    if( estimator_type != std::string("none") )
      {
        ErrorEstimatorFactoryBase::set_getpot(input);
        ErrorEstimatorFactoryBase::set_system(*_multiphysics_system);
        ErrorEstimatorFactoryBase::set_estimator_options(_error_estimator_options);
        _error_estimator.reset( (ErrorEstimatorFactoryBase::build(estimator_type)).release() );
      }
  }

void GRINS::Simulation::build_solver ( const GetPot &  input )

protected

Definition at line 503 of file simulation.C.

References _solver, GRINS::FactoryAbstract< Solver >::build(), GRINS::FactoryWithGetPot< Solver >::set_getpot(), and GRINS::SolverParsing::solver_type().

  {
    SolverFactoryAbstract::set_getpot(input);

    std::string solver_name = SolverParsing::solver_type(input);

    _solver = SolverFactoryAbstract::build(solver_name);
  }

bool GRINS::Simulation::check_for_adjoint_solve ( const GetPot &  input ) const

protected

Helper function.

Todo:

This option name WILL change at some point.

Definition at line 469 of file simulation.C.

References _adjoint_parameters, _error_estimator_options, GRINS::StrategiesParsing::do_adjoint_solve(), GRINS::ErrorEstimatorOptions::estimator_requires_adjoint(), GRINS::ErrorEstimatorOptions::estimator_type(), and GRINS::ParameterManager::parameter_vector.

Referenced by init_adjoint_solve().

  {
    std::string error_estimator = _error_estimator_options.estimator_type();

    bool do_adjoint_solve = false;

    // First check if the error estimator requires an adjoint solve
    if( _error_estimator_options.estimator_requires_adjoint() )
      do_adjoint_solve = true;

    // Next check if parameter sensitivies require an adjoint solve
    if ( _adjoint_parameters.parameter_vector.size() )
      do_adjoint_solve = true;

    // Now check if the user requested to do an adjoint solve regardless
    if( StrategiesParsing::do_adjoint_solve(input) )
      do_adjoint_solve = true;

    return do_adjoint_solve;
  }

SharedPtr< libMesh::EquationSystems > GRINS::Simulation::get_equation_system

(

)

Definition at line 393 of file simulation.C.

References _equation_system.

Referenced by main(), and run().

  {
    return _equation_system;
  }

MultiphysicsSystem * GRINS::Simulation::get_multiphysics_system ( )

inline

Definition at line 179 of file simulation.h.

References _multiphysics_system.

Referenced by main().

  {
    return this->_multiphysics_system;
  }

const MultiphysicsSystem * GRINS::Simulation::get_multiphysics_system ( ) const

inline

Definition at line 172 of file simulation.h.

References _multiphysics_system.

  {
    return this->_multiphysics_system;
  }

const std::string & GRINS::Simulation::get_multiphysics_system_name ( ) const

inline

Definition at line 185 of file simulation.h.

References _system_name.

Referenced by main().

  {
    return this->_system_name;
  }

libMesh::Number GRINS::Simulation::get_qoi_value

(

unsigned int

qoi_index

)

const

Definition at line 398 of file simulation.C.

References _multiphysics_system, and GRINS::CompositeQoI::get_qoi_value().

Referenced by main().

  {
    const CompositeQoI* qoi = libMesh::cast_ptr<const CompositeQoI*>(this->_multiphysics_system->get_qoi());
    return qoi->get_qoi_value(qoi_index);
  }

void GRINS::Simulation::init_adjoint_solve ( const GetPot &  input, bool  output_adjoint  )

protected

Helper function.

Definition at line 446 of file simulation.C.

References _do_adjoint_solve, _multiphysics_system, and check_for_adjoint_solve().

  {
    // Check if we're doing an adjoint solve
    _do_adjoint_solve = this->check_for_adjoint_solve(input);

    const libMesh::DifferentiableQoI* raw_qoi = _multiphysics_system->get_qoi();
    const CompositeQoI* qoi = dynamic_cast<const CompositeQoI*>( raw_qoi );

    // If we are trying to do an adjoint solve without a QoI, that's an error
    // If there are no QoIs, the CompositeQoI never gets built and qoi will be NULL
    if( _do_adjoint_solve && !qoi )
      {
        libmesh_error_msg("Error: Adjoint solve requested, but no QoIs detected.");
      }

    /* If we are not doing an adjoint solve, but adjoint output was requested:
       that's an error. */
    if( !_do_adjoint_solve && output_adjoint )
      {
        libmesh_error_msg("Error: Adjoint output requested, but no adjoint solve requested.");
      }
  }

void GRINS::Simulation::init_multiphysics_system ( const GetPot &  input )

protected

Helper function.

Definition at line 142 of file simulation.C.

References _equation_system, _multiphysics_system, _postprocessing, _print_log_info, _solver, GRINS::MultiphysicsSystem::attach_physics_list(), GRINS::PhysicsBuilder::build_physics_map(), GRINS::VariableBuilder::build_variables(), GRINS::StrategiesParsing::extra_quadrature_order(), GRINS::MultiphysicsSystem::read_input_options(), and GRINS::MultiphysicsSystem::register_postprocessing_vars().

  {
    // Only print libMesh logging info if the user requests it
    libMesh::perflog.disable_logging();
    if( this->_print_log_info ) libMesh::perflog.enable_logging();

    VariableBuilder::build_variables(input,(*_multiphysics_system));

    PhysicsList physics_list = PhysicsBuilder::build_physics_map(input);

    _multiphysics_system->attach_physics_list( physics_list );

    _multiphysics_system->read_input_options( input );

    _multiphysics_system->register_postprocessing_vars( input, *(_postprocessing) );

    /* Postprocessing needs to be initialized before the solver since that's
       where equation_system gets init'ed */
    _postprocessing->initialize( *_multiphysics_system, *_equation_system );

    _solver->initialize( input, _equation_system, _multiphysics_system );

    // Useful for debugging
    if( input("screen-options/print_dof_constraints", false ) )
      {
        _multiphysics_system->get_dof_map().print_dof_constraints();
      }

    // This *must* be done after equation_system->init in order to get variable indices
    // Set any extra quadrature order the user requested. By default, is 0.
    _multiphysics_system->extra_quadrature_order = StrategiesParsing::extra_quadrature_order(input);

    if (input("Strategies/MeshAdaptivity/disable_two_step_refinement",false))
      _equation_system->disable_refine_in_reinit();
  }

void GRINS::Simulation::init_params ( const GetPot &  input, SimulationBuilder &  sim_builder  )

protected

Helper function.

Definition at line 199 of file simulation.C.

References _adjoint_parameters, _forward_parameters, _multiphysics_system, and GRINS::ParameterManager::initialize().

  {
    unsigned int n_adjoint_parameters =
      input.vector_variable_size("QoI/adjoint_sensitivity_parameters");

    unsigned int n_forward_parameters =
      input.vector_variable_size("QoI/forward_sensitivity_parameters");

    // If the user actually asks for parameter sensitivities, then we
    // set up the parameter vectors to use.
    if ( n_adjoint_parameters )
      {
        // If we're doing adjoint sensitivities, dq/dp only makes
        // sense if we have q
        CompositeQoI* qoi =
          libMesh::cast_ptr<CompositeQoI*>
          (this->_multiphysics_system->get_qoi());

        if (!qoi)
          {
            std::cout <<
              "Error: adjoint_sensitivity_parameters are specified but\n"
                      << "no QoIs have been specified.\n" << std::endl;
            libmesh_error();
          }

        _adjoint_parameters.initialize
          (input, "QoI/adjoint_sensitivity_parameters",
           *this->_multiphysics_system, qoi);
      }

    if ( n_forward_parameters )
      {
        // If we're doing forward sensitivities, du/dp can make
        // sense even with no q defined
        CompositeQoI* qoi =
          dynamic_cast<CompositeQoI*>
          (this->_multiphysics_system->get_qoi());

        // dynamic_cast returns NULL if our QoI isn't a CompositeQoI;
        // i.e. if there were no QoIs that made us bother setting up
        // the CompositeQoI object.  Passing NULL tells
        // ParameterManager not to bother asking for qoi registration
        // of parameters.

        _forward_parameters.initialize
          (input, "QoI/forward_sensitivity_parameters",
           *this->_multiphysics_system, qoi);
      }
  }

void GRINS::Simulation::init_qois ( const GetPot &  input, SimulationBuilder &  sim_builder  )

protected

Helper function.

Definition at line 178 of file simulation.C.

References _multiphysics_system, _qoi_output, and GRINS::SimulationBuilder::build_qoi().

  {
    // If the user actually asks for a QoI, then we add it.
    SharedPtr<CompositeQoI> qois = sim_builder.build_qoi( input );
    if( qois->n_qois() > 0 )
      {
        // This *must* be done after equation_system->init in order to get variable indices
        qois->init(input, *_multiphysics_system );

        /* Note that we are effectively transfering ownership of the qoi pointer because
           it will be cloned in _multiphysics_system and all the calculations are done there. */
        _multiphysics_system->attach_qoi( qois.get() );
      }
    else if (_qoi_output->output_qoi_set())
      {
        std::cout << "Error: print_qoi is specified but\n" <<
          "no QoIs have been specified.\n" << std::endl;
        libmesh_error();
      }
  }

void GRINS::Simulation::init_restart ( const GetPot &  input, SimulationBuilder &  sim_builder, const libMesh::Parallel::Communicator &  comm  )

protected

Helper function.

Definition at line 252 of file simulation.C.

References _equation_system, _mesh, GRINS::MeshBuilder::do_mesh_refinement_from_input(), GRINS::SimulationBuilder::mesh_builder(), and read_restart().

  {
    this->read_restart( input );

    /* We do this here only if there's a restart file. Otherwise, this was done
       at mesh construction time */
    sim_builder.mesh_builder().do_mesh_refinement_from_input( input, comm, *_mesh );

    /* \todo Any way to tell if the mesh got refined so we don't unnecessarily
       call reinit()? */
    _equation_system->reinit();
  }

void GRINS::Simulation::print_sim_info

(

)

Definition at line 376 of file simulation.C.

References _equation_system, _mesh, _multiphysics_system, _print_constraint_info, _print_equation_system_info, and _print_mesh_info.

Referenced by run().

  {
    // Print mesh info if the user wants it
    if( this->_print_mesh_info )
      this->_mesh->print_info();

    // Print EquationSystems info if requested
    if( this->_print_equation_system_info )
      this->_equation_system->print_info();

    // Print DofMap constraint info if requested
    if( this->_print_constraint_info )
      this->_multiphysics_system->get_dof_map().print_dof_constraints();

    return;
  }

void GRINS::Simulation::read_restart ( const GetPot &  input )

protected

Definition at line 404 of file simulation.C.

References _equation_system, _have_restart, and GRINS::SimulationParsing::restart_file().

Referenced by init_restart().

  {
    const std::string restart_file = SimulationParsing::restart_file(input);

    // Most of this was pulled from FIN-S
    if (restart_file != "none")
      {
        std::cout << " ====== Restarting from " << restart_file << std::endl;

        // Must have correct file type to restart
        if (restart_file.rfind(".xdr") < restart_file.size())
          _equation_system->read(restart_file,GRINSEnums::DECODE,
                                 //libMesh::EquationSystems::READ_HEADER |  // Allow for thermochemistry upgrades
                                 libMesh::EquationSystems::READ_DATA |
                                 libMesh::EquationSystems::READ_ADDITIONAL_DATA);

        else if  (restart_file.rfind(".xda") < restart_file.size())
          _equation_system->read(restart_file,GRINSEnums::READ,
                                 //libMesh::EquationSystems::READ_HEADER |  // Allow for thermochemistry upgrades
                                 libMesh::EquationSystems::READ_DATA |
                                 libMesh::EquationSystems::READ_ADDITIONAL_DATA);

        else
          {
            std::cerr << "Error: Restart filename must have .xdr or .xda extension!" << std::endl;
            libmesh_error();
          }

        this->_have_restart = true;

        const std::string system_name = input("screen-options/system_name", "GRINS" );

        MultiphysicsSystem& system =
          _equation_system->get_system<MultiphysicsSystem>(system_name);

        // Update the old data
        system.update();
      }

    return;
  }

void GRINS::Simulation::run

(

)

Definition at line 267 of file simulation.C.

References _adjoint_parameters, _do_adjoint_solve, _equation_system, _error_estimator, _forward_parameters, _have_restart, _multiphysics_system, _output_adjoint, _output_residual, _output_residual_sensitivities, _output_solution_sensitivities, _output_vis, _postprocessing, _print_log_info, _print_scalars, _qoi_output, _solver, _timesteps_per_perflog, _timesteps_per_vis, _vis, GRINS::SolverContext::do_adjoint_solve, GRINS::SolverContext::equation_system, GRINS::SolverContext::error_estimator, GRINS::SolverContext::have_restart, GRINS::SolverContext::output_adjoint, GRINS::SolverContext::output_residual, GRINS::SolverContext::output_residual_sensitivities, GRINS::SolverContext::output_solution_sensitivities, GRINS::SolverContext::output_vis, GRINS::ParameterManager::parameter_vector, GRINS::SolverContext::postprocessing, GRINS::SolverContext::print_perflog, GRINS::SolverContext::print_scalars, print_sim_info(), GRINS::SolverContext::qoi_output, GRINS::SolverContext::system, GRINS::SolverContext::timesteps_per_perflog, GRINS::SolverContext::timesteps_per_vis, and GRINS::SolverContext::vis.

  {
    this->print_sim_info();

    SolverContext context;
    context.system = _multiphysics_system;
    context.equation_system = _equation_system;
    context.vis = _vis;
    context.output_adjoint = _output_adjoint;
    context.timesteps_per_vis = _timesteps_per_vis;
    context.timesteps_per_perflog = _timesteps_per_perflog;
    context.output_vis = _output_vis;
    context.output_residual = _output_residual;
    context.output_residual_sensitivities = _output_residual_sensitivities;
    context.output_solution_sensitivities = _output_solution_sensitivities;
    context.print_scalars = _print_scalars;
    context.print_perflog = _print_log_info;
    context.postprocessing = _postprocessing;
    context.error_estimator = _error_estimator;
    context.qoi_output = _qoi_output;
    context.do_adjoint_solve = _do_adjoint_solve;
    context.have_restart = _have_restart;

    if (_output_residual_sensitivities &&
        !_forward_parameters.parameter_vector.size())
      {
        std::cout <<
          "Error: output_residual_sensitivities is specified but\n" <<
          "no forward sensitivity parameters have been specified.\n" <<
          std::endl;
        libmesh_error();
      }

    if (_output_solution_sensitivities &&
        !_forward_parameters.parameter_vector.size())
      {
        std::cout <<
          "Error: output_solution_sensitivities is specified but\n" <<
          "no forward sensitivity parameters have been specified.\n" <<
          std::endl;
        libmesh_error();
      }

    _solver->solve( context );

    if (_qoi_output->output_qoi_set())
      {
        _multiphysics_system->assemble_qoi();
        const CompositeQoI * my_qoi = libMesh::cast_ptr<const CompositeQoI*>(this->_multiphysics_system->get_qoi());
        _qoi_output->output_qois(*my_qoi, this->_multiphysics_system->comm() );
      }

    if ( _adjoint_parameters.parameter_vector.size() )
      {
        // Default: "calculate sensitivities for all QoIs"
        libMesh::QoISet qois;

        const libMesh::ParameterVector & params =
          _adjoint_parameters.parameter_vector;

        libMesh::SensitivityData sensitivities
          (qois, *this->_multiphysics_system, params);

        _solver->adjoint_qoi_parameter_sensitivity
          (context, qois, params, sensitivities);

        std::cout << "Adjoint sensitivities:" << std::endl;

        for (unsigned int q=0;
             q != this->_multiphysics_system->qoi.size(); ++q)
          {
            for (unsigned int p=0; p != params.size(); ++p)
              {
                std::cout << "dq" << q << "/dp" << p << " = " <<
                  sensitivities[q][p] << std::endl;
              }
          }
      }

    if ( _forward_parameters.parameter_vector.size() )
      {
        // Default: "calculate sensitivities for all QoIs"
        libMesh::QoISet qois;

        const libMesh::ParameterVector & params =
          _forward_parameters.parameter_vector;

        libMesh::SensitivityData sensitivities
          (qois, *this->_multiphysics_system, params);

        _solver->forward_qoi_parameter_sensitivity
          (context, qois, params, sensitivities);

        std::cout << "Forward sensitivities:" << std::endl;

        for (unsigned int q=0;
             q != this->_multiphysics_system->qoi.size(); ++q)
          {
            for (unsigned int p=0; p != params.size(); ++p)
              {
                std::cout << "dq" << q << "/dp" << p << " = " <<
                  sensitivities[q][p] << std::endl;
              }
          }
      }

    return;
  }

Member Data Documentation

ParameterManager GRINS::Simulation::_adjoint_parameters

protected

Definition at line 155 of file simulation.h.

Referenced by check_for_adjoint_solve(), init_params(), and run().

bool GRINS::Simulation::_do_adjoint_solve

protected

Definition at line 160 of file simulation.h.

Referenced by init_adjoint_solve(), and run().

SharedPtr<libMesh::EquationSystems> GRINS::Simulation::_equation_system

protected

Definition at line 117 of file simulation.h.

Referenced by get_equation_system(), init_multiphysics_system(), init_restart(), print_sim_info(), read_restart(), and run().

SharedPtr<libMesh::ErrorEstimator> GRINS::Simulation::_error_estimator

protected

Definition at line 153 of file simulation.h.

Referenced by build_error_estimator(), and run().

ErrorEstimatorOptions GRINS::Simulation::_error_estimator_options

protected

Definition at line 152 of file simulation.h.

Referenced by build_error_estimator(), and check_for_adjoint_solve().

ParameterManager GRINS::Simulation::_forward_parameters

protected

Definition at line 157 of file simulation.h.

Referenced by init_params(), and run().

bool GRINS::Simulation::_have_restart

protected

Definition at line 162 of file simulation.h.

Referenced by read_restart(), and run().

SharedPtr<libMesh::UnstructuredMesh> GRINS::Simulation::_mesh

protected

Definition at line 115 of file simulation.h.

Referenced by init_restart(), and print_sim_info().

GRINS::MultiphysicsSystem* GRINS::Simulation::_multiphysics_system

protected

Definition at line 125 of file simulation.h.

Referenced by build_error_estimator(), get_multiphysics_system(), get_qoi_value(), init_adjoint_solve(), init_multiphysics_system(), init_params(), init_qois(), print_sim_info(), and run().

bool GRINS::Simulation::_output_adjoint

protected

Definition at line 144 of file simulation.h.

Referenced by run().

bool GRINS::Simulation::_output_residual

protected

Definition at line 145 of file simulation.h.

Referenced by run().

bool GRINS::Simulation::_output_residual_sensitivities

protected

Definition at line 146 of file simulation.h.

Referenced by run().

bool GRINS::Simulation::_output_solution_sensitivities

protected

Definition at line 147 of file simulation.h.

Referenced by run().

bool GRINS::Simulation::_output_vis

protected

Definition at line 143 of file simulation.h.

Referenced by run().

SharedPtr<PostProcessedQuantities<libMesh::Real> > GRINS::Simulation::_postprocessing

protected

Definition at line 129 of file simulation.h.

Referenced by init_multiphysics_system(), and run().

bool GRINS::Simulation::_print_constraint_info

protected

Definition at line 135 of file simulation.h.

Referenced by print_sim_info().

bool GRINS::Simulation::_print_equation_system_info

protected

Definition at line 134 of file simulation.h.

Referenced by print_sim_info().

bool GRINS::Simulation::_print_log_info

protected

Definition at line 133 of file simulation.h.

Referenced by init_multiphysics_system(), and run().

bool GRINS::Simulation::_print_mesh_info

protected

Definition at line 132 of file simulation.h.

Referenced by print_sim_info().

bool GRINS::Simulation::_print_perflog

protected

Definition at line 136 of file simulation.h.

bool GRINS::Simulation::_print_scalars

protected

Definition at line 137 of file simulation.h.

Referenced by run().

SharedPtr<QoIOutput> GRINS::Simulation::_qoi_output

protected

Definition at line 140 of file simulation.h.

Referenced by init_qois(), and run().

libMesh::UniquePtr<GRINS::Solver> GRINS::Simulation::_solver

protected

Definition at line 119 of file simulation.h.

Referenced by build_solver(), init_multiphysics_system(), and run().

std::string GRINS::Simulation::_system_name

protected

GRINS::Multiphysics system name.

Definition at line 122 of file simulation.h.

Referenced by get_multiphysics_system_name().

unsigned int GRINS::Simulation::_timesteps_per_perflog

protected

Definition at line 150 of file simulation.h.

Referenced by run().

unsigned int GRINS::Simulation::_timesteps_per_vis

protected

Definition at line 149 of file simulation.h.

Referenced by run().

SharedPtr<GRINS::Visualization> GRINS::Simulation::_vis

protected

Definition at line 127 of file simulation.h.

Referenced by run().

---

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

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