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...

const PhysicsList &	get_physics_list () const

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::ParameterMultiAccessor< libMesh::Number > &param_pointer)
	Each Physics will register its copy(s) of an independent variable. More...

virtual libMesh::UniquePtr< 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	damping_residual (bool request_jacobian, libMesh::DiffContext &context)
	Contributions to $C(u)\dot{u}$ . 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...

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

SharedPtr< 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)

std::vector< SharedPtr< NeumannBCContainer > > &	get_neumann_bcs ()

const std::vector< SharedPtr< NeumannBCContainer > > &	get_neumann_bcs () const

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)

void	get_active_neumann_bcs (BoundaryID bc_id, const std::vector< SharedPtr< NeumannBCContainer > > &neumann_bcs, std::vector< SharedPtr< NeumannBCContainer > > &active_neumann_bcs)
	Extract the bcs from neumann_bcs that are active on bc_id and return them in active_neumann_bcs. More...

bool	apply_neumann_bcs (bool request_jacobian, libMesh::DiffContext &context)
	Applies the subset of _neumann_bcs that are active on the current element side. More...

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

bool	_use_numerical_jacobians_only

std::vector< std::string >	_numerical_jacobian_h_variables

std::vector< libMesh::Real >	_numerical_jacobian_h_values

const GetPot *	_input
	Cached for helping build boundary conditions. More...

std::vector< SharedPtr< NeumannBCContainer > >	_neumann_bcs
	Neumann boundary conditions. More...

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 82 of file multiphysics_sys.h.

Member Typedef Documentation

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

private

Definition at line 225 of file multiphysics_sys.h.

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

private

Definition at line 224 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 43 of file multiphysics_sys.C.

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

GRINS::MultiphysicsSystem::~MultiphysicsSystem ( )

inline

Destructor. Clean up all physics allocations.

Definition at line 92 of file multiphysics_sys.h.

92 {};

Member Function Documentation

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

private

Definition at line 260 of file multiphysics_sys.C.

References _physics_list, and _use_numerical_jacobians_only.

Referenced by damping_residual(), 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++ )
       {
         // 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;
   }

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

private

Applies the subset of _neumann_bcs that are active on the current element side.

Definition at line 450 of file multiphysics_sys.C.

References _neumann_bcs, _use_numerical_jacobians_only, get_active_neumann_bcs(), GRINS::Physics::is_axisymmetric(), and GRINS::FEVariablesBase::neumann_bc_sign().

Referenced by side_time_derivative().

   {
     AssemblyContext& assembly_context =
       libMesh::libmesh_cast_ref<AssemblyContext&>( context );
 
     std::vector<BoundaryID> ids = assembly_context.side_boundary_ids();
 
     bool compute_jacobian = request_jacobian;
     if( !request_jacobian || _use_numerical_jacobians_only ) compute_jacobian = false;
 
     for( std::vector<BoundaryID>::const_iterator it = ids.begin();
          it != ids.end(); it++ )
       {
         BoundaryID bc_id = *it;
 
         libmesh_assert_not_equal_to(bc_id, libMesh::BoundaryInfo::invalid_id);
 
         // Retreive the NeumannBCContainers that are active on the current bc_id
         std::vector<SharedPtr<NeumannBCContainer> > active_neumann_bcs;
         this->get_active_neumann_bcs( bc_id, _neumann_bcs, active_neumann_bcs );
 
         if( !active_neumann_bcs.empty() )
           {
             typedef std::vector<SharedPtr<NeumannBCContainer> >::iterator BCIt;
 
             for( BCIt container = active_neumann_bcs.begin(); container < active_neumann_bcs.end(); ++container )
               {
                 SharedPtr<NeumannBCAbstract>& func = (*container)->get_func();
 
                 const FEVariablesBase& var = (*container)->get_fe_var();
 
                 func->eval_flux( compute_jacobian, assembly_context,
                                  var.neumann_bc_sign(), Physics::is_axisymmetric() );
               }
           }
       } // end loop over boundary ids
 
     return compute_jacobian;
   }

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

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

Definition at line 50 of file multiphysics_sys.C.

References _physics_list.

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

   {
     _physics_list = physics_list;
   }

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

virtual

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

Definition at line 191 of file multiphysics_sys.C.

   {
     AssemblyContext* context = new AssemblyContext(*this);
 
     libMesh::UniquePtr<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 421 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::damping_residual	(	bool	request_jacobian,
		libMesh::DiffContext &	context
	)

virtual

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

Definition at line 370 of file multiphysics_sys.C.

References _general_residual(), GRINS::Physics::compute_damping_residual_cache(), and GRINS::Physics::damping_residual().

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

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 340 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 304 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);
   }

void GRINS::MultiphysicsSystem::get_active_neumann_bcs	(	BoundaryID	bc_id,
		const std::vector< SharedPtr< NeumannBCContainer > > &	neumann_bcs,
		std::vector< SharedPtr< NeumannBCContainer > > &	active_neumann_bcs
	)

private

Extract the bcs from neumann_bcs that are active on bc_id and return them in active_neumann_bcs.

Definition at line 439 of file multiphysics_sys.C.

Referenced by apply_neumann_bcs().

   {
     // Manually writing the loop since std::copy_if is C++11 only
     for( std::vector<SharedPtr<NeumannBCContainer> >::const_iterator it = neumann_bcs.begin();
          it < neumann_bcs.end(); ++it )
       if( (*it)->has_bc_id( bc_id ) )
           active_neumann_bcs.push_back( *it );
   }

