Base class for reading and handling boundary conditions for physics classes. More...

#include <inc_navier_stokes_bc_handling.h>

Inheritance diagram for GRINS::IncompressibleNavierStokesBCHandling:

Collaboration diagram for GRINS::IncompressibleNavierStokesBCHandling:

Public Member Functions
	IncompressibleNavierStokesBCHandling (const std::string &physics_name, const GetPot &input)

virtual	~IncompressibleNavierStokesBCHandling ()

virtual int	string_to_int (const std::string &bc_type_in) const

virtual void	init_bc_data (const libMesh::FEMSystem &system)
	Override this method to initialize any system-dependent data. More...

virtual void	init_bc_types (const GRINS::BoundaryID bc_id, const std::string &bc_id_string, const int bc_type, const std::string &bc_vars, const std::string &bc_value, const GetPot &input)

virtual void	user_init_dirichlet_bcs (libMesh::FEMSystem *system, libMesh::DofMap &dof_map, GRINS::BoundaryID bc_id, GRINS::BCType bc_type) const

void	attach_neumann_bound_func (GRINS::NBCContainer &neumann_bcs)

void	attach_dirichlet_bound_func (const GRINS::DBCContainer &dirichlet_bc)

virtual void	read_bc_data (const GetPot &input, const std::string &id_str, const std::string &bc_str, const std::string &var_str, const std::string &val_str)

virtual void	apply_neumann_bcs (AssemblyContext &context, const GRINS::CachedValues &cache, const bool request_jacobian, const GRINS::BoundaryID bc_id) const

virtual void	user_apply_neumann_bcs (AssemblyContext &context, const GRINS::CachedValues &cache, const bool request_jacobian, const GRINS::BoundaryID bc_id, const GRINS::BCType bc_type) const

virtual void	init_dirichlet_bc_func_objs (libMesh::FEMSystem *system) const

virtual void	init_periodic_bcs (libMesh::FEMSystem *system) const

void	set_dirichlet_bc_type (GRINS::BoundaryID bc_id, int bc_type)

void	set_neumann_bc_type (GRINS::BoundaryID bc_id, int bc_type)

void	set_dirichlet_bc_value (GRINS::BoundaryID bc_id, libMesh::Real value, int component=0)

void	set_neumann_bc_value (GRINS::BoundaryID bc_id, const libMesh::Point &q_in)

libMesh::Real	get_dirichlet_bc_value (GRINS::BoundaryID bc_id, int component=0) const

const libMesh::Point &	get_neumann_bc_value (GRINS::BoundaryID bc_id) const

std::tr1::shared_ptr< GRINS::NeumannFuncObj >	get_neumann_bound_func (GRINS::BoundaryID bc_id, GRINS::VariableIndex var_id) const

std::tr1::shared_ptr< GRINS::NeumannFuncObj >	get_neumann_bound_func (GRINS::BoundaryID bc_id, GRINS::VariableIndex var_id)

virtual void	init_dirichlet_bcs (libMesh::FEMSystem *system) const

GRINS::BCType	get_dirichlet_bc_type (const GRINS::BoundaryID bc_id) const

bool	is_axisymmetric () const

Protected Types
enum	BC_BASE { PERIODIC = -5, CONSTANT_DIRICHLET, PARSED_DIRICHLET, PARSED_FEM_DIRICHLET, AXISYMMETRIC }

Protected Attributes
PrimitiveFlowVariables	_flow_vars

std::vector< std::pair< BoundaryID, BCType > >	_dirichlet_bc_map
	Map between boundary id and Dirichlet boundary condition type. More...

std::map< GRINS::BoundaryID, GRINS::BCType >	_neumann_bc_map
	Map between boundary id and Neumann boundary condition type. More...

std::map< GRINS::BoundaryID, libMesh::Point >	_dirichlet_values
	Stash prescribed Dirichlet boundary values. More...

std::map< GRINS::BoundaryID, libMesh::Point >	_q_values
	Stash prescribed boundary fluxes. More...

std::map< GRINS::BoundaryID, GRINS::NBCContainer >	_neumann_bound_funcs

std::vector< GRINS::DBCContainer >	_dirichlet_bound_funcs

GRINS::BoundaryConditions	_bound_conds
	Object that stashes generic boundary condition types. More...

std::vector< GRINS::PBCContainer >	_periodic_bcs

unsigned int	_num_periodic_bcs

std::string	_physics_name

Static Protected Attributes
static bool	_axisymmetric = false
	Flag to cache whether or not there is an axisymmetric boundary present. More...

Private Types
enum	INS_BC_TYPES { NO_SLIP =1, PRESCRIBED_VELOCITY, PARABOLIC_PROFILE, GENERAL_VELOCITY }

