Manages runtime construction of Dirichlet boundary conditions. More...

#include <default_bc_builder.h>

Inheritance diagram for GRINS::DefaultBCBuilder:

Collaboration diagram for GRINS::DefaultBCBuilder:

Public Member Functions
	DefaultBCBuilder ()

	~DefaultBCBuilder ()

Public Member Functions inherited from GRINS::BCBuilder
	BCBuilder ()

virtual	~BCBuilder ()

Public Member Functions inherited from GRINS::BuilderHelper
	BuilderHelper ()

	~BuilderHelper ()

Protected Member Functions
virtual void	build_bcs (const GetPot &input, MultiphysicsSystem &system, std::vector< SharedPtr< NeumannBCContainer > > &neumann_bcs)

void	build_type_based_bcs (const GetPot &input, MultiphysicsSystem &system, const std::set< BoundaryID > &bc_ids, libMesh::DofMap &dof_map, const std::string &type_input_section, std::set< std::string > &var_sections, std::vector< SharedPtr< NeumannBCContainer > > &neumann_bcs)
	Helper function to build boundary conditions specified by a single type. More...

void	build_axisymmetric_bcs (const GetPot &input, MultiphysicsSystem &system, const std::set< BoundaryID > &bc_ids, libMesh::DofMap &dof_map, const std::string &bc_type, std::set< std::string > &var_sections, std::vector< SharedPtr< NeumannBCContainer > > &neumann_bcs)

void	build_bcs_by_var_section (const GetPot &input, MultiphysicsSystem &system, const std::string &bc_name, const std::set< BoundaryID > &bc_ids, libMesh::DofMap &dof_map, std::set< std::string > &var_sections, const std::map< BoundaryID, std::vector< libMesh::subdomain_id_type > > &bc_id_to_subdomain_id_map, std::vector< SharedPtr< NeumannBCContainer > > &neumann_bcs)
	Helper function to build boundary conditions using Variable sections. More...

void	parse_and_build_bc_id_map (const GetPot &input, std::map< std::string, std::set< BoundaryID > > &bc_id_map)

void	verify_bc_ids_with_mesh (const MultiphysicsSystem &system, const std::map< std::string, std::set< BoundaryID > > &bc_id_map) const

void	build_periodic_bc (const GetPot &input, libMesh::System &system, const std::set< BoundaryID > &bc_ids, const std::string &section)

void	parse_periodic_master_slave_ids (const GetPot &input, const std::string &section, libMesh::boundary_id_type &master_id, libMesh::boundary_id_type &slave_id) const

libMesh::RealVectorValue	parse_periodic_offset (const GetPot &input, const std::string &section) const

void	build_bc_to_subdomain_map_check_with_mesh (const MultiphysicsSystem &system, std::map< BoundaryID, std::vector< libMesh::subdomain_id_type > > &bc_id_to_subdomain_id_map) const
	Build up bc_id to subdomain_id map. More...

bool	is_var_active (const FEVariablesBase &var, const std::vector< libMesh::subdomain_id_type > &subdomain_ids) const
	Check if the Variable var is active on the given subdomain_id. More...

Protected Member Functions inherited from GRINS::BCBuilder
void	construct_dbc_core (const GetPot &input, MultiphysicsSystem &system, const std::set< BoundaryID > &bc_ids, const FEVariablesBase &fe_var, const std::string &section, const std::string &bc_type, libMesh::DofMap &dof_map)

void	construct_nbc_core (const GetPot &input, MultiphysicsSystem &system, const std::set< BoundaryID > &bc_ids, const FEVariablesBase &fe_var, const std::string &section, const std::string &bc_type, std::vector< SharedPtr< NeumannBCContainer > > &neumann_bcs)

bool	is_dirichlet_bc_type (const std::string &bc_type)

bool	is_neumann_bc_type (const std::string &bc_type)

void	add_periodic_bc_to_dofmap (libMesh::boundary_id_type master_id, libMesh::boundary_id_type slave_id, const libMesh::RealVectorValue &offset_vector, libMesh::DofMap &dof_map)

Additional Inherited Members
Static Public Member Functions inherited from GRINS::BCBuilder
static void	build_boundary_conditions (const GetPot &input, MultiphysicsSystem &system, std::vector< SharedPtr< NeumannBCContainer > > &neumann_bcs)

