#include <solid_mechanics_bc_handling.h>

Inheritance diagram for GRINS::SolidMechanicsBCHandling:

Collaboration diagram for GRINS::SolidMechanicsBCHandling:

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

virtual	~SolidMechanicsBCHandling ()

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
SolidMechanicsVariables	_disp_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	SOLIDS_BC_TYPES { PINNED =1, CONSTANT_DISPLACEMENT, ROLLER_X, ROLLER_Y, ROLLER_Z, SYMMETRY_YZ, SYMMETRY_XZ, SYMMETRY_XY, CONSTANT_TRACTION }

Private Member Functions
	SolidMechanicsBCHandling ()

Detailed Description

Definition at line 35 of file solid_mechanics_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::SolidMechanicsBCHandling::SOLIDS_BC_TYPES

private

Enumerator
PINNED
CONSTANT_DISPLACEMENT
ROLLER_X
ROLLER_Y
ROLLER_Z
SYMMETRY_YZ
SYMMETRY_XZ
SYMMETRY_XY
CONSTANT_TRACTION

Definition at line 74 of file solid_mechanics_bc_handling.h.

                         {PINNED=1,
                          CONSTANT_DISPLACEMENT,
                          ROLLER_X,
                          ROLLER_Y,
                          ROLLER_Z,
                          SYMMETRY_YZ,
                          SYMMETRY_XZ,
                          SYMMETRY_XY,
                          CONSTANT_TRACTION};

Constructor & Destructor Documentation

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

Definition at line 37 of file solid_mechanics_bc_handling.C.

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

     : BCHandlingBase(physics_name),
       _disp_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::SolidMechanicsBCHandling::~SolidMechanicsBCHandling ( )

virtual

Definition at line 52 of file solid_mechanics_bc_handling.C.

   {
     return;
   }

GRINS::SolidMechanicsBCHandling::SolidMechanicsBCHandling ( )

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 GRINS::HeatTransferBCHandling::user_init_dirichlet_bcs(), GRINS::LowMachNavierStokesBCHandling::user_init_dirichlet_bcs(), 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(), GRINS::HeatTransferBCHandling::user_apply_neumann_bcs(), and 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::SolidMechanicsBCHandling::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 97 of file solid_mechanics_bc_handling.C.

References _disp_vars, and GRINS::SolidMechanicsVariables::init().

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

void GRINS::SolidMechanicsBCHandling::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 104 of file solid_mechanics_bc_handling.C.

References _disp_vars, GRINS::BCHandlingBase::_physics_name, CONSTANT_DISPLACEMENT, CONSTANT_TRACTION, GRINS::SolidMechanicsVariables::have_v(), GRINS::SolidMechanicsVariables::have_w(), GRINS::BCHandlingBase::init_bc_types(), PINNED, ROLLER_X, ROLLER_Y, ROLLER_Z, GRINS::BCHandlingBase::set_dirichlet_bc_type(), GRINS::BCHandlingBase::set_dirichlet_bc_value(), GRINS::BCHandlingBase::set_neumann_bc_type(), GRINS::BCHandlingBase::set_neumann_bc_value(), SYMMETRY_XY, SYMMETRY_XZ, and SYMMETRY_YZ.

   {
     switch(bc_type)
       {
       case(PINNED):
         {
           this->set_dirichlet_bc_type( bc_id, bc_type );
         }
         break;
 
       case(CONSTANT_DISPLACEMENT):
         {
           this->set_dirichlet_bc_type( bc_id, bc_type );
 
           int n_disp_comps = input.vector_variable_size("Physics/"+_physics_name+"/displacement_"+bc_id_string);
 
           if( _disp_vars.have_v() )
             {
               if( n_disp_comps < 2 )
                 {
                   std::cerr << "Error: Must specify at least 2 displacement components for 2-D problem." << std::endl;
                   libmesh_error();
                 }
             }
 
           if( _disp_vars.have_w() )
             {
               if( n_disp_comps < 3 )
                 {
                   std::cerr << "Error: Must specify 3 displacement components for 3-D problem." << std::endl;
                   libmesh_error();
                 }
             }
 
           for( int i = 0; i < n_disp_comps; i++ )
             {
               this->set_dirichlet_bc_value( bc_id,
                                             input("Physics/"+_physics_name+"/displacement_"+bc_id_string, 0.0, i ),
                                             i );
             }
         }
         break;
 
       case(ROLLER_X):
       case(ROLLER_Y):
       case(ROLLER_Z):
       case(SYMMETRY_YZ):
       case(SYMMETRY_XZ):
       case(SYMMETRY_XY):
         {
           this->set_dirichlet_bc_type( bc_id, bc_type );
         }
         break;
 
       case(CONSTANT_TRACTION):
         {
           this->set_neumann_bc_type( bc_id, bc_type );
 
           libMesh::Gradient t_in;
 
           int num_t_components = input.vector_variable_size("Physics/"+_physics_name+"/traction_"+bc_id_string);
 
           if( num_t_components < 3 )
             {
               std::cerr << "Error: Expecting 3 components when specifying traction!" << std::endl
                         << "       Found " << num_t_components << " components." << std::endl;
               libmesh_error();
             }
 
           for( int i = 0; i < num_t_components; i++ )
             {
               t_in(i) = input("Physics/"+_physics_name+"/traction_"+bc_id_string, 0.0, i );
             }
 
           this->set_neumann_bc_value( bc_id, t_in );
         }
         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(), GRINS::IncompressibleNavierStokesBCHandling::IncompressibleNavierStokesBCHandling(), GRINS::LowMachNavierStokesBCHandling::LowMachNavierStokesBCHandling(), GRINS::ReactingLowMachNavierStokesBCHandling< Chemistry >::ReactingLowMachNavierStokesBCHandling(), 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::LowMachNavierStokesBCHandling::init_bc_types(), GRINS::SpalartAllmarasBCHandling::init_bc_types(), GRINS::IncompressibleNavierStokesBCHandling::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(), GRINS::IncompressibleNavierStokesBCHandling::init_bc_types(), and 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 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 init_bc_types().

   {
     _q_values[bc_id] = q_in;
   }

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

virtual

Reimplemented from GRINS::BCHandlingBase.

Definition at line 57 of file solid_mechanics_bc_handling.C.

References CONSTANT_DISPLACEMENT, CONSTANT_TRACTION, PINNED, ROLLER_X, ROLLER_Y, ROLLER_Z, GRINS::BCHandlingBase::string_to_int(), SYMMETRY_XY, SYMMETRY_XZ, and SYMMETRY_YZ.

   {
     int bc_type_out;
 
     if( bc_type == "pinned" )
       bc_type_out = PINNED;
 
     else if( bc_type == "constant_displacement" )
       bc_type_out = CONSTANT_DISPLACEMENT;
 
     else if( bc_type == "roller_x" )
       bc_type_out = ROLLER_X;
 
     else if( bc_type == "roller_y" )
       bc_type_out = ROLLER_Y;
 
     else if( bc_type == "roller_z" )
       bc_type_out = ROLLER_Z;
 
     else if( bc_type == "yz_symmetry" )
       bc_type_out = SYMMETRY_YZ;
 
     else if( bc_type == "xz_symmetry" )
       bc_type_out = SYMMETRY_XZ;
 
     else if( bc_type == "xy_symmetry" )
       bc_type_out = SYMMETRY_XY;
 
     else if( bc_type == "constant_traction" )
       bc_type_out = CONSTANT_TRACTION;
 
     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::SolidMechanicsBCHandling::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 433 of file solid_mechanics_bc_handling.C.

References GRINS::BCHandlingBase::_bound_conds, _disp_vars, GRINS::BCHandlingBase::_physics_name, GRINS::BoundaryConditions::apply_neumann_normal(), CONSTANT_TRACTION, GRINS::BCHandlingBase::get_neumann_bc_value(), GRINS::SolidMechanicsVariables::have_v(), GRINS::SolidMechanicsVariables::have_w(), GRINS::SolidMechanicsVariables::u_var(), GRINS::SolidMechanicsVariables::v_var(), and GRINS::SolidMechanicsVariables::w_var().

   {
     switch( bc_type )
       {
       case(CONSTANT_TRACTION):
         {
           const libMesh::Point& traction = this->get_neumann_bc_value(bc_id);
 
           _bound_conds.apply_neumann_normal( context, _disp_vars.u_var(), 1.0, traction(0) );
 
           if( _disp_vars.have_v() )
             _bound_conds.apply_neumann_normal( context, _disp_vars.v_var(), 1.0, traction(1) );
 
           if( _disp_vars.have_w() )
             _bound_conds.apply_neumann_normal( context, _disp_vars.w_var(), 1.0, traction(2) );
         }
         break;
 
       default:
         {
           std::cerr << "Error: Invalid Neumann BC type for " << _physics_name
                     << std::endl;
           libmesh_error();
         }
 
       } // switch( bc_type )
 
     return;
   }

void GRINS::SolidMechanicsBCHandling::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 199 of file solid_mechanics_bc_handling.C.

   {
     VariableIndex u_var = _disp_vars.u_var();
     libmesh_assert(system->has_variable(_disp_vars.u_var_name()));
 
     VariableIndex v_var;
     if( _disp_vars.have_v() )
       {
         v_var = _disp_vars.v_var();
         libmesh_assert(system->has_variable(_disp_vars.v_var_name()));
       }
 
     VariableIndex w_var;
     if( _disp_vars.have_w() )
       {
         w_var = _disp_vars.w_var();
         libmesh_assert(system->has_variable(_disp_vars.w_var_name()));
       }
 
     switch( bc_type )
       {
       case(PINNED):
         {
           std::set<BoundaryID> dbc_ids;
           dbc_ids.insert(bc_id);
 
           std::vector<VariableIndex> dbc_vars;
           dbc_vars.push_back(u_var);
 
           if( _disp_vars.have_v() )
             dbc_vars.push_back(v_var);
 
           if( _disp_vars.have_w() )
             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(CONSTANT_DISPLACEMENT):
         {
           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>
               disp_func( this->get_dirichlet_bc_value(bc_id,0) );
 
             libMesh::DirichletBoundary disp_dbc(dbc_ids,
                                                 dbc_vars,
                                                 &disp_func );
 
             dof_map.add_dirichlet_boundary( disp_dbc );
             dbc_vars.clear();
           }
 
           if( _disp_vars.have_v() )
             {
               dbc_vars.push_back(v_var);
               libMesh::ConstFunction<libMesh::Number>
                 disp_func( this->get_dirichlet_bc_value(bc_id,1) );
 
               libMesh::DirichletBoundary disp_dbc(dbc_ids,
                                                   dbc_vars,
                                                   &disp_func );
 
               dof_map.add_dirichlet_boundary( disp_dbc );
               dbc_vars.clear();
             }
 
           if( _disp_vars.have_w() )
             {
               dbc_vars.push_back(w_var);
               libMesh::ConstFunction<libMesh::Number>
                 disp_func( this->get_dirichlet_bc_value(bc_id,2) );
 
               libMesh::DirichletBoundary disp_dbc(dbc_ids,
                                                   dbc_vars,
                                                   &disp_func );
 
               dof_map.add_dirichlet_boundary( disp_dbc );
             }
         }
         break;
 
         // Roller is free to move in the x-direction, so pin y and z-directions
       case(ROLLER_X):
         {
           std::set<BoundaryID> dbc_ids;
           dbc_ids.insert(bc_id);
 
           std::vector<VariableIndex> dbc_vars;
 
           if( _disp_vars.have_v() )
             dbc_vars.push_back(v_var);
 
           if( _disp_vars.have_w() )
             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;
 
         // Roller is free to move in the y-direction, so pin x and z-directions
       case(ROLLER_Y):
         {
           std::set<BoundaryID> dbc_ids;
           dbc_ids.insert(bc_id);
 
           std::vector<VariableIndex> dbc_vars;
           dbc_vars.push_back(u_var);
 
           if( _disp_vars.have_w() )
             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;
 
         // Roller is free to move in the z-direction, so pin x and y-directions
       case(ROLLER_Z):
         {
           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);
 
           libMesh::ZeroFunction<libMesh::Number> zero;
 
           libMesh::DirichletBoundary no_slip_dbc(dbc_ids,
                                                  dbc_vars,
                                                  &zero );
 
           dof_map.add_dirichlet_boundary( no_slip_dbc );
         }
         break;
 
         // Symmetric about YZ-plane so pin x-direction
       case(SYMMETRY_YZ):
         {
           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;
 
         // Symmetric about XZ-plane so pin y-direction
       case(SYMMETRY_XZ):
         {
           std::set<BoundaryID> dbc_ids;
           dbc_ids.insert(bc_id);
 
           std::vector<VariableIndex> dbc_vars;
           dbc_vars.push_back(v_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;
 
         // Symmetric about XY-plane so pin z-direction
       case(SYMMETRY_XY):
         {
           std::set<BoundaryID> dbc_ids;
           dbc_ids.insert(bc_id);
 
           std::vector<VariableIndex> dbc_vars;
           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;
 
       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 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().