std::vector<SharedPtr<NeumannBCContainer> >& GRINS::MultiphysicsSystem::get_neumann_bcs ( )

inline

Definition at line 179 of file multiphysics_sys.h.

References _neumann_bcs.

180 { return _neumann_bcs; }

GRINS::MultiphysicsSystem::_neumann_bcs

std::vector< SharedPtr< NeumannBCContainer > > _neumann_bcs

Neumann boundary conditions.

Definition: multiphysics_sys.h:217

const std::vector<SharedPtr<NeumannBCContainer> >& GRINS::MultiphysicsSystem::get_neumann_bcs ( ) const

inline

Definition at line 182 of file multiphysics_sys.h.

References _neumann_bcs.

183 { return _neumann_bcs; }

GRINS::MultiphysicsSystem::_neumann_bcs

std::vector< SharedPtr< NeumannBCContainer > > _neumann_bcs

Neumann boundary conditions.

Definition: multiphysics_sys.h:217

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

Definition at line 400 of file multiphysics_sys.C.

References _physics_list.

   {
     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];
   }

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

inline

Definition at line 244 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;
   }

const PhysicsList& GRINS::MultiphysicsSystem::get_physics_list ( ) const

inline

Definition at line 97 of file multiphysics_sys.h.

References _physics_list.

Referenced by GRINS::OldStyleBCBuilder::build_bcs().

98 { return _physics_list; }

GRINS::MultiphysicsSystem::_physics_list

PhysicsList _physics_list

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

Definition: multiphysics_sys.h:195

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

Query to check if a particular physics has been enabled.

Definition at line 411 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 244 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 115 of file multiphysics_sys.C.

References _input, _neumann_bcs, _numerical_jacobian_h_values, _numerical_jacobian_h_variables, _physics_list, and GRINS::BCBuilder::build_boundary_conditions().

   {
     // 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 );
       }
 
     libmesh_assert(_input);
     BCBuilder::build_boundary_conditions(*_input,*this,_neumann_bcs);
 
     // If any variables need custom numerical_jacobian_h, we can set those
     // values now that variable names are all registered with the System
     for (unsigned int i=0; i != _numerical_jacobian_h_values.size(); ++i)
       {
         unsigned int var_num =
           this->variable_number(_numerical_jacobian_h_variables[i]);
         this->set_numerical_jacobian_h_for_var
           (var_num, _numerical_jacobian_h_values[i]);
       }
 
     // 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());
     }
 
     // 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 380 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 360 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 390 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 330 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 55 of file multiphysics_sys.C.

References _input, _numerical_jacobian_h_values, _numerical_jacobian_h_variables, and _use_numerical_jacobians_only.

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

   {
     // Cache this for building boundary condition later
     _input = &input;
 
     // 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);
 
     const unsigned int n_numerical_jacobian_h_values =
       input.vector_variable_size
         ("linear-nonlinear-solver/numerical_jacobian_h_values");
 
     if (n_numerical_jacobian_h_values !=
         input.vector_variable_size
           ("linear-nonlinear-solver/numerical_jacobian_h_variables"))
       {
         std::cerr << "Error: found " << n_numerical_jacobian_h_values
                   << " numerical_jacobian_h_values" << std::endl;
         std::cerr << "  but "
                   << input.vector_variable_size
                        ("linear-nonlinear-solver/numerical_jacobian_h_variables")
                 << " numerical_jacobian_h_variables" << std::endl;
         libmesh_error();
       }
 
     _numerical_jacobian_h_variables.resize(n_numerical_jacobian_h_values);
     _numerical_jacobian_h_values.resize(n_numerical_jacobian_h_values);
     for (unsigned int i=0; i != n_numerical_jacobian_h_values; ++i)
       {
         _numerical_jacobian_h_variables[i] =
           input("linear-nonlinear-solver/numerical_jacobian_h_variables",
                 "", i);
         _numerical_jacobian_h_values[i] =
           input("linear-nonlinear-solver/numerical_jacobian_h_values",
                 libMesh::Real(0), i);
       }
   }

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

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

Definition at line 229 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 215 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 350 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 314 of file multiphysics_sys.C.

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

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

Member Data Documentation

const GetPot* GRINS::MultiphysicsSystem::_input

private

Cached for helping build boundary conditions.

We can't make a copy because it will muck up the UFO detection amongst other things. So, we keep a raw pointer. We don't own this so we MUST not delete.

Definition at line 210 of file multiphysics_sys.h.

Referenced by init_data(), and read_input_options().

std::vector<SharedPtr<NeumannBCContainer> > GRINS::MultiphysicsSystem::_neumann_bcs

private

Neumann boundary conditions.

Store each NeumannBCContainer for each set of BoundaryIDs and Variables, as specified in the input file. The container knows what BoundaryIDs and Variables it applies to. We use SharedPtr here because libMesh::UniquePtr may still actually be an AutoPtr.

Definition at line 217 of file multiphysics_sys.h.

Referenced by apply_neumann_bcs(), get_neumann_bcs(), and init_data().

std::vector<libMesh::Real> GRINS::MultiphysicsSystem::_numerical_jacobian_h_values

private

Definition at line 204 of file multiphysics_sys.h.

Referenced by init_data(), and read_input_options().

std::vector<std::string> GRINS::MultiphysicsSystem::_numerical_jacobian_h_variables

private

Definition at line 201 of file multiphysics_sys.h.

Referenced by init_data(), and read_input_options().

PhysicsList GRINS::MultiphysicsSystem::_physics_list

private