Private Member Functions
	IncompressibleNavierStokesBCHandling ()

Detailed Description

Base class for reading and handling boundary conditions for physics classes.

Definition at line 35 of file inc_navier_stokes_bc_handling.h.

Member Enumeration Documentation

enum GRINS::BCHandlingBase::BC_BASE

protectedinherited

Enumerator
PERIODIC
CONSTANT_DIRICHLET
PARSED_DIRICHLET
PARSED_FEM_DIRICHLET
AXISYMMETRIC

Definition at line 163 of file bc_handling_base.h.

                 { PERIODIC = -5,
                   CONSTANT_DIRICHLET,
                   PARSED_DIRICHLET,
                   PARSED_FEM_DIRICHLET,
                   AXISYMMETRIC };

enum GRINS::IncompressibleNavierStokesBCHandling::INS_BC_TYPES

private

Enumerator
NO_SLIP
PRESCRIBED_VELOCITY
PARABOLIC_PROFILE
GENERAL_VELOCITY

Definition at line 68 of file inc_navier_stokes_bc_handling.h.

                      {NO_SLIP=1, 
                       PRESCRIBED_VELOCITY, 
                       PARABOLIC_PROFILE,
                       GENERAL_VELOCITY};

Constructor & Destructor Documentation

GRINS::IncompressibleNavierStokesBCHandling::IncompressibleNavierStokesBCHandling	(	const std::string &	physics_name,
		const GetPot &	input
	)

Definition at line 41 of file inc_navier_stokes_bc_handling.C.

References GRINS::BCHandlingBase::_physics_name, and GRINS::BCHandlingBase::read_bc_data().

     : BCHandlingBase(physics_name),
       _flow_vars(input)
   {
     std::string id_str = "Physics/"+_physics_name+"/bc_ids";
     std::string bc_str = "Physics/"+_physics_name+"/bc_types";
     std::string var_str = "Physics/"+_physics_name+"/bc_variables";
     std::string val_str = "Physics/"+_physics_name+"/bc_values";
 
     this->read_bc_data( input, id_str, bc_str, var_str, val_str );
 
     return;
   }

GRINS::IncompressibleNavierStokesBCHandling::~IncompressibleNavierStokesBCHandling ( )

virtual

Definition at line 56 of file inc_navier_stokes_bc_handling.C.

   {
     return;
   }

GRINS::IncompressibleNavierStokesBCHandling::IncompressibleNavierStokesBCHandling ( )

private

Member Function Documentation

void GRINS::BCHandlingBase::apply_neumann_bcs	(	AssemblyContext &	context,
		const GRINS::CachedValues &	cache,
		const bool	request_jacobian,
		const GRINS::BoundaryID	bc_id
	)		const

virtualinherited

Definition at line 234 of file bc_handling_base.C.

References GRINS::BCHandlingBase::_neumann_bc_map, and GRINS::BCHandlingBase::user_apply_neumann_bcs().

   {
     std::map< BoundaryID, BCType>::const_iterator 
       bc_map_it = _neumann_bc_map.find( bc_id );
 
     /* We assume that if you didn't put a boundary id in, then you didn't want to
        set a boundary condition on that boundary. */
     if( bc_map_it != _neumann_bc_map.end() )
       {
         this->user_apply_neumann_bcs( context, cache, request_jacobian,
                                       bc_id, bc_map_it->second );
       }
     return;
   }

void GRINS::BCHandlingBase::attach_dirichlet_bound_func ( const GRINS::DBCContainer & dirichlet_bc )

inherited

Definition at line 67 of file bc_handling_base.C.

References GRINS::BCHandlingBase::_dirichlet_bound_funcs.

Referenced by GRINS::Physics::attach_dirichlet_bound_func(), GRINS::LowMachNavierStokesBCHandling::init_bc_types(), init_bc_types(), and GRINS::BCHandlingBase::init_bc_types().

   {
     _dirichlet_bound_funcs.push_back( dirichlet_bc );
     return;
   }

void GRINS::BCHandlingBase::attach_neumann_bound_func ( GRINS::NBCContainer & neumann_bcs )

inherited

Definition at line 61 of file bc_handling_base.C.

References GRINS::BCHandlingBase::_neumann_bound_funcs, and GRINS::NBCContainer::get_bc_id().

Referenced by GRINS::Physics::attach_neumann_bound_func().

   {
     _neumann_bound_funcs.insert( std::make_pair( neumann_bcs.get_bc_id(), neumann_bcs ) );
     return;
   }

GRINS::BCType GRINS::BCHandlingBase::get_dirichlet_bc_type ( const GRINS::BoundaryID bc_id ) const

inlineinherited

Definition at line 207 of file bc_handling_base.h.

References GRINS::BCHandlingBase::_dirichlet_bc_map.

   {
     BCType bc_type_out = -100;
 
     for( std::vector<std::pair<BoundaryID,BCType> >::const_iterator it = _dirichlet_bc_map.begin();
          it != _dirichlet_bc_map.end(); it++ )
       {
         if( it->first == bc_id ) bc_type_out = it->second;
       }
 
     libmesh_assert_not_equal_to( bc_type_out, -100 );
 
     return bc_type_out;
   }

libMesh::Real GRINS::BCHandlingBase::get_dirichlet_bc_value	(	GRINS::BoundaryID	bc_id,
		int	component = `0`
	)		const

inherited

Definition at line 273 of file bc_handling_base.C.

Referenced by GRINS::HeatTransferBCHandling::user_init_dirichlet_bcs(), GRINS::LowMachNavierStokesBCHandling::user_init_dirichlet_bcs(), user_init_dirichlet_bcs(), GRINS::SolidMechanicsBCHandling::user_init_dirichlet_bcs(), and GRINS::AxisymmetricHeatTransferBCHandling::user_init_dirichlet_bcs().

   {
     return (_dirichlet_values.find(bc_id)->second)(component);
   }

const libMesh::Point & GRINS::BCHandlingBase::get_neumann_bc_value ( GRINS::BoundaryID bc_id ) const

inlineinherited

Definition at line 185 of file bc_handling_base.h.

References GRINS::BCHandlingBase::_q_values.

Referenced by GRINS::AxisymmetricHeatTransferBCHandling::user_apply_neumann_bcs(), GRINS::HeatTransferBCHandling::user_apply_neumann_bcs(), and GRINS::SolidMechanicsBCHandling::user_apply_neumann_bcs().

   {
     return (_q_values.find(bc_id))->second;
   }

std::tr1::shared_ptr< GRINS::NeumannFuncObj > GRINS::BCHandlingBase::get_neumann_bound_func	(	GRINS::BoundaryID	bc_id,
		GRINS::VariableIndex	var_id
	)		const

inlineinherited

Definition at line 192 of file bc_handling_base.h.

References GRINS::BCHandlingBase::_neumann_bound_funcs.

Referenced by GRINS::AxisymmetricHeatTransferBCHandling::user_apply_neumann_bcs(), and GRINS::HeatTransferBCHandling::user_apply_neumann_bcs().

   {
     return ((_neumann_bound_funcs.find(bc_id))->second).get_func(var_id);
   }

std::tr1::shared_ptr< GRINS::NeumannFuncObj > GRINS::BCHandlingBase::get_neumann_bound_func	(	GRINS::BoundaryID	bc_id,
		GRINS::VariableIndex	var_id
	)

inlineinherited

Definition at line 200 of file bc_handling_base.h.

References GRINS::BCHandlingBase::_neumann_bound_funcs.

   {
     return ((_neumann_bound_funcs.find(bc_id))->second).get_func(var_id);
   }

void GRINS::IncompressibleNavierStokesBCHandling::init_bc_data ( const libMesh::FEMSystem & system )

virtual

Override this method to initialize any system-dependent data.

Override this method to, for example, cache a System variable number. This is called before any of the other init methods in this class. By default, does nothing.

Reimplemented from GRINS::BCHandlingBase.

Definition at line 86 of file inc_navier_stokes_bc_handling.C.

References _flow_vars, and GRINS::PrimitiveFlowVariables::init().

   {
     _flow_vars.init(const_cast<libMesh::FEMSystem*>(&system));
 
     return;
   }

void GRINS::IncompressibleNavierStokesBCHandling::init_bc_types	(	const GRINS::BoundaryID	bc_id,
		const std::string &	bc_id_string,
		const int	bc_type,
		const std::string &	bc_vars,
		const std::string &	bc_value,
		const GetPot &	input
	)

virtual

Reimplemented from GRINS::BCHandlingBase.

Definition at line 93 of file inc_navier_stokes_bc_handling.C.

References GRINS::BCHandlingBase::_physics_name, GRINS::DBCContainer::add_bc_id(), GRINS::DBCContainer::add_var_name(), GRINS::BCHandlingBase::attach_dirichlet_bound_func(), GRINS::BCHandlingBase::AXISYMMETRIC, GENERAL_VELOCITY, GRINS::BCHandlingBase::init_bc_types(), NO_SLIP, PARABOLIC_PROFILE, PRESCRIBED_VELOCITY, GRINS::BCHandlingBase::set_dirichlet_bc_type(), GRINS::BCHandlingBase::set_dirichlet_bc_value(), and GRINS::DBCContainer::set_func().

   {
     switch(bc_type)
       {
       case(NO_SLIP):
         {
           this->set_dirichlet_bc_type( bc_id, bc_type );
         }
         break;
       case(PRESCRIBED_VELOCITY):
         {
           this->set_dirichlet_bc_type( bc_id, bc_type );
         
           /* Force the user to specify 3 velocity components regardless of dimension.
              This should make it easier to keep things correct if we want to have 
              2D flow not be in the x-y plane. */
           int n_vel_comps = input.vector_variable_size("Physics/"+_physics_name+"/bound_vel_"+bc_id_string);
           if( n_vel_comps != 3 )
             {
               std::cerr << "Error: Must specify 3 velocity components when inputting"
                         << std::endl
                         << "       prescribed velocities. Found " << n_vel_comps
                         << " velocity components."
                         << std::endl;
               libmesh_error();
             }
         
           this->set_dirichlet_bc_value( bc_id, 
                                         input("Physics/"+_physics_name+"/bound_vel_"+bc_id_string, 0.0, 0 ),
                                         0 );
 
           this->set_dirichlet_bc_value( bc_id, 
                                         input("Physics/"+_physics_name+"/bound_vel_"+bc_id_string, 0.0, 1 ),
                                         1 );
 
 #if LIBMESH_DIM > 2
           this->set_dirichlet_bc_value( bc_id, 
                                         input("Physics/"+_physics_name+"/bound_vel_"+bc_id_string, 0.0, 2 ),
                                         2 );
 #endif
         }
         break;
       case(PARABOLIC_PROFILE):
         {
           this->set_dirichlet_bc_type( bc_id, bc_type );
         
           // Make sure all 6 components are there
           if( input.vector_variable_size("Physics/"+_physics_name+"/parabolic_profile_coeffs_"+bc_id_string) != 6 )
             {
               std::cerr << "Error: Must specify 6 components when inputting"
                         << std::endl
                         << "       coefficients for a parabolic profile. Found " 
                         << input.vector_variable_size("Physics/"+_physics_name+"/parabolic_profile_"+bc_id_string)
                         << " components."
                         << std::endl;
               libmesh_error();
             }
 
           libMesh::Real a = input( "Physics/"+_physics_name+"/parabolic_profile_coeffs_"+bc_id_string, 0.0, 0 );
           libMesh::Real b = input( "Physics/"+_physics_name+"/parabolic_profile_coeffs_"+bc_id_string, 0.0, 1 );
           libMesh::Real c = input( "Physics/"+_physics_name+"/parabolic_profile_coeffs_"+bc_id_string, 0.0, 2 );
           libMesh::Real d = input( "Physics/"+_physics_name+"/parabolic_profile_coeffs_"+bc_id_string, 0.0, 3 );
           libMesh::Real e = input( "Physics/"+_physics_name+"/parabolic_profile_coeffs_"+bc_id_string, 0.0, 4 );
           libMesh::Real f = input( "Physics/"+_physics_name+"/parabolic_profile_coeffs_"+bc_id_string, 0.0, 5 );
 
           std::string var = input( "Physics/"+_physics_name+"/parabolic_profile_var_"+bc_id_string, "DIE!" );
         
           if( var == "DIE!" )
             {
               std::cerr << "Error: Mush specify a variable name to which apply parabolic profile through parabolic_profile_var input option." << std::endl;
               libmesh_error();
             }
 
           DBCContainer cont;
           cont.add_var_name( var );
           cont.add_bc_id( bc_id );
 
           std::tr1::shared_ptr<libMesh::FunctionBase<libMesh::Number> > func( new ParabolicProfile(a,b,c,d,e,f) );
           cont.set_func( func );
           this->attach_dirichlet_bound_func( cont );
         
           // Set specified components of Dirichlet data to zero
           std::string fix_var = input( "Physics/"+_physics_name+"/parabolic_profile_fix_"+bc_id_string, "DIE!" );
 
           if( fix_var == "DIE!" )
             {
               std::cerr << "Error: Mush specify a variable name to fix for parabolic profile through parabolic_profile_fix input option." << std::endl;
               libmesh_error();
             }
 
           DBCContainer cont_fix;
           cont_fix.add_var_name( fix_var );
           cont_fix.add_bc_id( bc_id );
 
           std::tr1::shared_ptr<libMesh::FunctionBase<libMesh::Number> >
             func_fix( new libMesh::ZeroFunction<libMesh::Number>() );
           cont_fix.set_func( func_fix );
           this->attach_dirichlet_bound_func( cont_fix );
         }
         break;
 
       case(GENERAL_VELOCITY):
         {
           this->set_dirichlet_bc_type( bc_id, bc_type );
         }
         break;
 
       case(AXISYMMETRIC):
         {
           this->set_dirichlet_bc_type( bc_id, bc_type );
         }
         break;
 
       default:
         {
           // Call base class to detect any physics-common boundary conditions
           BCHandlingBase::init_bc_types( bc_id, bc_id_string, bc_type,
                                          bc_vars, bc_value, input );
         }
       } // End switch(bc_type)
   
     return;
   }

void GRINS::BCHandlingBase::init_dirichlet_bc_func_objs ( libMesh::FEMSystem * system ) const

virtualinherited

Definition at line 116 of file bc_handling_base.C.

References GRINS::BCHandlingBase::_dirichlet_bound_funcs.

Referenced by GRINS::Physics::init_bcs().

   {
     libMesh::DofMap& dof_map = system->get_dof_map();
 
     for( std::vector< DBCContainer >::const_iterator 
            it = _dirichlet_bound_funcs.begin();
          it != _dirichlet_bound_funcs.end();
          it++ )
       {
         // First, get variable names. We convert them to variable ids,
         // both to tell the DirichletBoundary what variables to
         // project and to tell the CompositeFunction what remapping to
         // do.
         std::vector<VariableName> var_names = (*it).get_var_names();
       
         std::vector<VariableIndex> dbc_vars;
 
         for( std::vector<VariableName>::const_iterator name = var_names.begin();
              name != var_names.end();
              name++ )
           {
             dbc_vars.push_back( system->variable_number( *name ) );
           }
       
         // Get bc_id's
         std::set<BoundaryID> bc_ids = (*it).get_bc_ids();
       
         // Get Dirichlet bc functor
         std::tr1::shared_ptr<libMesh::FunctionBase<libMesh::Number> >
           func = (*it).get_func();
 
         // Remap indices as necessary
         if (func.get())
           {
             libMesh::CompositeFunction<libMesh::Number> remapped_func;
             remapped_func.attach_subfunction(*func, dbc_vars);
 
             // Now create DirichletBoundary object and give it to libMesh
             // libMesh makes it own copy of the DirichletBoundary so we can
             // let this one die.
             libMesh::DirichletBoundary dbc( bc_ids, dbc_vars,
                                             remapped_func );
       
             dof_map.add_dirichlet_boundary( dbc );
           }
         else
           {
             // Get Dirichlet bc functor
             const std::string& func_string = (*it).get_fem_func_string();
 
             libmesh_assert_not_equal_to(func_string, "");
 
             // Need to belatedly create Dirichlet functor since we
             // didn't have a System object handy until now.
             libMesh::ParsedFEMFunction<libMesh::Number>
               func(*system, func_string);
 
             libMesh::CompositeFEMFunction<libMesh::Number> remapped_func;
             remapped_func.attach_subfunction(func, dbc_vars);
 
             // Now create DirichletBoundary object and give it to libMesh
             // libMesh makes it own copy of the DirichletBoundary so we can
             // let this one die.
             libMesh::DirichletBoundary dbc( bc_ids, dbc_vars,
                                             *system,
                                             remapped_func );
       
             dof_map.add_dirichlet_boundary( dbc );
           }
       }
 
     return;
   }

void GRINS::BCHandlingBase::init_dirichlet_bcs ( libMesh::FEMSystem * system ) const

virtualinherited

Reimplemented in GRINS::ReactingLowMachNavierStokesBCHandling< Chemistry >, and GRINS::LowMachNavierStokesBCHandling.

Definition at line 190 of file bc_handling_base.C.

References GRINS::BCHandlingBase::_dirichlet_bc_map, and GRINS::BCHandlingBase::user_init_dirichlet_bcs().

Referenced by GRINS::Physics::init_bcs().

   {
     libMesh::DofMap& dof_map = system->get_dof_map();
 
     for( std::vector<std::pair<BoundaryID,BCType> >::const_iterator it = _dirichlet_bc_map.begin();
          it != _dirichlet_bc_map.end(); it++ )
       {
         this->user_init_dirichlet_bcs( system, dof_map, it->first, it->second );
       }
 
     return;
   }

void GRINS::BCHandlingBase::init_periodic_bcs ( libMesh::FEMSystem * system ) const

virtualinherited

Definition at line 203 of file bc_handling_base.C.

References GRINS::BCHandlingBase::_num_periodic_bcs, and GRINS::BCHandlingBase::_periodic_bcs.

Referenced by GRINS::Physics::init_bcs().

   {
     /* Consistency check required to make sure user actually set periodic bc data.
        This is needed because of the way we parse periodic boundary conditions. */
     if( _periodic_bcs.size() != _num_periodic_bcs/2 )
       {
         std::cerr << "=========================================================="  << std::endl
                   << "Error: Inconsistency in perioidic boundary conditions."      << std::endl
                   << "       There were " << _num_periodic_bcs << " deteced but "  << std::endl
                   << "       only " << _periodic_bcs.size() << " pairs of data "   << std::endl
                   << "       were set."                                            << std::endl
                   << "=========================================================="  << std::endl;
         libmesh_error();
       }
 
     libMesh::DofMap& dof_map = system->get_dof_map();
 
     for( std::vector< PBCContainer >::const_iterator it = _periodic_bcs.begin();
          it != _periodic_bcs.end();
          it++ )
       {
         libMesh::PeriodicBoundary bc( it->get_offset_vector() );
         bc.myboundary = it->get_master_bcid();
         bc.pairedboundary = it->get_slave_bcid();
 
         dof_map.add_periodic_boundary( bc );
       }
 
     return;
   }

bool GRINS::BCHandlingBase::is_axisymmetric ( ) const

inlineinherited

Definition at line 179 of file bc_handling_base.h.

References GRINS::BCHandlingBase::_axisymmetric.

Referenced by GRINS::HeatTransfer< Conductivity >::HeatTransfer(), GRINS::IncompressibleNavierStokes< Viscosity >::IncompressibleNavierStokes(), GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::ReactingLowMachNavierStokes(), and GRINS::HeatTransferBCHandling::user_apply_neumann_bcs().

   {
     return _axisymmetric;
   }

void GRINS::BCHandlingBase::read_bc_data	(	const GetPot &	input,
		const std::string &	id_str,
		const std::string &	bc_str,
		const std::string &	var_str,
		const std::string &	val_str
	)

virtualinherited

Definition at line 73 of file bc_handling_base.C.

References GRINS::BCHandlingBase::init_bc_types(), and GRINS::BCHandlingBase::string_to_int().

Referenced by GRINS::AxisymmetricHeatTransferBCHandling::AxisymmetricHeatTransferBCHandling(), GRINS::HeatTransferBCHandling::HeatTransferBCHandling(), IncompressibleNavierStokesBCHandling(), GRINS::LowMachNavierStokesBCHandling::LowMachNavierStokesBCHandling(), GRINS::ReactingLowMachNavierStokesBCHandling< Chemistry >::ReactingLowMachNavierStokesBCHandling(), GRINS::SolidMechanicsBCHandling::SolidMechanicsBCHandling(), and GRINS::SpalartAllmarasBCHandling::SpalartAllmarasBCHandling().

   {
     int num_ids = input.vector_variable_size(id_str);
     int num_bcs = input.vector_variable_size(bc_str);
     // int num_vars = input.vector_variable_size(var_str);
     // int num_vals = input.vector_variable_size(val_str);
 
     if( num_ids != num_bcs )
       {
         std::cerr << "Error: Must specify equal number of boundary ids and boundary conditions"
                   << std::endl;
         libmesh_error();
       }
 
     for( int i = 0; i < num_ids; i++ )
       {
         int bc_id = input(id_str, -1, i );
         std::string bc_type_in = input(bc_str, "NULL", i );
 
         int bc_type = this->string_to_int( bc_type_in );
 
         std::stringstream ss;
         ss << bc_id;
         std::string bc_id_string = ss.str();
 
         std::string bc_val = input(val_str, std::string(""), i );
 
         std::string bc_vars = input(var_str, std::string(""), i );
 
         this->init_bc_types( bc_id, bc_id_string, bc_type, bc_vars, bc_val, input );
       }
 
     return;
   }

void GRINS::BCHandlingBase::set_dirichlet_bc_type	(	GRINS::BoundaryID	bc_id,
		int	bc_type
	)

inherited

Definition at line 252 of file bc_handling_base.C.

References GRINS::BCHandlingBase::_dirichlet_bc_map.

Referenced by GRINS::AxisymmetricHeatTransferBCHandling::init_bc_types(), GRINS::HeatTransferBCHandling::init_bc_types(), GRINS::SpalartAllmarasBCHandling::init_bc_types(), GRINS::LowMachNavierStokesBCHandling::init_bc_types(), GRINS::SolidMechanicsBCHandling::init_bc_types(), and init_bc_types().

   {
     _dirichlet_bc_map.push_back( std::make_pair(bc_id, bc_type) );
     return;
   }

void GRINS::BCHandlingBase::set_dirichlet_bc_value	(	GRINS::BoundaryID	bc_id,
		libMesh::Real	value,
		int	component = `0`
	)

inherited

Definition at line 264 of file bc_handling_base.C.

References GRINS::BCHandlingBase::_dirichlet_values.

Referenced by GRINS::AxisymmetricHeatTransferBCHandling::init_bc_types(), GRINS::HeatTransferBCHandling::init_bc_types(), GRINS::LowMachNavierStokesBCHandling::init_bc_types(), init_bc_types(), and GRINS::SolidMechanicsBCHandling::init_bc_types().

   {
     _dirichlet_values[bc_id](component) = value;
     return;
   }

void GRINS::BCHandlingBase::set_neumann_bc_type	(	GRINS::BoundaryID	bc_id,
		int	bc_type
	)

inherited

Definition at line 258 of file bc_handling_base.C.

References GRINS::BCHandlingBase::_neumann_bc_map.

Referenced by GRINS::AxisymmetricHeatTransferBCHandling::init_bc_types(), GRINS::HeatTransferBCHandling::init_bc_types(), GRINS::LowMachNavierStokesBCHandling::init_bc_types(), and GRINS::SolidMechanicsBCHandling::init_bc_types().

   {
     _neumann_bc_map[bc_id] = bc_type;
     return;
   }

void GRINS::BCHandlingBase::set_neumann_bc_value	(	GRINS::BoundaryID	bc_id,
		const libMesh::Point &	q_in
	)

inherited

Definition at line 278 of file bc_handling_base.C.

References GRINS::BCHandlingBase::_q_values.

Referenced by GRINS::AxisymmetricHeatTransferBCHandling::init_bc_types(), GRINS::HeatTransferBCHandling::init_bc_types(), GRINS::LowMachNavierStokesBCHandling::init_bc_types(), and GRINS::SolidMechanicsBCHandling::init_bc_types().

   {
     _q_values[bc_id] = q_in;
   }

int GRINS::IncompressibleNavierStokesBCHandling::string_to_int ( const std::string & bc_type_in ) const

virtual

Reimplemented from GRINS::BCHandlingBase.

Definition at line 61 of file inc_navier_stokes_bc_handling.C.

References GENERAL_VELOCITY, NO_SLIP, PARABOLIC_PROFILE, PRESCRIBED_VELOCITY, and GRINS::BCHandlingBase::string_to_int().

   {
     int bc_type_out;
 
     if( bc_type == "no_slip" )
       bc_type_out = NO_SLIP;
 
     else if( bc_type == "prescribed_vel" )
       bc_type_out = PRESCRIBED_VELOCITY;
 
     else if( bc_type == "parabolic_profile" )
       bc_type_out = PARABOLIC_PROFILE;
 
     else if( bc_type == "general_velocity" )
       bc_type_out = GENERAL_VELOCITY;
 
     else
       {
         // Call base class to detect any physics-common boundary conditions
         bc_type_out = BCHandlingBase::string_to_int( bc_type );
       }
 
     return bc_type_out;
   }

void GRINS::BCHandlingBase::user_apply_neumann_bcs	(	AssemblyContext &	context,
		const GRINS::CachedValues &	cache,
		const bool	request_jacobian,
		const GRINS::BoundaryID	bc_id,
		const GRINS::BCType	bc_type
	)		const

virtualinherited

Reimplemented in GRINS::ReactingLowMachNavierStokesBCHandling< Chemistry >, GRINS::SolidMechanicsBCHandling, GRINS::HeatTransferBCHandling, and GRINS::AxisymmetricHeatTransferBCHandling.

Definition at line 479 of file bc_handling_base.C.

Referenced by GRINS::BCHandlingBase::apply_neumann_bcs().

   {
     // Not all Physics need this so we have a do nothing default.
     return;
   }

void GRINS::IncompressibleNavierStokesBCHandling::user_init_dirichlet_bcs	(	libMesh::FEMSystem *	system,
		libMesh::DofMap &	dof_map,
		GRINS::BoundaryID	bc_id,
		GRINS::BCType	bc_type
	)		const

virtual

Reimplemented from GRINS::BCHandlingBase.

Definition at line 222 of file inc_navier_stokes_bc_handling.C.

References _flow_vars, GRINS::BCHandlingBase::AXISYMMETRIC, GENERAL_VELOCITY, GRINS::BCHandlingBase::get_dirichlet_bc_value(), NO_SLIP, PARABOLIC_PROFILE, PRESCRIBED_VELOCITY, GRINS::PrimitiveFlowVariables::u_var(), GRINS::PrimitiveFlowVariables::v_var(), and GRINS::PrimitiveFlowVariables::w_var().

   {
     int dim = system->get_mesh().mesh_dimension();
 
     VariableIndex u_var = _flow_vars.u_var();
     VariableIndex v_var = _flow_vars.v_var();
     VariableIndex w_var = -1;
     if( dim == 3 )
       w_var = _flow_vars.w_var();
 
     switch( bc_type )
       {
       case(NO_SLIP):
         {
           std::set<BoundaryID> dbc_ids;
           dbc_ids.insert(bc_id);
         
           std::vector<VariableIndex> dbc_vars;
           dbc_vars.push_back(u_var);
           dbc_vars.push_back(v_var);
           if(dim == 3)
             dbc_vars.push_back(w_var);
         
           libMesh::ZeroFunction<libMesh::Number> zero;
         
           libMesh::DirichletBoundary no_slip_dbc(dbc_ids, 
                                                  dbc_vars, 
                                                  &zero );
         
           dof_map.add_dirichlet_boundary( no_slip_dbc );
         }
         break;
       case(PRESCRIBED_VELOCITY):
         {
           std::set<BoundaryID> dbc_ids;
           dbc_ids.insert(bc_id);
         
           std::vector<VariableIndex> dbc_vars;
         
           // This is inefficient, but it shouldn't matter because
           // everything gets cached on the libMesh side so it should
           // only affect performance at startup.
           {
             dbc_vars.push_back(u_var);
             libMesh::ConstFunction<libMesh::Number>
               vel_func( this->get_dirichlet_bc_value(bc_id,0) );
           
             libMesh::DirichletBoundary vel_dbc(dbc_ids, 
                                                dbc_vars, 
                                                &vel_func );
           
             dof_map.add_dirichlet_boundary( vel_dbc );
             dbc_vars.clear();
           }
         
           {
             dbc_vars.push_back(v_var);
             libMesh::ConstFunction<libMesh::Number>
               vel_func( this->get_dirichlet_bc_value(bc_id,1) );
           
             libMesh::DirichletBoundary vel_dbc(dbc_ids, 
                                                dbc_vars, 
                                                &vel_func );
           
             dof_map.add_dirichlet_boundary( vel_dbc );
             dbc_vars.clear();
           }
           if( dim == 3 )
             {
               dbc_vars.push_back(w_var);
               libMesh::ConstFunction<libMesh::Number>
                 vel_func( this->get_dirichlet_bc_value(bc_id,2) );
             
               libMesh::DirichletBoundary vel_dbc(dbc_ids, 
                                                  dbc_vars, 
                                                  &vel_func );
             
               dof_map.add_dirichlet_boundary( vel_dbc );
             }  
         }
         break;
       case(PARABOLIC_PROFILE):
         // This case is handled init_dirichlet_bc_func_objs
         break;
 
       case(GENERAL_VELOCITY):
         // This case is handled in the init_dirichlet_bc_func_objs
         break;
 
       case(AXISYMMETRIC):
         {
           std::set<BoundaryID> dbc_ids;
           dbc_ids.insert(bc_id);
         
           std::vector<VariableIndex> dbc_vars;
           dbc_vars.push_back(u_var);
         
           libMesh::ZeroFunction<libMesh::Number> zero;
         
           libMesh::DirichletBoundary no_slip_dbc( dbc_ids, 
                                                   dbc_vars, 
                                                   &zero );
         
           dof_map.add_dirichlet_boundary( no_slip_dbc );
         }
       break;
 
       default:
         {
           std::cerr << "Invalid BCType " << bc_type << std::endl;
           libmesh_error();
         }
       
       }// end switch
 
     return;
   }

Member Data Documentation

bool GRINS::BCHandlingBase::_axisymmetric = false

staticprotectedinherited

Flag to cache whether or not there is an axisymmetric boundary present.

Definition at line 170 of file bc_handling_base.h.

Referenced by GRINS::BCHandlingBase::is_axisymmetric(), and GRINS::BCHandlingBase::string_to_int().

GRINS::BoundaryConditions GRINS::BCHandlingBase::_bound_conds

protectedinherited

Object that stashes generic boundary condition types.

Todo:: Move this so that only one object is needed. Perhaps make static?

Definition at line 156 of file bc_handling_base.h.

Referenced by GRINS::AxisymmetricHeatTransferBCHandling::user_apply_neumann_bcs(), GRINS::HeatTransferBCHandling::user_apply_neumann_bcs(), and GRINS::SolidMechanicsBCHandling::user_apply_neumann_bcs().

std::vector<std::pair<BoundaryID,BCType> > GRINS::BCHandlingBase::_dirichlet_bc_map

protectedinherited

Map between boundary id and Dirichlet boundary condition type.

We need to keep this around because the libMesh::DirichletBoundary objects can't be created until we init the variables. We use a vector of pairs so that the boundary condition functors get added to the libMesh::DofMap in the same order as in the input file.

Definition at line 137 of file bc_handling_base.h.

Referenced by GRINS::BCHandlingBase::get_dirichlet_bc_type(), GRINS::LowMachNavierStokesBCHandling::init_dirichlet_bcs(), GRINS::BCHandlingBase::init_dirichlet_bcs(), and GRINS::BCHandlingBase::set_dirichlet_bc_type().