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 void	assembly (bool get_residual, bool get_jacobian, bool apply_heterogeneous_constraints=false, bool apply_no_constraints=false)
	Override FEMSystem::assembly. More...

virtual void	reinit ()
	Override FEMSystem::reinit. 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 &)

typedef void(GRINS::Physics::*	CacheFuncType) (AssemblyContext &)

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

libMesh::UniquePtr< libMesh::System::Constraint >	_constraint
	Constraint application object. 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 77 of file multiphysics_sys.h.

Member Typedef Documentation

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

private

Definition at line 227 of file multiphysics_sys.h.

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

private

Definition at line 226 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 45 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 87 of file multiphysics_sys.h.

87 {};

Member Function Documentation

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

private

Definition at line 306 of file multiphysics_sys.C.

References _physics_list, _use_numerical_jacobians_only, GRINS::CachedValues::clear(), and GRINS::AssemblyContext::get_cached_values().

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::cast_ref<AssemblyContext&>(context);
 
     bool compute_jacobian = true;
     if( !request_jacobian || _use_numerical_jacobians_only ) compute_jacobian = false;
 
     CachedValues & cache = c.get_cached_values();
 
     // 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 );
       }
 
     // 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 );
               }
           }
         else
           {
             ((*(physics_iter->second)).*resfunc)( compute_jacobian, c );
           }
       }
 
     // We need to clear out the cache when we're done so we don't interfere
     // with other residual functions
     cache.clear();
 
     // 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 500 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::cast_ref<AssemblyContext&>( context );
 
     std::vector<BoundaryID> ids;
     assembly_context.side_boundary_ids(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::assembly	(	bool	get_residual,
		bool	get_jacobian,
		bool	apply_heterogeneous_constraints = `false`,
		bool	apply_no_constraints = `false`
	)

virtual

Override FEMSystem::assembly.

This allows us to insert things like preassembly().

Definition at line 269 of file multiphysics_sys.C.

References _physics_list.

Referenced by GRINS::UnsteadyVisualization::output_residual().

   {
     // First do any preassembly that the Physics requires (which by default is none)
     for( PhysicsListIter physics_iter = _physics_list.begin();
          physics_iter != _physics_list.end();
          physics_iter++ )
       (physics_iter->second)->preassembly(*this);
 
     // Now do the assembly
     libMesh::FEMSystem::assembly(get_residual,get_jacobian,
                                  apply_heterogeneous_constraints,
                                  apply_no_constraints);
   }

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

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

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

Referenced by GRINSTesting::SpectroscopicAbsorptionTest::elem_qoi_derivatives().

   {
     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 471 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 420 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 390 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 354 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 489 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 186 of file multiphysics_sys.h.

References _neumann_bcs.

187 { return _neumann_bcs; }

GRINS::MultiphysicsSystem::_neumann_bcs

std::vector< SharedPtr< NeumannBCContainer > > _neumann_bcs

Neumann boundary conditions.

Definition: multiphysics_sys.h:219

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

inline

Definition at line 189 of file multiphysics_sys.h.

References _neumann_bcs.

190 { return _neumann_bcs; }

GRINS::MultiphysicsSystem::_neumann_bcs

std::vector< SharedPtr< NeumannBCContainer > > _neumann_bcs

Neumann boundary conditions.

Definition: multiphysics_sys.h:219

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

Definition at line 450 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 246 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 92 of file multiphysics_sys.h.

References _physics_list.

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

93 { return _physics_list; }

GRINS::MultiphysicsSystem::_physics_list

PhysicsList _physics_list

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

Definition: multiphysics_sys.h:197

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

Query to check if a particular physics has been enabled.

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

References _physics_list.

Referenced by GRINSTesting::SpectroscopicAbsorptionTest::elem_qoi_derivatives().

   {
     AssemblyContext& c = 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 117 of file multiphysics_sys.C.

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

   {
     // 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);
 
     this->_constraint =
       ConstraintBuilder::build_constraint_object(*_input,*this);
 
     this->attach_constraint_object(*this->_constraint);
 
     // 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 430 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 410 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 440 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 380 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 57 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(), and GRINSTesting::SystemHelper::setup_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 236 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 );
       }
 
     for (unsigned int bc=0; bc<_neumann_bcs.size(); bc++)
       _neumann_bcs[bc]->get_func()->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 222 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;
   }

void GRINS::MultiphysicsSystem::reinit ( )

virtual

Override FEMSystem::reinit.

This will allow each Physics to reinit things internally that need it, such as point locators.

Definition at line 286 of file multiphysics_sys.C.

References _physics_list, and GRINS::CompositeQoI::reinit().

Referenced by GRINSTesting::IntegratedFunctionTest::reinit_through_system().

   {
     // First call Parent
     FEMSystem::reinit();
 
     // Now do per Physics reinit (which by default is none)
     for( PhysicsListIter physics_iter = _physics_list.begin();
          physics_iter != _physics_list.end();
          physics_iter++ )
       (physics_iter->second)->reinit(*this);
 
     // And now reinit the QoI
     if (this->qoi.size() > 0)
       {
         libMesh::DifferentiableQoI* diff_qoi = this->get_qoi();
         CompositeQoI* qoi = libMesh::cast_ptr<CompositeQoI*>(diff_qoi);
         qoi->reinit(*this);
       }
   }

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 400 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 364 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

libMesh::UniquePtr<libMesh::System::Constraint> GRINS::MultiphysicsSystem::_constraint

private

Constraint application object.

Definition at line 222 of file multiphysics_sys.h.

Referenced by init_data().

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 212 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 219 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 206 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 203 of file multiphysics_sys.h.

Referenced by init_data(), and read_input_options().

PhysicsList GRINS::MultiphysicsSystem::_physics_list

private