Static Public Member Functions inherited from GRINS::BuilderHelper
static void	parse_var_sections (const GetPot &input, std::set< std::string > &sections)
	Parses the input file for [Variables] first-level subsections. More...

static void	parse_var_sections_vector (const GetPot &input, std::vector< std::string > &sections)
	The same as parse_var_sections, except the result is returned in an std::vector. More...

Static Protected Member Functions inherited from GRINS::BCBuilder
static bool	is_new_bc_input_style (const GetPot &input)

static libMesh::UniquePtr< BCBuilder >	build_builder (const GetPot &input)

Detailed Description

Manages runtime construction of Dirichlet boundary conditions.

This will parse the input for the request Dirichlet boundary conditions and manage their construction. Actual construction of the DirichletBoundary objects is delegated to factory classes. This builder classes merely manages tasks around the factories as needed. To add new Dirichlet boundary conditions, the user should instantiate an appropriate factory sub class.

Definition at line 47 of file default_bc_builder.h.

Constructor & Destructor Documentation

GRINS::DefaultBCBuilder::DefaultBCBuilder ( )

inline

Definition at line 52 of file default_bc_builder.h.

       : BCBuilder(),
         BuilderHelper()
     {};

GRINS::DefaultBCBuilder::~DefaultBCBuilder ( )

inline

Definition at line 57 of file default_bc_builder.h.

57 {};

Member Function Documentation

void GRINS::DefaultBCBuilder::build_axisymmetric_bcs	(	const GetPot &	input,
		MultiphysicsSystem &	system,
		const std::set< BoundaryID > &	bc_ids,
		libMesh::DofMap &	dof_map,
		const std::string &	bc_type,
		std::set< std::string > &	var_sections,
		std::vector< SharedPtr< NeumannBCContainer > > &	neumann_bcs
	)

protected

Definition at line 142 of file default_bc_builder.C.

References GRINS::BCBuilder::construct_dbc_core(), GRINS::BCBuilder::construct_nbc_core(), GRINS::GRINSPrivate::VariableWarehouse::get_variable(), GRINS::FEVariablesBase::is_constraint_var(), GRINS::BCBuilder::is_dirichlet_bc_type(), and GRINS::BCBuilder::is_neumann_bc_type().

Referenced by build_type_based_bcs().

   {
     // Axisymmetric depends on the variable type.
     // So, we loop over all the Variable names and prepend the type
     // with the variable name. So, the factories for axisymmetric
     // need to be instantiated with, e.g., Velocity_axisymmetric
     for( std::set<std::string>::const_iterator vars = var_sections.begin();
          vars != var_sections.end(); ++vars )
       {
         const std::string& var_section = *vars;
 
         // Grab FEVariable
         const FEVariablesBase& fe_var =
           GRINS::GRINSPrivate::VariableWarehouse::get_variable(var_section);
 
         // We don't need to do anything for constraint variables
         if( fe_var.is_constraint_var() )
           continue;
 
         std::string full_bc_type = var_section+"_"+bc_type;
 
         // Axisymmetric is Dirichlet or Neumann, depending on the Variable
         if( this->is_dirichlet_bc_type(full_bc_type) )
           {
             this->construct_dbc_core( input,
                                       system,
                                       bc_ids,
                                       fe_var,
                                       std::string("dummy"), // No section needed for axisymmetric
                                       full_bc_type,
                                       dof_map );
           }
         else if( this->is_neumann_bc_type(full_bc_type) )
           {
             this->construct_nbc_core( input,
                                       system,
                                       bc_ids,
                                       fe_var,
                                       std::string("dummy"), // No section needed for axisymmetric
                                       full_bc_type,
                                       neumann_bcs );
           }
         else
           libmesh_error_msg("ERROR! Invalid axisymmetric type: "+full_bc_type);
       }
   }

void GRINS::DefaultBCBuilder::build_bc_to_subdomain_map_check_with_mesh	(	const MultiphysicsSystem &	system,
		std::map< BoundaryID, std::vector< libMesh::subdomain_id_type > > &	bc_id_to_subdomain_id_map
	)		const

protected

Build up bc_id to subdomain_id map.

we also check and make sure that there's only one subdomain id per boundary id. If not, we throw an error.

Definition at line 463 of file default_bc_builder.C.

Referenced by build_bcs().

   {
     std::vector<libMesh::dof_id_type> elem_ids;
     std::vector<unsigned short int> side_ids;
     std::vector<BoundaryID> bc_ids;
 
     const libMesh::MeshBase& mesh = system.get_mesh();
 
     // Extract the list of elements on the boundary
     mesh.get_boundary_info().build_active_side_list( elem_ids, side_ids, bc_ids );
 
     libmesh_assert_equal_to( elem_ids.size(), side_ids.size() );
     libmesh_assert_equal_to( elem_ids.size(), bc_ids.size() );
 
     for( unsigned int i = 0; i < elem_ids.size(); i++ )
       {
         const libMesh::Elem* elem_ptr = mesh.elem_ptr(elem_ids[i]);
 
         libMesh::subdomain_id_type subdomain_id = elem_ptr->subdomain_id();
 
         std::map<BoundaryID,std::vector<libMesh::subdomain_id_type> >::iterator
           map_it = bc_id_to_subdomain_id_map.find(bc_ids[i]);
 
         if( map_it == bc_id_to_subdomain_id_map.end() )
           {
             std::vector<libMesh::subdomain_id_type> sid(1,subdomain_id);
             bc_id_to_subdomain_id_map.insert(std::make_pair(bc_ids[i],sid));
           }
         else
           {
             std::vector<libMesh::subdomain_id_type>& sids = map_it->second;
             bool found_sid = false;
 
             for( unsigned int i = 0; i < sids.size(); i++ )
               {
                 if( sids[i] == subdomain_id )
                   found_sid = true;
               }
 
             if( !found_sid && (sids.size() > 2) )
               libmesh_error_msg("ERROR: How do you have more than 2 subdomain ids for a boundary id?!");
             else if( !found_sid && sids.size() < 2 )
               sids.push_back(subdomain_id);
           }
       }
   }

void GRINS::DefaultBCBuilder::build_bcs	(	const GetPot &	input,
		MultiphysicsSystem &	system,
		std::vector< SharedPtr< NeumannBCContainer > > &	neumann_bcs
	)

protectedvirtual

Implements GRINS::BCBuilder.

Definition at line 46 of file default_bc_builder.C.

References GRINS::BoundaryConditionNames::bc_section(), build_bc_to_subdomain_map_check_with_mesh(), build_bcs_by_var_section(), build_type_based_bcs(), parse_and_build_bc_id_map(), GRINS::BuilderHelper::parse_var_sections(), and verify_bc_ids_with_mesh().

   {
     libMesh::DofMap& dof_map = system.get_dof_map();
 
     // Setup map between boundary section name and the boundary ids
     std::map<std::string,std::set<BoundaryID> > bc_id_map;
     this->parse_and_build_bc_id_map( input, bc_id_map );
 
     // The user must have mapped all boundary ids present in the mesh.
     // Additionally, they can't have specified an boundary id that doesn't
     // exist.
     this->verify_bc_ids_with_mesh( system, bc_id_map );
 
     // Parse variable sections. These correspond to the names of FEVariables
     // We will be looking for all variable sections in all boundary sections
     // that are not "constraint" variables (i.e. FEVariablesBase::_is_constraint)
     std::set<std::string> var_sections;
     this->parse_var_sections( input, var_sections );
 
     // Cache the map between boundary ids and subdomain ids
     // We map to a vector because it's possible to have an "interface"
     // boundary id that touches multiple elements with differing
     // subdomain ids
     std::map<BoundaryID,std::vector<libMesh::subdomain_id_type> >
       bc_id_to_subdomain_id_map;
 
     this->build_bc_to_subdomain_map_check_with_mesh( system,
                                                      bc_id_to_subdomain_id_map );
 
     for( std::map<std::string,std::set<BoundaryID> >::const_iterator bc_it = bc_id_map.begin();
          bc_it != bc_id_map.end(); ++bc_it )
       {
         const std::string& bc_name = bc_it->first;
 
         const std::set<BoundaryID>& bc_ids = bc_it->second;
 
         // Check for special types of boundary conditions that can be
         // specified as a single type that applies to all boundaries
         std::string type_input_section = BoundaryConditionNames::bc_section()+"/"+bc_name;
         std::string type_input = type_input_section+"/type";
 
         if( input.have_variable(type_input) )
           {
             this->build_type_based_bcs(input,system,bc_ids,dof_map,
                                        type_input_section,var_sections,
                                        neumann_bcs);
           }
         // Otherwise, we look for each Variable section and the
         // boundary conditions specified therein
         else
           {
             this->build_bcs_by_var_section(input,system,bc_name,bc_ids,dof_map,
                                            var_sections,bc_id_to_subdomain_id_map,
                                            neumann_bcs);
           }
       }
   }

void GRINS::DefaultBCBuilder::build_bcs_by_var_section	(	const GetPot &	input,
		MultiphysicsSystem &	system,
		const std::string &	bc_name,
		const std::set< BoundaryID > &	bc_ids,
		libMesh::DofMap &	dof_map,
		std::set< std::string > &	var_sections,
		const std::map< BoundaryID, std::vector< libMesh::subdomain_id_type > > &	bc_id_to_subdomain_id_map,
		std::vector< SharedPtr< NeumannBCContainer > > &	neumann_bcs
	)

protected

Helper function to build boundary conditions using Variable sections.

This is the "standard" part. We parse for each Variable section that should have boundary conditions and then parse the boundary condition type.

Definition at line 195 of file default_bc_builder.C.

References GRINS::BoundaryConditionNames::bc_section(), GRINS::BCBuilder::construct_dbc_core(), GRINS::BCBuilder::construct_nbc_core(), GRINS::GRINSPrivate::VariableWarehouse::get_variable(), GRINS::FEVariablesBase::is_constraint_var(), GRINS::BCBuilder::is_dirichlet_bc_type(), GRINS::BCBuilder::is_neumann_bc_type(), and is_var_active().

Referenced by build_bcs().

   {
     for( std::set<std::string>::const_iterator vars = var_sections.begin();
          vars != var_sections.end(); ++vars )
       {
         const std::string& var_section = *vars;
 
         // Setup the input section we're in. We use this, but
         // this is also the section where the BCFactory will try
         // to parse the values, if it needs to, so let's set up
         // once and reuse it.
         std::string input_section = std::string(BoundaryConditionNames::bc_section()+"/"+bc_name+"/"+var_section);
 
         // All the boundary ids have the same subdomain id (this is checked
         // earlier), so just grab the first one
         std::map<BoundaryID,std::vector<libMesh::subdomain_id_type> >::const_iterator
           subdomain_ids_iter = bc_id_to_subdomain_id_map.find(*bc_ids.begin());
 
         // If we're on a DistributedMesh we might need to learn about
         // subdomain ids from other processors.
         std::vector<libMesh::subdomain_id_type> subdomain_ids;
         if (subdomain_ids_iter != bc_id_to_subdomain_id_map.end())
           subdomain_ids = subdomain_ids_iter->second;
         system.comm().allgather(subdomain_ids);
         std::sort( subdomain_ids.begin(), subdomain_ids.end() );
         subdomain_ids.erase
           (std::unique(subdomain_ids.begin(), subdomain_ids.end()),
            subdomain_ids.end() );
 
         // Grab the FEVariable
         const FEVariablesBase& fe_var =
           GRINSPrivate::VariableWarehouse::get_variable(var_section);
 
         bool var_active = this->is_var_active( fe_var, subdomain_ids );
 
         // If the variable is *not* active and the section is there,
         // that's an error.
         if( !var_active && input.have_section(input_section) )
           {
             std::stringstream error_msg;
             error_msg << "ERROR: Cannot specify boundary condition for variable "
                       << var_section << " on boundary " << bc_name << std::endl
                       << "since it is inactive on the subdomain associated "
                       << "with this boundary." <<  std::endl;
             libmesh_error_msg(error_msg.str());
           }
 
         // Make sure this section is there,
         // unless that variable is a constraint variable
         // or it's not enabled on this subdomain
         if( !input.have_section(input_section) )
           {
             if( fe_var.is_constraint_var() || !var_active )
               continue;
             else
               libmesh_error_msg("ERROR: Could not find boundary condition specification for "+input_section+"!");
 
           }
 
         // Grab the type of the boundary condition
         // There may be more than one type (e.g. pin displacement in
         // two directions and load in the third direction).
         std::string bc_type_section = input_section+"/type";
         unsigned int n_bc_types = input.vector_variable_size(bc_type_section);
 
         for( unsigned int bc_type_idx = 0; bc_type_idx < n_bc_types; bc_type_idx++ )
           {
             std::string bc_type = input(bc_type_section, std::string("DIE!"), bc_type_idx);
 
             if( this->is_dirichlet_bc_type(bc_type) )
               {
                 this->construct_dbc_core( input,system, bc_ids,
                                           fe_var, input_section,
                                           bc_type, dof_map );
               }
             else if( this->is_neumann_bc_type(bc_type) )
               {
                 this->construct_nbc_core( input,system, bc_ids,
                                           fe_var, input_section,
                                           bc_type, neumann_bcs );
               }
             else
               libmesh_error_msg("ERROR: Invalid bc_type "+bc_type+"!");
 
           } // end loop over bc_types
 
       } // end loop over variable sections
   }

void GRINS::DefaultBCBuilder::build_periodic_bc	(	const GetPot &	input,
		libMesh::System &	system,
		const std::set< BoundaryID > &	bc_ids,
		const std::string &	section
	)

protected

Definition at line 384 of file default_bc_builder.C.

References GRINS::BCBuilder::add_periodic_bc_to_dofmap(), parse_periodic_master_slave_ids(), and parse_periodic_offset().

Referenced by build_type_based_bcs().

   {
     // Make sure we're not using a ParallelMesh
     // https://github.com/libMesh/libmesh/issues/977
     const libMesh::MeshBase& mesh = system.get_mesh();
     const libMesh::ParallelMesh* pmesh = dynamic_cast<const libMesh::ParallelMesh*>(&mesh);
     if(pmesh)
       {
         std::stringstream error_msg;
         error_msg << "ERROR: Cannot use ParallelMesh with periodic boundary conditions!"
                   << std::endl
                   << "       See https://github.com/libMesh/libmesh/issues/977 for discussion."
                   << std::endl;
         libmesh_error_msg(error_msg.str());
       }
 
     libMesh::boundary_id_type invalid_bid =
       std::numeric_limits<libMesh::boundary_id_type>::max();
 
     libMesh::boundary_id_type slave_id = invalid_bid;
     libMesh::boundary_id_type master_id = invalid_bid;
 
     this->parse_periodic_master_slave_ids(input,section,master_id,slave_id);
 
     if( bc_ids.find(slave_id) == bc_ids.end() ||
         bc_ids.find(master_id) == bc_ids.end() )
       libmesh_error_msg("ERROR: Mismatch between bc_ids and master/slave ids for perioid bcs!");
 
     libMesh::RealVectorValue offset_vector =
       this->parse_periodic_offset(input,section);
 
     libMesh::DofMap& dof_map = system.get_dof_map();
 
     this->add_periodic_bc_to_dofmap( master_id, slave_id, offset_vector, dof_map );
   }

void GRINS::DefaultBCBuilder::build_type_based_bcs	(	const GetPot &	input,
		MultiphysicsSystem &	system,
		const std::set< BoundaryID > &	bc_ids,
		libMesh::DofMap &	dof_map,
		const std::string &	type_input_section,
		std::set< std::string > &	var_sections,
		std::vector< SharedPtr< NeumannBCContainer > > &	neumann_bcs
	)

protected

Helper function to build boundary conditions specified by a single type.

Examples include axisymmetric and periodic.

Definition at line 105 of file default_bc_builder.C.

References GRINS::BoundaryConditionNames::axisymmetric(), build_axisymmetric_bcs(), build_periodic_bc(), GRINS::Physics::is_axisymmetric(), and GRINS::BoundaryConditionNames::periodic().

Referenced by build_bcs().

   {
     std::string type_input = type_input_section+"/type";
     std::string bc_type = input( type_input, std::string("DIE!") );
 
     if( bc_type == BoundaryConditionNames::axisymmetric() )
       {
         // Check and make sure the Physics thinks it's axisymmetric, otherwise error
         if( !Physics::is_axisymmetric() )
           libmesh_error_msg("ERROR: Must specify Physics/is_axisymmetric = true for axisymmetric BC!");
 
         // Now build the boundary condition
         this->build_axisymmetric_bcs(input,system,bc_ids,dof_map,
                                      bc_type,var_sections,neumann_bcs);
       }
     else if( bc_type == BoundaryConditionNames::periodic() )
       {
         this->build_periodic_bc(input,system,bc_ids,type_input_section);
       }
     else
       {
         std::string error_msg = "ERROR: Invalid type '"+bc_type+"' for "+type_input+"!\n";
         error_msg += "       Valid values are: "+BoundaryConditionNames::axisymmetric()+"\n";
         error_msg += "                         "+BoundaryConditionNames::periodic()+"\n";
         error_msg += "       If your boundary condition is not one of these types, then \n";
         error_msg += "       you must specify the boundary condition type for each Variable\n";
         error_msg += "       section. Please have a look at the examples.\n";
         libmesh_error_msg(error_msg);
       }
   }

bool GRINS::DefaultBCBuilder::is_var_active	(	const FEVariablesBase &	var,
		const std::vector< libMesh::subdomain_id_type > &	subdomain_ids
	)		const

protected

Check if the Variable var is active on the given subdomain_id.

Definition at line 511 of file default_bc_builder.C.

References GRINS::FEVariablesBase::subdomain_ids().

Referenced by build_bcs_by_var_section().

   {
     bool var_active = false;
 
     // If the var subdomain_ids are empty, then this var is active
     // on the whole domain and we don't need to do anything
     if( var.subdomain_ids().empty() )
       var_active = true;
 
     else
       {
         // Now check if this variable is enabled on this subdomain
         const std::set<libMesh::subdomain_id_type>& var_subdomain_ids =
           var.subdomain_ids();
 
         for(std::vector<libMesh::subdomain_id_type>::const_iterator id = subdomain_ids.begin(); id < subdomain_ids.end(); ++id )
           {
             if( var_subdomain_ids.find(*id) != var_subdomain_ids.end() )
               var_active = true;
           }
       }
 
     return var_active;
   }

void GRINS::DefaultBCBuilder::parse_and_build_bc_id_map	(	const GetPot &	input,
		std::map< std::string, std::set< BoundaryID > > &	bc_id_map
	)

protected

Definition at line 291 of file default_bc_builder.C.

References GRINS::BoundaryConditionNames::bc_id_name_map_var(), GRINS::BoundaryConditionNames::bc_ids_var(), and GRINS::StringUtilities::split_string().

Referenced by build_bcs(), GRINSTesting::DefaultBCBuilderTest::test_parse_and_build_bc_id_map(), and GRINSTesting::DefaultBCBuilderTest::test_verify_bc_ids_with_mesh().

   {
     // First, make sure the proper input variables have been set
     if( !input.have_variable(BoundaryConditionNames::bc_ids_var()) ||
         !input.have_variable(BoundaryConditionNames::bc_id_name_map_var()) )
       {
         std::string error_msg = "ERROR: Must specify both "+BoundaryConditionNames::bc_ids_var();
         error_msg += " and "+BoundaryConditionNames::bc_id_name_map_var()+"!";
         libmesh_error_msg(error_msg);
       }
 
     // Make sure the vectors are the same size
     unsigned int n_ids = input.vector_variable_size(BoundaryConditionNames::bc_ids_var());
     unsigned int n_names = input.vector_variable_size(BoundaryConditionNames::bc_id_name_map_var());
 
     if( n_ids != n_names )
       libmesh_error_msg("ERROR: Must have matching number of boundary id sets and boundary names!");
 
     // We'll build this up along the way and then double check
     // that we have a one-to-one match with the boundary ids
     // that the mesh knows about
     std::set<BoundaryID> all_bc_ids;
 
     // Now build up the map
     for( unsigned int i = 0; i < n_names; i++ )
       {
         std::string bc_name = input(BoundaryConditionNames::bc_id_name_map_var(),std::string("DIE!"),i);
         std::string bc_ids_input = input(BoundaryConditionNames::bc_ids_var(),std::string("DIE!"),i);
 
         // Users can group multiple bc_ids together with the ':' delimiter
         std::vector<std::string> bc_ids_str;
         StringUtilities::split_string( bc_ids_input, ":", bc_ids_str );
         std::set<BoundaryID> bc_ids;
 
         for(std::vector<std::string>::const_iterator it = bc_ids_str.begin();
             it < bc_ids_str.end(); ++it )
           {
             BoundaryID id = StringUtilities::string_to_T<BoundaryID>(*it);
 
             // Can only specify a boundary id once
             if( (bc_ids.find(id) != bc_ids.end()) ||
                 (all_bc_ids.find(id) != all_bc_ids.end())   )
               libmesh_error_msg("ERROR: Can only specify a boundary ID once!");
 
             bc_ids.insert(id);
             all_bc_ids.insert(id);
           }
 
         // Insert pair into the bc_id_map
         bc_id_map.insert( std::make_pair( bc_name, bc_ids ) );
       }
   }

void GRINS::DefaultBCBuilder::parse_periodic_master_slave_ids	(	const GetPot &	input,
		const std::string &	section,
		libMesh::boundary_id_type &	master_id,
		libMesh::boundary_id_type &	slave_id
	)		const

protected

Definition at line 424 of file default_bc_builder.C.

Referenced by build_periodic_bc(), and GRINSTesting::DefaultBCBuilderTest::test_parse_periodic_master_slave_ids().

   {
     if( !input.have_variable(section+"/master_id") )
       libmesh_error_msg("ERROR: Could not find master_id in section "+section);
 
     if( !input.have_variable(section+"/slave_id") )
       libmesh_error_msg("ERROR: Could not find slave_id in section "+section);
 
     libMesh::boundary_id_type invalid_bid =
       std::numeric_limits<libMesh::boundary_id_type>::max();
 
     master_id = input(section+"/master_id", invalid_bid);
     slave_id = input(section+"/slave_id", invalid_bid);
   }

libMesh::RealVectorValue GRINS::DefaultBCBuilder::parse_periodic_offset	(	const GetPot &	input,
		const std::string &	section
	)		const

protected

Definition at line 442 of file default_bc_builder.C.

Referenced by build_periodic_bc(), and GRINSTesting::DefaultBCBuilderTest::test_parse_periodic_offset().

   {
     std::string input_section = section+"/boundary_offset";
     if( !input.have_variable(input_section) )
       libmesh_error_msg("ERROR: Could not find boundary_offset in section "+section);
 
     unsigned int n_comps = input.vector_variable_size(input_section);
 
     if( n_comps > 3 )
       libmesh_error_msg("ERROR: Cannot specify more than 3 components for boundary_offset!");
 
     libMesh::RealVectorValue offset;
     libMesh::Real invalid_real = std::numeric_limits<libMesh::Real>::max();
 
     for( unsigned int i = 0; i < n_comps; i++ )
       offset(i) = input(input_section, invalid_real, i );
 
     return offset;
   }

void GRINS::DefaultBCBuilder::verify_bc_ids_with_mesh	(	const MultiphysicsSystem &	system,
		const std::map< std::string, std::set< BoundaryID > > &	bc_id_map
	)		const

protected

Definition at line 345 of file default_bc_builder.C.

Referenced by build_bcs(), and GRINSTesting::DefaultBCBuilderTest::test_verify_bc_ids_with_mesh().

   {
     const libMesh::MeshBase& mesh = system.get_mesh();
     const libMesh::BoundaryInfo& boundary_info = mesh.get_boundary_info();
 
     std::set<BoundaryID> mesh_ids = boundary_info.get_boundary_ids();
     mesh.comm().set_union(mesh_ids);
 
     // Collect all the bc_ids into one set so we can just compare the sets
     std::set<BoundaryID> all_ids;
 
     for( std::map<std::string,std::set<BoundaryID> >::const_iterator bc_it = bc_id_map.begin();
          bc_it != bc_id_map.end(); ++bc_it )
       all_ids.insert( (bc_it->second).begin(), (bc_it->second).end() );
 
     if( mesh_ids != all_ids )
       {
         std::string err_msg = "ERROR: Mismatch between specified boundary ids and the boundary ids in the mesh!\n";
         err_msg += "User specified ids: ";
 
         for( std::set<BoundaryID>::const_iterator it = all_ids.begin();
              it != all_ids.end(); ++it )
           err_msg += StringUtilities::T_to_string<BoundaryID>(*it)+" ";
 
         err_msg += "\n";
 
         err_msg += "Mesh specified ids: ";
 
         for( std::set<BoundaryID>::const_iterator it = mesh_ids.begin();
              it != mesh_ids.end(); ++it )
           err_msg += StringUtilities::T_to_string<BoundaryID>(*it)+" ";
 
         err_msg += "\n";
 
         libmesh_error_msg(err_msg);
       }
   }

The documentation for this class was generated from the following files:

src/boundary_conditions/include/grins/default_bc_builder.h
src/boundary_conditions/src/default_bc_builder.C

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation