Interface with libMesh for solving Multiphysics problems. More...

#include <multiphysics_sys.h>

Inheritance diagram for GRINS::MultiphysicsSystem:

Collaboration diagram for GRINS::MultiphysicsSystem:

Public Member Functions
	MultiphysicsSystem (libMesh::EquationSystems &es, const std::string &name, const unsigned int number)
	Constructor. Will be called by libMesh only. More...

	~MultiphysicsSystem ()
	Destructor. Clean up all physics allocations. More...

void	attach_physics_list (PhysicsList physics_list)
	PhysicsList gets built by GRINS::PhysicsFactory and attached here. More...

virtual void	read_input_options (const GetPot &input)
	Reads input options for this class and all physics that are enabled. More...

virtual void	init_data ()
	System initialization. Calls each physics implementation of init_variables() More...

void	register_postprocessing_vars (const GetPot &input, PostProcessedQuantities< libMesh::Real > &postprocessing)
	Each Physics will register their postprocessed quantities with this call. More...

void	register_parameter (const std::string &param_name, libMesh::ParameterMultiPointer< libMesh::Number > &param_pointer)
	Each Physics will register its copy(s) of an independent variable. More...

virtual libMesh::AutoPtr< libMesh::DiffContext >	build_context ()
	Override FEMSystem::build_context in order to use our own AssemblyContext. More...

virtual void	init_context (libMesh::DiffContext &context)
	Context initialization. Calls each physics implementation of init_context() More...

virtual bool	element_time_derivative (bool request_jacobian, libMesh::DiffContext &context)
	Element interior contributions to which have time varying components. More...

virtual bool	side_time_derivative (bool request_jacobian, libMesh::DiffContext &context)
	Boundary contributions to which have time varying components. More...

virtual bool	nonlocal_time_derivative (bool request_jacobian, libMesh::DiffContext &context)
	Contributions to on SCALAR variables which have time varying components. More...

virtual bool	element_constraint (bool request_jacobian, libMesh::DiffContext &context)

virtual bool	side_constraint (bool request_jacobian, libMesh::DiffContext &context)
	Boundary contributions to which do not have time varying components. More...

virtual bool	nonlocal_constraint (bool request_jacobian, libMesh::DiffContext &context)
	Contributions to on SCALAR variables which do not have time varying components. More...

virtual bool	mass_residual (bool request_jacobian, libMesh::DiffContext &context)
	Contributions to $M(u)\dot{u}$ . More...

virtual bool	nonlocal_mass_residual (bool request_jacobian, libMesh::DiffContext &context)
	Contributions to $M(u)\dot{u}$ on SCALAR variables. More...

bool	has_physics (const std::string physics_name) const
	Query to check if a particular physics has been enabled. More...

std::tr1::shared_ptr< GRINS::Physics >	get_physics (const std::string physics_name)

std::tr1::shared_ptr< GRINS::Physics >	get_physics (const std::string physics_name) const

virtual void	compute_postprocessed_quantity (unsigned int quantity_index, const AssemblyContext &context, const libMesh::Point &point, libMesh::Real &value)

Private Types
typedef void(GRINS::Physics::*	ResFuncType) (bool, AssemblyContext &, CachedValues &)

typedef void(GRINS::Physics::*	CacheFuncType) (const AssemblyContext &, CachedValues &)

Private Member Functions
bool	_general_residual (bool request_jacobian, libMesh::DiffContext &context, ResFuncType resfunc, CacheFuncType cachefunc)

Private Attributes
PhysicsList	_physics_list
	Container of pointers to GRINS::Physics classes requested at runtime. More...

bool	_use_numerical_jacobians_only

Detailed Description

Interface with libMesh for solving Multiphysics problems.

MultiphysicsSystem (through libMesh::FEMSystem) solves the following equation:

$M(u)\dot{u} = F(u)$

M = mass matrix u = solution vector F = time derivative

Note that for the nonlinear system that is solved for implicit time stepping is:

$M(u_{\theta})(u^n - u^{n+1}) + \Delta t F(u) = 0$

_time_derivative correspond to calculating terms for $F(u)$ _mass_residual correspond to calculating terms for $M(u)\dot{u}$

Definition at line 81 of file multiphysics_sys.h.

Member Typedef Documentation

typedef void(GRINS::Physics::* GRINS::MultiphysicsSystem::CacheFuncType) (const AssemblyContext &, CachedValues &)

private

Definition at line 191 of file multiphysics_sys.h.

typedef void(GRINS::Physics::* GRINS::MultiphysicsSystem::ResFuncType) (bool, AssemblyContext &, CachedValues &)

private

Definition at line 190 of file multiphysics_sys.h.

Constructor & Destructor Documentation

GRINS::MultiphysicsSystem::MultiphysicsSystem	(	libMesh::EquationSystems &	es,
		const std::string &	name,
		const unsigned int	number
	)

Constructor. Will be called by libMesh only.

Definition at line 40 of file multiphysics_sys.C.

     : FEMSystem(es, name, number),
       _use_numerical_jacobians_only(false)
   {
     return;
   }

GRINS::MultiphysicsSystem::~MultiphysicsSystem ( )

Destructor. Clean up all physics allocations.

Definition at line 49 of file multiphysics_sys.C.

   {
     return;
   }

Member Function Documentation

bool GRINS::MultiphysicsSystem::_general_residual	(	bool	request_jacobian,
		libMesh::DiffContext &	context,
		ResFuncType	resfunc,
		CacheFuncType	cachefunc
	)

private

Definition at line 228 of file multiphysics_sys.C.

References _physics_list, and _use_numerical_jacobians_only.

Referenced by element_constraint(), element_time_derivative(), mass_residual(), nonlocal_constraint(), nonlocal_mass_residual(), nonlocal_time_derivative(), side_constraint(), and side_time_derivative().

   {
     AssemblyContext& c = libMesh::libmesh_cast_ref<AssemblyContext&>(context);
   
     bool compute_jacobian = true;
     if( !request_jacobian || _use_numerical_jacobians_only ) compute_jacobian = false;
 
     CachedValues cache;
 
     // Now compute cache for this element
     for( PhysicsListIter physics_iter = _physics_list.begin();
          physics_iter != _physics_list.end();
          physics_iter++ )
       {
         // boost::shared_ptr gets confused by operator->*
         ((*(physics_iter->second)).*cachefunc)( c, cache );
       }
 
     // Loop over each physics and compute their contributions
     for( PhysicsListIter physics_iter = _physics_list.begin();
          physics_iter != _physics_list.end();
          physics_iter++ )
       {
         if(c.has_elem())
           {
             if( (physics_iter->second)->enabled_on_elem( &c.get_elem() ) )
               {
                 ((*(physics_iter->second)).*resfunc)( compute_jacobian, c, cache );
               }
           }
         else
           {
             ((*(physics_iter->second)).*resfunc)( compute_jacobian, c, cache );
           }
       }
 
     // TODO: Need to think about the implications of this because there might be some
     // TODO: jacobian terms we don't want to compute for efficiency reasons
     return compute_jacobian;
   }

void GRINS::MultiphysicsSystem::attach_physics_list ( PhysicsList physics_list )

PhysicsList gets built by GRINS::PhysicsFactory and attached here.

Definition at line 54 of file multiphysics_sys.C.

References _physics_list.

Referenced by GRINS::Simulation::init_multiphysics_system().

   {
     _physics_list = physics_list;
     return;
   }

libMesh::AutoPtr< libMesh::DiffContext > GRINS::MultiphysicsSystem::build_context ( )

virtual

Override FEMSystem::build_context in order to use our own AssemblyContext.

Definition at line 159 of file multiphysics_sys.C.

   {
     AssemblyContext* context = new AssemblyContext(*this);
 
     libMesh::AutoPtr<libMesh::DiffContext> ap(context);
 
     libMesh::DifferentiablePhysics* phys = libMesh::FEMSystem::get_physics();
 
     libmesh_assert(phys);
 
     // If we are solving a moving mesh problem, tell that to the Context
     context->set_mesh_system(phys->get_mesh_system());
     context->set_mesh_x_var(phys->get_mesh_x_var());
     context->set_mesh_y_var(phys->get_mesh_y_var());
     context->set_mesh_z_var(phys->get_mesh_z_var());
 
     ap->set_deltat_pointer( &deltat );
 
     // If we are solving the adjoint problem, tell that to the Context
     ap->is_adjoint() = this->get_time_solver().is_adjoint();
 
     return ap;
   }

void GRINS::MultiphysicsSystem::compute_postprocessed_quantity	(	unsigned int	quantity_index,
		const AssemblyContext &	context,
		const libMesh::Point &	point,
		libMesh::Real &	value
	)

virtual

Definition at line 373 of file multiphysics_sys.C.

References _physics_list.

   {
     for( PhysicsListIter physics_iter = _physics_list.begin();
          physics_iter != _physics_list.end();
          physics_iter++ )
       {
         // Only compute if physics is active on current subdomain or globally
         if( (physics_iter->second)->enabled_on_elem( &context.get_elem() ) )
           {
             (physics_iter->second)->compute_postprocessed_quantity( quantity_index, context, point, value );
           }
       }
     return;
   }

bool GRINS::MultiphysicsSystem::element_constraint	(	bool	request_jacobian,
		libMesh::DiffContext &	context
	)

virtual

Element interior contributions to $F(u)$ which do not have time varying components. Element interior contributions to $F(u)$ which do not have time varying components.

Definition at line 302 of file multiphysics_sys.C.

References _general_residual(), GRINS::Physics::compute_element_constraint_cache(), and GRINS::Physics::element_constraint().

   {
     return this->_general_residual
       (request_jacobian,
        context,
        &GRINS::Physics::element_constraint,
        &GRINS::Physics::compute_element_constraint_cache);
   }

bool GRINS::MultiphysicsSystem::element_time_derivative	(	bool	request_jacobian,
		libMesh::DiffContext &	context
	)

virtual

Element interior contributions to $F(u)$ which have time varying components.

Definition at line 272 of file multiphysics_sys.C.

References _general_residual(), GRINS::Physics::compute_element_time_derivative_cache(), and GRINS::Physics::element_time_derivative().

   {
     return this->_general_residual
       (request_jacobian,
        context,
        &GRINS::Physics::element_time_derivative,
        &GRINS::Physics::compute_element_time_derivative_cache);
   }

std::tr1::shared_ptr< Physics > GRINS::MultiphysicsSystem::get_physics ( const std::string physics_name )

Definition at line 352 of file multiphysics_sys.C.

References _physics_list.

Referenced by GRINS::Simulation::attach_dirichlet_bc_funcs(), and GRINS::Simulation::attach_neumann_bc_funcs().

   {
     if( _physics_list.find( physics_name ) == _physics_list.end() )
       {
         std::cerr << "Error: Could not find physics " << physics_name << std::endl;
         libmesh_error();
       }
 
     return _physics_list[physics_name];
   }

std::tr1::shared_ptr< GRINS::Physics > GRINS::MultiphysicsSystem::get_physics ( const std::string physics_name ) const

inline

Definition at line 201 of file multiphysics_sys.h.

References _physics_list.

   {
     libmesh_assert(_physics_list.find( physics_name ) != _physics_list.end());
 
     return _physics_list.find(physics_name)->second;
   }

bool GRINS::MultiphysicsSystem::has_physics ( const std::string physics_name ) const

Query to check if a particular physics has been enabled.

Definition at line 363 of file multiphysics_sys.C.

References _physics_list.

   {
     bool has_physics = false;
 
     if( _physics_list.find(physics_name) != _physics_list.end() )
       has_physics = true;
 
     return has_physics;
   }

void GRINS::MultiphysicsSystem::init_context ( libMesh::DiffContext & context )

virtual

Context initialization. Calls each physics implementation of init_context()

Definition at line 212 of file multiphysics_sys.C.

References _physics_list.

   {
     AssemblyContext& c = libMesh::libmesh_cast_ref<AssemblyContext&>(context);
 
     //Loop over each physics to initialize relevant variable structures for assembling system
     for( PhysicsListIter physics_iter = _physics_list.begin();
          physics_iter != _physics_list.end();
          physics_iter++ )
       {
         (physics_iter->second)->init_context( c );
       }
 
     return;
   }

void GRINS::MultiphysicsSystem::init_data ( )

virtual

System initialization. Calls each physics implementation of init_variables()

Todo:: Figure out how to tell compilers not to fuse this loop when they want to be aggressive.

Definition at line 88 of file multiphysics_sys.C.

References _physics_list.

   {
     // Need this to be true because of our overloading of the
     // mass_residual function.
     // This is data in FEMSystem. MUST be set before FEMSystem::init_data.
     use_fixed_solution = true;
 
     // Initalize all the variables. We pass this pointer for the system.
     /* NOTE: We CANNOT fuse this loop with the others. This loop
        MUST complete first. */
     for( PhysicsListIter physics_iter = _physics_list.begin();
          physics_iter != _physics_list.end();
          physics_iter++ )
       {
         (physics_iter->second)->init_variables( this );
       }
 
     // Now set time_evolving variables
     for( PhysicsListIter physics_iter = _physics_list.begin();
          physics_iter != _physics_list.end();
          physics_iter++ )
       {
         (physics_iter->second)->set_time_evolving_vars( this );
       }
 
     // Set whether the problem we're solving is steady or not
     // Since the variable is static, just call one Physics class
     {
       (_physics_list.begin()->second)->set_is_steady((this->time_solver)->is_steady());
     }
 
     for( PhysicsListIter physics_iter = _physics_list.begin();
          physics_iter != _physics_list.end();
          physics_iter++ )
       {
         // Initialize builtin BC's for each physics
         (physics_iter->second)->init_bcs( this );
       }
 
     // Next, call parent init_data function to intialize everything.
     libMesh::FEMSystem::init_data();
 
     // After solution has been initialized we can project initial
     // conditions to it
     libMesh::CompositeFunction<libMesh::Number> ic_function;
     for( PhysicsListIter physics_iter = _physics_list.begin();
          physics_iter != _physics_list.end();
          physics_iter++ )
       {
         // Initialize builtin IC's for each physics
         (physics_iter->second)->init_ics( this, ic_function );
       }
 
     if (ic_function.n_subfunctions())
       {
         this->project_solution(&ic_function);
       }
 
     // Now do any auxillary initialization required by each Physics
     for( PhysicsListIter physics_iter = _physics_list.begin();
          physics_iter != _physics_list.end();
          physics_iter++ )
       {
         (physics_iter->second)->auxiliary_init( *this );
       }
 
     return;
   }

bool GRINS::MultiphysicsSystem::mass_residual	(	bool	request_jacobian,
		libMesh::DiffContext &	context
	)

virtual

Contributions to $M(u)\dot{u}$ .

Definition at line 332 of file multiphysics_sys.C.

References _general_residual(), GRINS::Physics::compute_mass_residual_cache(), and GRINS::Physics::mass_residual().

   {
     return this->_general_residual
       (request_jacobian,
        context,
        &GRINS::Physics::mass_residual,
        &GRINS::Physics::compute_mass_residual_cache);
   }

bool GRINS::MultiphysicsSystem::nonlocal_constraint	(	bool	request_jacobian,
		libMesh::DiffContext &	context
	)

virtual

Contributions to $F(u)$ on SCALAR variables which do not have time varying components.

Definition at line 322 of file multiphysics_sys.C.

References _general_residual(), GRINS::Physics::compute_nonlocal_constraint_cache(), and GRINS::Physics::nonlocal_constraint().

   {
     return this->_general_residual
       (request_jacobian,
        context,
        &GRINS::Physics::nonlocal_constraint,
        &GRINS::Physics::compute_nonlocal_constraint_cache);
   }

bool GRINS::MultiphysicsSystem::nonlocal_mass_residual	(	bool	request_jacobian,
		libMesh::DiffContext &	context
	)

virtual

Contributions to $M(u)\dot{u}$ on SCALAR variables.

Definition at line 342 of file multiphysics_sys.C.

References _general_residual(), GRINS::Physics::compute_nonlocal_mass_residual_cache(), and GRINS::Physics::nonlocal_mass_residual().

   {
     return this->_general_residual
       (request_jacobian,
        context,
        &GRINS::Physics::nonlocal_mass_residual,
        &GRINS::Physics::compute_nonlocal_mass_residual_cache);
   }

bool GRINS::MultiphysicsSystem::nonlocal_time_derivative	(	bool	request_jacobian,
		libMesh::DiffContext &	context
	)

virtual

Contributions to $F(u)$ on SCALAR variables which have time varying components.

Definition at line 292 of file multiphysics_sys.C.

References _general_residual(), GRINS::Physics::compute_nonlocal_time_derivative_cache(), and GRINS::Physics::nonlocal_time_derivative().

   {
     return this->_general_residual
       (request_jacobian,
        context,
        &GRINS::Physics::nonlocal_time_derivative,
        &GRINS::Physics::compute_nonlocal_time_derivative_cache);
   }

void GRINS::MultiphysicsSystem::read_input_options ( const GetPot & input )

virtual

Reads input options for this class and all physics that are enabled.

This function reads the input options for the MultiphysicsSystem class and then enables each of the requested physics in the system. Finally, the input options for each of the physics will be read.

Todo:: Remove old print_residual nomenclature

Definition at line 60 of file multiphysics_sys.C.

References _use_numerical_jacobians_only.

Referenced by GRINS::Simulation::init_multiphysics_system().

   {
     // Read options for MultiphysicsSystem first
     this->verify_analytic_jacobians = input("linear-nonlinear-solver/verify_analytic_jacobians", 0.0 );
     this->print_solution_norms = input("screen-options/print_solution_norms", false );
     this->print_solutions = input("screen-options/print_solutions", false );
     this->print_residual_norms = input("screen-options/print_residual_norms", false );
 
     // backwards compatibility with old config files.
     this->print_residuals = input("screen-options/print_residual", false );
     if (this->print_residuals)
       libmesh_deprecated();
 
     this->print_residuals = input("screen-options/print_residuals", this->print_residuals );
     this->print_jacobian_norms = input("screen-options/print_jacobian_norms", false );
     this->print_jacobians = input("screen-options/print_jacobians", false );
     this->print_element_solutions = input("screen-options/print_element_solutions", false );
     this->print_element_residuals = input("screen-options/print_element_residuals", false );
     this->print_element_jacobians = input("screen-options/print_element_jacobians", false );
 
     _use_numerical_jacobians_only = input("linear-nonlinear-solver/use_numerical_jacobians_only", false );
 
     numerical_jacobian_h =
       input("linear-nonlinear-solver/numerical_jacobian_h",
             numerical_jacobian_h);
   }

void GRINS::MultiphysicsSystem::register_parameter	(	const std::string &	param_name,
		libMesh::ParameterMultiPointer< libMesh::Number > &	param_pointer
	)

Each Physics will register its copy(s) of an independent variable.

Definition at line 197 of file multiphysics_sys.C.

Referenced by GRINS::ParameterManager::initialize().

   {
     //Loop over each physics to ask each for the requested parameter
     for( PhysicsListIter physics_iter = _physics_list.begin();
          physics_iter != _physics_list.end();
          physics_iter++ )
       {
         (physics_iter->second)->register_parameter( param_name,
                                                     param_pointer );
       }
   }

void GRINS::MultiphysicsSystem::register_postprocessing_vars	(	const GetPot &	input,
		PostProcessedQuantities< libMesh::Real > &	postprocessing
	)

Each Physics will register their postprocessed quantities with this call.

Definition at line 183 of file multiphysics_sys.C.

References _physics_list.

Referenced by GRINS::Simulation::init_multiphysics_system().

   {
     for( PhysicsListIter physics_iter = _physics_list.begin();
          physics_iter != _physics_list.end();
          physics_iter++ )
       {
         (physics_iter->second)->register_postprocessing_vars( input, postprocessing );
       }
 
     return;
   }

bool GRINS::MultiphysicsSystem::side_constraint	(	bool	request_jacobian,
		libMesh::DiffContext &	context
	)

virtual

Boundary contributions to $F(u)$ which do not have time varying components.

Definition at line 312 of file multiphysics_sys.C.

References _general_residual(), GRINS::Physics::compute_side_constraint_cache(), and GRINS::Physics::side_constraint().

   {
     return this->_general_residual
       (request_jacobian,
        context,
        &GRINS::Physics::side_constraint,
        &GRINS::Physics::compute_side_constraint_cache);
   }

bool GRINS::MultiphysicsSystem::side_time_derivative	(	bool	request_jacobian,
		libMesh::DiffContext &	context
	)

virtual

Boundary contributions to $F(u)$ which have time varying components.

Definition at line 282 of file multiphysics_sys.C.

References _general_residual(), GRINS::Physics::compute_side_time_derivative_cache(), and GRINS::Physics::side_time_derivative().

   {
     return this->_general_residual
       (request_jacobian,
        context,
        &GRINS::Physics::side_time_derivative,
        &GRINS::Physics::compute_side_time_derivative_cache);
   }

Member Data Documentation

PhysicsList GRINS::MultiphysicsSystem::_physics_list

private

Container of pointers to GRINS::Physics classes requested at runtime.

Set using the attach_physics_list method as construction is taken care of by GRINS::PhysicsFactory.

Definition at line 181 of file multiphysics_sys.h.

Referenced by _general_residual(), attach_physics_list(), compute_postprocessed_quantity(), get_physics(), has_physics(), init_context(), init_data(), and register_postprocessing_vars().

bool GRINS::MultiphysicsSystem::_use_numerical_jacobians_only

private

Definition at line 183 of file multiphysics_sys.h.

Referenced by _general_residual(), and read_input_options().

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

src/physics/include/grins/multiphysics_sys.h
src/physics/src/multiphysics_sys.C

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation