#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 ()

std::tr1::shared_ptr< libMesh::EquationSystems >	get_equation_system ()

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	attach_neumann_bc_funcs (std::map< GRINS::PhysicsName, GRINS::NBCContainer > neumann_bcs, GRINS::MultiphysicsSystem *system)

void	attach_dirichlet_bc_funcs (std::multimap< GRINS::PhysicsName, GRINS::DBCContainer > dbc_map, GRINS::MultiphysicsSystem *system)

void	init_multiphysics_system (const GetPot &input, SimulationBuilder &sim_builder)
	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...

void	check_for_unused_vars (const GetPot &input, bool warning_only)
	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...

Protected Attributes
std::tr1::shared_ptr< libMesh::UnstructuredMesh >	_mesh

std::tr1::shared_ptr< libMesh::EquationSystems >	_equation_system

std::tr1::shared_ptr< GRINS::Solver >	_solver

std::string	_system_name
	GRINS::Multiphysics system name. More...

GRINS::MultiphysicsSystem *	_multiphysics_system

std::tr1::shared_ptr< GRINS::Visualization >	_vis

std::tr1::shared_ptr< PostProcessedQuantities< libMesh::Real > >	_postprocessing

bool	_print_mesh_info

bool	_print_log_info

bool	_print_equation_system_info

bool	_print_perflog

bool	_print_qoi

bool	_print_scalars

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

std::tr1::shared_ptr< libMesh::ErrorEstimator >	_error_estimator

ParameterManager	_adjoint_parameters

ParameterManager	_forward_parameters

bool	_do_adjoint_solve

Private Member Functions
	Simulation ()

Detailed Description

Definition at line 62 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
	)

GRINS::Simulation::~Simulation ( )

virtual

Definition at line 140 of file simulation.C.

   {
     return;
   }

GRINS::Simulation::Simulation ( )

private

Member Function Documentation

void GRINS::Simulation::attach_dirichlet_bc_funcs	(	std::multimap< GRINS::PhysicsName, GRINS::DBCContainer >	dbc_map,
		GRINS::MultiphysicsSystem *	system
	)

protected

Definition at line 492 of file simulation.C.

References GRINS::MultiphysicsSystem::get_physics().

Referenced by init_multiphysics_system().

   {
     for( std::multimap< PhysicsName, DBCContainer >::const_iterator it = dbc_map.begin();
          it != dbc_map.end();
          it++ )
       {
         std::tr1::shared_ptr<Physics> physics = system->get_physics( it->first );
 
         physics->attach_dirichlet_bound_func( it->second );
       }
     return;
   }

void GRINS::Simulation::attach_neumann_bc_funcs	(	std::map< GRINS::PhysicsName, GRINS::NBCContainer >	neumann_bcs,
		GRINS::MultiphysicsSystem *	system
	)

protected

Definition at line 473 of file simulation.C.

References GRINS::MultiphysicsSystem::get_physics().

Referenced by init_multiphysics_system().

   {
     //_neumann_bc_funcs = neumann_bcs;
 
     if( neumann_bcs.size() > 0 )
       {
         for( std::map< std::string, NBCContainer >::iterator bc = neumann_bcs.begin();
              bc != neumann_bcs.end();
              bc++ )
           {
             std::tr1::shared_ptr<Physics> physics = system->get_physics( bc->first );
             physics->attach_neumann_bound_func( bc->second );
           }
       }
 
     return;
   }

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

protected

Helper function.

Todo:: We need to collect these options into one spot

Todo:: This option name WILL change at some point.

Definition at line 529 of file simulation.C.

Referenced by init_adjoint_solve().

   {
     std::string error_estimator = input("MeshAdaptivity/estimator_type", "none");
 
     bool do_adjoint_solve = false;
 
     // First check if the error estimator requires an adjoint solve
     if( error_estimator.find("adjoint") != std::string::npos )
       {
         do_adjoint_solve = true;
       }
 
     // Now check if the user requested to do an adjoint solve regardless
     if( input( "linear-nonlinear-solver/do_adjoint_solve", false ) )
       {
         do_adjoint_solve = true;
       }
 
     return do_adjoint_solve;
   }

void GRINS::Simulation::check_for_unused_vars	(	const GetPot &	input,
		bool	warning_only
	)

protected

Helper function.

Definition at line 273 of file simulation.C.

   {
     /* Everything should be set up now, so check if there's any unused variables
        in the input file. If so, then tell the user what they were and error out. */
     std::vector<std::string> unused_vars = input.unidentified_variables();
 
     if( !unused_vars.empty() )
       {
         libMesh::err << "==========================================================" << std::endl;
         if( warning_only )
           libMesh::err << "Warning: ";
         else
           libMesh::err << "Error: ";
 
         libMesh::err << "Found unused variables!" << std::endl;
 
         for( std::vector<std::string>::const_iterator it = unused_vars.begin();
              it != unused_vars.end(); ++it )
           {
             libMesh::err << *it << std::endl;
           }
         libMesh::err << "==========================================================" << std::endl;
 
         if( !warning_only )
           libmesh_error();
       }
 
     return;
   }

std::tr1::shared_ptr< libMesh::EquationSystems > GRINS::Simulation::get_equation_system ( )

Definition at line 422 of file simulation.C.

References _equation_system.

Referenced by main().

   {
     return _equation_system;
   }

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

inline

Definition at line 176 of file simulation.h.

References _system_name.

   {
     return this->_system_name;
   }

libMesh::Number GRINS::Simulation::get_qoi_value ( unsigned int qoi_index ) const

Definition at line 427 of file simulation.C.

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

   {
     const CompositeQoI* qoi = libMesh::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 506 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,
		SimulationBuilder &	sim_builder
	)

protected

Helper function.

Definition at line 145 of file simulation.C.

References _equation_system, _multiphysics_system, _postprocessing, _print_log_info, _solver, attach_dirichlet_bc_funcs(), attach_neumann_bc_funcs(), GRINS::MultiphysicsSystem::attach_physics_list(), GRINS::SimulationBuilder::build_dirichlet_bcs(), GRINS::SimulationBuilder::build_neumann_bcs(), GRINS::SimulationBuilder::build_physics(), 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();
 
     PhysicsList physics_list = sim_builder.build_physics(input);
 
     _multiphysics_system->attach_physics_list( physics_list );
 
     _multiphysics_system->read_input_options( input );
 
     _multiphysics_system->register_postprocessing_vars( input, *(_postprocessing) );
 
     // This *must* be done before equation_system->init
     this->attach_dirichlet_bc_funcs( sim_builder.build_dirichlet_bcs(), _multiphysics_system );
 
     /* 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
     this->attach_neumann_bc_funcs( sim_builder.build_neumann_bcs( *_equation_system ), _multiphysics_system );
 
     return;
   }

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

protected

Helper function.

Definition at line 204 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 181 of file simulation.C.

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

   {
     // If the user actually asks for a QoI, then we add it.
     std::tr1::shared_ptr<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 (_print_qoi)
       {
         std::cout << "Error: print_qoi is specified but\n" <<
           "no QoIs have been specified.\n" << std::endl;
         libmesh_error();
       }
 
     return;
   }

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

protected

Helper function.

Definition at line 257 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();
 
     return;
   }

void GRINS::Simulation::print_sim_info ( )

Definition at line 411 of file simulation.C.

References _equation_system, _mesh, _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 info if requested
     if( this->_print_equation_system_info ) this->_equation_system->print_info();
 
     return;
   }

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

protected

Definition at line 433 of file simulation.C.

References _equation_system.

Referenced by init_restart().

   {
     const std::string restart_file = input( "restart-options/restart_file", "none" );
 
     // 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();
           }
       
         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 303 of file simulation.C.

Referenced by main(), and run().

   {
     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.print_qoi = _print_qoi;
     context.do_adjoint_solve = _do_adjoint_solve;
 
     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 ( this->_print_qoi )
       {
         _multiphysics_system->assemble_qoi();
         const CompositeQoI* my_qoi = libMesh::libmesh_cast_ptr<const CompositeQoI*>(this->_multiphysics_system->get_qoi());
         my_qoi->output_qoi( std::cout );
       }
 
     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 162 of file simulation.h.

Referenced by init_params(), and run().

bool GRINS::Simulation::_do_adjoint_solve

protected

Definition at line 167 of file simulation.h.

Referenced by init_adjoint_solve(), and run().

std::tr1::shared_ptr<libMesh::EquationSystems> GRINS::Simulation::_equation_system

protected

Definition at line 128 of file simulation.h.

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

std::tr1::shared_ptr<libMesh::ErrorEstimator> GRINS::Simulation::_error_estimator

protected

Definition at line 160 of file simulation.h.

Referenced by run().

ParameterManager GRINS::Simulation::_forward_parameters

protected

Definition at line 164 of file simulation.h.

Referenced by init_params(), and run().

std::tr1::shared_ptr<libMesh::UnstructuredMesh> GRINS::Simulation::_mesh

protected

Definition at line 126 of file simulation.h.

Referenced by init_restart(), and print_sim_info().

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

protected

Definition at line 136 of file simulation.h.

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

bool GRINS::Simulation::_output_adjoint

protected

Definition at line 152 of file simulation.h.

Referenced by run().

bool GRINS::Simulation::_output_residual

protected

Definition at line 153 of file simulation.h.

Referenced by run().

bool GRINS::Simulation::_output_residual_sensitivities

protected

Definition at line 154 of file simulation.h.

Referenced by run().

bool GRINS::Simulation::_output_solution_sensitivities

protected

Definition at line 155 of file simulation.h.

Referenced by run().

bool GRINS::Simulation::_output_vis

protected

Definition at line 151 of file simulation.h.

Referenced by run().

std::tr1::shared_ptr<PostProcessedQuantities<libMesh::Real> > GRINS::Simulation::_postprocessing

protected

Definition at line 140 of file simulation.h.

Referenced by init_multiphysics_system(), and run().

bool GRINS::Simulation::_print_equation_system_info

protected

Definition at line 145 of file simulation.h.

Referenced by print_sim_info().

bool GRINS::Simulation::_print_log_info

protected

Definition at line 144 of file simulation.h.

Referenced by init_multiphysics_system(), and run().

bool GRINS::Simulation::_print_mesh_info

protected

Definition at line 143 of file simulation.h.

Referenced by print_sim_info().

bool GRINS::Simulation::_print_perflog

protected

Definition at line 146 of file simulation.h.

bool GRINS::Simulation::_print_qoi

protected

Definition at line 147 of file simulation.h.

Referenced by init_qois(), and run().

bool GRINS::Simulation::_print_scalars

protected

Definition at line 148 of file simulation.h.

Referenced by run().

std::tr1::shared_ptr<GRINS::Solver> GRINS::Simulation::_solver

protected

Definition at line 130 of file simulation.h.

Referenced by init_multiphysics_system(), and run().

std::string GRINS::Simulation::_system_name

protected

GRINS::Multiphysics system name.

Definition at line 133 of file simulation.h.

Referenced by get_multiphysics_system_name().

unsigned int GRINS::Simulation::_timesteps_per_perflog

protected

Definition at line 158 of file simulation.h.

Referenced by run().

unsigned int GRINS::Simulation::_timesteps_per_vis

protected

Definition at line 157 of file simulation.h.

Referenced by run().

std::tr1::shared_ptr<GRINS::Visualization> GRINS::Simulation::_vis

protected

Definition at line 138 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

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation