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

#include <heat_transfer_bc_handling.h>

Inheritance diagram for GRINS::HeatTransferBCHandling:

Collaboration diagram for GRINS::HeatTransferBCHandling:

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

virtual	~HeatTransferBCHandling ()

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

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

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	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
PrimitiveTempVariables	_temp_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	HT_BC_TYPES { ISOTHERMAL_WALL =0, ADIABATIC_WALL, PRESCRIBED_HEAT_FLUX, GENERAL_HEAT_FLUX }

Private Member Functions
	HeatTransferBCHandling ()

Detailed Description

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

Definition at line 35 of file heat_transfer_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::HeatTransferBCHandling::HT_BC_TYPES

private

Enumerator
ISOTHERMAL_WALL
ADIABATIC_WALL
PRESCRIBED_HEAT_FLUX
GENERAL_HEAT_FLUX

Definition at line 73 of file heat_transfer_bc_handling.h.

                     {ISOTHERMAL_WALL=0,
                      ADIABATIC_WALL,
                      PRESCRIBED_HEAT_FLUX,
                      GENERAL_HEAT_FLUX};

Constructor & Destructor Documentation

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

Definition at line 38 of file heat_transfer_bc_handling.C.

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

     : BCHandlingBase(physics_name),
       _temp_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::HeatTransferBCHandling::~HeatTransferBCHandling ( )

virtual

Definition at line 53 of file heat_transfer_bc_handling.C.

   {
     return;
   }

GRINS::HeatTransferBCHandling::HeatTransferBCHandling ( )

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(), GRINS::IncompressibleNavierStokesBCHandling::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 user_init_dirichlet_bcs(), GRINS::LowMachNavierStokesBCHandling::user_init_dirichlet_bcs(), GRINS::SolidMechanicsBCHandling::user_init_dirichlet_bcs(), GRINS::IncompressibleNavierStokesBCHandling::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(), 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 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::HeatTransferBCHandling::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 83 of file heat_transfer_bc_handling.C.

References _temp_vars, and GRINS::PrimitiveTempVariables::init().

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

void GRINS::HeatTransferBCHandling::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 90 of file heat_transfer_bc_handling.C.

References GRINS::BCHandlingBase::_physics_name, ADIABATIC_WALL, GENERAL_HEAT_FLUX, GRINS::BCHandlingBase::init_bc_types(), ISOTHERMAL_WALL, PRESCRIBED_HEAT_FLUX, GRINS::BCHandlingBase::set_dirichlet_bc_type(), GRINS::BCHandlingBase::set_dirichlet_bc_value(), GRINS::BCHandlingBase::set_neumann_bc_type(), and GRINS::BCHandlingBase::set_neumann_bc_value().

   {
     switch(bc_type)
       {
       case(ISOTHERMAL_WALL):
         {
           this->set_dirichlet_bc_type( bc_id, bc_type );
 
           this->set_dirichlet_bc_value( bc_id, input("Physics/"+_physics_name+"/T_wall_"+bc_id_string, 0.0 ) );
         }
         break;
       
       case(ADIABATIC_WALL):
         {
           this->set_neumann_bc_type( bc_id, bc_type );
         }
         break;
       
       case(PRESCRIBED_HEAT_FLUX):
         {
           this->set_neumann_bc_type( bc_id, bc_type );
         
           libMesh::RealGradient q_in;
         
           int num_q_components = input.vector_variable_size("Physics/"+_physics_name+"/q_wall_"+bc_id_string);
         
           for( int i = 0; i < num_q_components; i++ )
             {
               q_in(i) = input("Physics/"+_physics_name+"/q_wall_"+bc_id_string, 0.0, i );
             }
 
           this->set_neumann_bc_value( bc_id, q_in );
         }
         break;
       case(GENERAL_HEAT_FLUX):
         {
           this->set_neumann_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 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(), HeatTransferBCHandling(), GRINS::IncompressibleNavierStokesBCHandling::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(), init_bc_types(), GRINS::LowMachNavierStokesBCHandling::init_bc_types(), GRINS::SpalartAllmarasBCHandling::init_bc_types(), GRINS::IncompressibleNavierStokesBCHandling::init_bc_types(), and GRINS::SolidMechanicsBCHandling::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(), init_bc_types(), GRINS::LowMachNavierStokesBCHandling::init_bc_types(), GRINS::IncompressibleNavierStokesBCHandling::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(), 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(), init_bc_types(), GRINS::LowMachNavierStokesBCHandling::init_bc_types(), and GRINS::SolidMechanicsBCHandling::init_bc_types().

   {
     _q_values[bc_id] = q_in;
   }

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

virtual

Reimplemented from GRINS::BCHandlingBase.

Definition at line 58 of file heat_transfer_bc_handling.C.

References ADIABATIC_WALL, GENERAL_HEAT_FLUX, ISOTHERMAL_WALL, PRESCRIBED_HEAT_FLUX, and GRINS::BCHandlingBase::string_to_int().

   {
     int bc_type_out;
 
     if( bc_type == "isothermal_wall" )
       bc_type_out = ISOTHERMAL_WALL;
   
     else if( bc_type == "adiabatic_wall" )
       bc_type_out = ADIABATIC_WALL;
   
     else if( bc_type == "prescribed_heat_flux" )
       bc_type_out = PRESCRIBED_HEAT_FLUX;
   
     else if( bc_type == "general_heat_flux" )
       bc_type_out = GENERAL_HEAT_FLUX;
 
     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::HeatTransferBCHandling::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

Reimplemented from GRINS::BCHandlingBase.

Definition at line 180 of file heat_transfer_bc_handling.C.

References GRINS::BCHandlingBase::_bound_conds, GRINS::BCHandlingBase::_physics_name, _temp_vars, ADIABATIC_WALL, GRINS::BoundaryConditions::apply_neumann(), GRINS::BoundaryConditions::apply_neumann_axisymmetric(), GENERAL_HEAT_FLUX, GRINS::BCHandlingBase::get_neumann_bc_value(), GRINS::BCHandlingBase::get_neumann_bound_func(), GRINS::BCHandlingBase::is_axisymmetric(), PRESCRIBED_HEAT_FLUX, and GRINS::PrimitiveTempVariables::T_var().

   {
     switch( bc_type )
       {
         // Zero heat flux
       case(ADIABATIC_WALL):
         // Don't need to do anything: q = 0 in this case
         break;
       
         // Prescribed constant heat flux
       case(PRESCRIBED_HEAT_FLUX):
         {
           if( this->is_axisymmetric() )
             {
               _bound_conds.apply_neumann_axisymmetric( context, _temp_vars.T_var(), -1.0,
                                                        this->get_neumann_bc_value(bc_id) );
             }
           else
             {
               _bound_conds.apply_neumann( context, _temp_vars.T_var(), -1.0,
                                           this->get_neumann_bc_value(bc_id) );
             }
         }
         break;
         // General heat flux from user specified function
       case(GENERAL_HEAT_FLUX):
         {
           if( this->is_axisymmetric() )
             {
               _bound_conds.apply_neumann_axisymmetric( context, cache, request_jacobian, _temp_vars.T_var(), -1.0, 
                                                        this->get_neumann_bound_func( bc_id, _temp_vars.T_var() ) );
             }
           else
             {
               _bound_conds.apply_neumann( context, cache, request_jacobian, _temp_vars.T_var(), -1.0, 
                                           this->get_neumann_bound_func( bc_id, _temp_vars.T_var() ) );
             }
         }
         break;
       default:
         {
           std::cerr << "Error: Invalid Neumann BC type for " << _physics_name
                     << std::endl;
           libmesh_error();
         }
       } // End switch
   
     return;
   }

void GRINS::HeatTransferBCHandling::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 146 of file heat_transfer_bc_handling.C.

References GRINS::BCHandlingBase::_physics_name, _temp_vars, GRINS::BCHandlingBase::get_dirichlet_bc_value(), ISOTHERMAL_WALL, and GRINS::PrimitiveTempVariables::T_var().

   {
     switch( bc_type )
       {
       case(ISOTHERMAL_WALL):
         {
           std::set<BoundaryID> dbc_ids;
           dbc_ids.insert(bc_id);
         
           std::vector<VariableIndex> dbc_vars;
           dbc_vars.push_back(_temp_vars.T_var());
         
           libMesh::ConstFunction<libMesh::Number>
             t_func(this->get_dirichlet_bc_value(bc_id));
         
           libMesh::DirichletBoundary t_dbc( dbc_ids, dbc_vars, &t_func );
         
           dof_map.add_dirichlet_boundary( t_dbc );
         }
         break;
       default:
         {
           std::cerr << "Error: Invalid Dirichlet BC type for " << _physics_name
                     << 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(), 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().