GRINS::OldStyleBCBuilder Class Reference

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

#include <old_style_bc_builder.h>

Inheritance diagram for GRINS::OldStyleBCBuilder:

Collaboration diagram for GRINS::OldStyleBCBuilder:

Public Member Functions
	OldStyleBCBuilder ()
	~OldStyleBCBuilder ()
Public Member Functions inherited from GRINS::BCBuilder
	BCBuilder ()
virtual	~BCBuilder ()

Protected Member Functions
virtual void	build_bcs (const GetPot &input, MultiphysicsSystem &system, std::vector< SharedPtr< NeumannBCContainer > > &neumann_bcs)
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)

Private Member Functions
const FEVariablesBase *	determine_variable_group (const std::string &raw_physics_name, const std::string &bc_type_str, std::string &var_section)
	Determine the FEVariable type from the raw_physics_name. More...
void	construct_bcs_old_style (const GetPot &input, MultiphysicsSystem &system, const std::string &raw_physics_name, const std::string &section_name, const std::string &bc_id_str, const std::string &bc_type_str, const std::string &bc_value_str, const std::string &bc_var_str, libMesh::DofMap &dof_map, std::vector< SharedPtr< NeumannBCContainer > > &neumann_bcs)
void	build_basic_physics (std::set< std::string > &physics_names)
void	build_vel_and_temp_physics (std::set< std::string > &physics_names)
void	build_reacting_physics (std::set< std::string > &physics_names)
template<typename FunctionType >
void	set_dirichlet_bc_factory_old_style_quantities (const std::string &bc_value_str, unsigned int value_idx, const std::vector< std::string > &var_names)
template<typename FunctionType >
void	set_neumann_bc_factory_old_style_quantities (const std::string &bc_value_str, unsigned int value_idx, const std::vector< std::string > &var_names)
void	build_periodic_bc (const GetPot &input, const std::string &section_name, BoundaryID bc_id, 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 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 40 of file old_style_bc_builder.h.

Constructor & Destructor Documentation

GRINS::OldStyleBCBuilder::OldStyleBCBuilder ( )

inline

Definition at line 44 of file old_style_bc_builder.h.

      : BCBuilder()
    {};

GRINS::OldStyleBCBuilder::~OldStyleBCBuilder ( )

inline

Definition at line 48 of file old_style_bc_builder.h.

{};

Member Function Documentation

void GRINS::OldStyleBCBuilder::build_basic_physics ( std::set< std::string > &  physics_names )

private

Definition at line 273 of file old_style_bc_builder.C.

References GRINS::PhysicsNaming::axisymmetric_heat_transfer(), GRINS::PhysicsNaming::convection_diffusion(), GRINS::PhysicsNaming::elastic_cable(), GRINS::PhysicsNaming::elastic_membrane(), GRINS::PhysicsNaming::heat_conduction(), GRINS::PhysicsNaming::heat_transfer(), GRINS::PhysicsNaming::incompressible_navier_stokes(), GRINS::PhysicsNaming::spalart_allmaras(), and GRINS::PhysicsNaming::stokes().

Referenced by build_bcs().

  {
    physics_names.insert(PhysicsNaming::incompressible_navier_stokes());
    physics_names.insert(PhysicsNaming::stokes());
    physics_names.insert(PhysicsNaming::elastic_membrane());
    physics_names.insert(PhysicsNaming::elastic_cable());
    physics_names.insert(PhysicsNaming::convection_diffusion());
    physics_names.insert(PhysicsNaming::spalart_allmaras());
    physics_names.insert(PhysicsNaming::axisymmetric_heat_transfer());
    physics_names.insert(PhysicsNaming::heat_conduction());
    physics_names.insert(PhysicsNaming::heat_transfer());
  }

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

protectedvirtual

Implements GRINS::BCBuilder.

Definition at line 49 of file old_style_bc_builder.C.

References build_basic_physics(), build_reacting_physics(), build_vel_and_temp_physics(), construct_bcs_old_style(), GRINS::PhysicsNaming::extract_physics(), GRINS::MultiphysicsSystem::get_physics_list(), and grins_warning.

  {
    // Warn about deprecation of this horrid style
    {
      std::string warning = "WARNING: Specifying boundary conditions in the\n";
      warning += "         Physics sections is DEPRECATED! Please\n";
      warning += "         update your input file to new the newer\n";
      warning += "         style. See the examples for an illustration.\n";

      grins_warning(warning);
    }

    libMesh::DofMap& dof_map = system.get_dof_map();

    const PhysicsList& physics_list = system.get_physics_list();

    std::set<std::string> basic_physics;
    this->build_basic_physics(basic_physics);

    std::set<std::string> vel_and_temp_physics;
    this->build_vel_and_temp_physics(vel_and_temp_physics);

    std::set<std::string> reacting_physics;
    this->build_reacting_physics(reacting_physics);

    for( PhysicsListIter physics_iter = physics_list.begin();
         physics_iter != physics_list.end();
         physics_iter++ )
      {
        std::string physics_name = physics_iter->first;
        std::string raw_physics_name = PhysicsNaming::extract_physics(physics_name);

        std::string section_name = "Physics/"+physics_name;

        if( basic_physics.find( raw_physics_name ) != basic_physics.end() )
          {
            this->construct_bcs_old_style(input,
                                          system,
                                          raw_physics_name,
                                          section_name,
                                          "bc_ids",
                                          "bc_types",
                                          "bc_values",
                                          "bc_variables",
                                          dof_map,
                                          neumann_bcs);
          }

        if( (vel_and_temp_physics.find( raw_physics_name ) != vel_and_temp_physics.end()) ||
            (reacting_physics.find( raw_physics_name ) != reacting_physics.end()) )
          {
            this->construct_bcs_old_style(input,
                                          system,
                                          raw_physics_name,
                                          section_name,
                                          "vel_bc_ids",
                                          "vel_bc_types",
                                          "vel_bc_values",
                                          "vel_bc_variables",
                                          dof_map,
                                          neumann_bcs);

            this->construct_bcs_old_style(input,
                                          system,
                                          raw_physics_name,
                                          section_name,
                                          "temp_bc_ids",
                                          "temp_bc_types",
                                          "temp_bc_values",
                                          "temp_bc_variables",
                                          dof_map,
                                          neumann_bcs);
          }

        if( reacting_physics.find( raw_physics_name ) != reacting_physics.end() )
          {
            this->construct_bcs_old_style(input,
                                          system,
                                          raw_physics_name,
                                          section_name,
                                          "species_bc_ids",
                                          "species_bc_types",
                                          "species_bc_values",
                                          "species_bc_variables",
                                          dof_map,
                                          neumann_bcs);
          }
      }
  }

void GRINS::OldStyleBCBuilder::build_periodic_bc ( const GetPot &  input, const std::string &  section_name, BoundaryID  bc_id, libMesh::DofMap &  dof_map  )

private

Definition at line 296 of file old_style_bc_builder.C.

References GRINS::BCBuilder::add_periodic_bc_to_dofmap().

Referenced by construct_bcs_old_style().

  {
    std::string wall_input = section+"/periodic_wall_";
    wall_input += StringUtilities::T_to_string<BoundaryID>(bc_id);

    if( input.have_variable(wall_input) )
      {
        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;

        if( input.vector_variable_size(wall_input) != 2 )
          libmesh_error_msg("ERROR: "+wall_input+" must have only 2 components!");

        master_id = bc_id;

        if( input(wall_input,invalid_bid,0) == bc_id )
          slave_id = input(wall_input,invalid_bid,1);
        else
          slave_id = input(wall_input,invalid_bid,0);

        std::string offset_input = section+"/periodic_offset_";
        offset_input += StringUtilities::T_to_string<BoundaryID>(bc_id);

        if( !input.have_variable(offset_input) )
          libmesh_error_msg("ERROR: Could not find "+offset_input+"!");

        unsigned int n_comps = input.vector_variable_size(offset_input);

        libMesh::Real invalid_real = std::numeric_limits<libMesh::Real>::max();

        libMesh::RealVectorValue offset_vector;
        for( unsigned int i = 0; i < n_comps; i++ )
          offset_vector(i) = input(offset_input,invalid_real,i);

        this->add_periodic_bc_to_dofmap( master_id, slave_id,
                                         offset_vector, dof_map );
      }
  }

void GRINS::OldStyleBCBuilder::build_reacting_physics ( std::set< std::string > &  physics_names )

private

Definition at line 291 of file old_style_bc_builder.C.

References GRINS::PhysicsNaming::reacting_low_mach_navier_stokes().

Referenced by build_bcs().

  {
    physics_names.insert(PhysicsNaming::reacting_low_mach_navier_stokes());
  }

void GRINS::OldStyleBCBuilder::build_vel_and_temp_physics ( std::set< std::string > &  physics_names )

private

Definition at line 286 of file old_style_bc_builder.C.

References GRINS::PhysicsNaming::low_mach_navier_stokes().

Referenced by build_bcs().

  {
    physics_names.insert(PhysicsNaming::low_mach_navier_stokes());
  }

void GRINS::OldStyleBCBuilder::construct_bcs_old_style ( const GetPot &  input, MultiphysicsSystem &  system, const std::string &  raw_physics_name, const std::string &  section_name, const std::string &  bc_id_str, const std::string &  bc_type_str, const std::string &  bc_value_str, const std::string &  bc_var_str, libMesh::DofMap &  dof_map, std::vector< SharedPtr< NeumannBCContainer > > &  neumann_bcs  )

private

Definition at line 178 of file old_style_bc_builder.C.

References GRINS::FEVariablesBase::active_var_names(), build_periodic_bc(), GRINS::BCBuilder::construct_dbc_core(), GRINS::BCBuilder::construct_nbc_core(), determine_variable_group(), GRINS::BCBuilder::is_dirichlet_bc_type(), and GRINS::BCBuilder::is_neumann_bc_type().

Referenced by build_bcs().

  {
    unsigned int num_ids = input.vector_variable_size(section_name+"/"+bc_id_str);
    unsigned int num_types = input.vector_variable_size(section_name+"/"+bc_type_str);

    if( num_ids != num_types )
      libmesh_error_msg("Error: Must specify equal number of boundary ids and boundary conditions");

    for( unsigned int i = 0; i < num_ids; i++ )
      {
        // Parse the bc type, add "_old_style" at the end to distinguish for deprecated construction
        std::string bc_type = input(section_name+"/"+bc_type_str, std::string("DIE!"), i );
        bc_type += "_old_style";

        BoundaryID bc_id = input(section_name+"/"+bc_id_str, -1, i );

        // If this is a periodic boundary condition, we can immediately
        // apply and move to the next one
        if( bc_type == std::string("periodic_old_style") )
          {
            this->build_periodic_bc( input, section_name, bc_id, dof_map );
            continue;
          }

        // We use the set for compatibility with the BCFactories
        std::set<BoundaryID> bc_ids;
        bc_ids.insert(bc_id);

        std::string variable_group_name;

        const FEVariablesBase* fe_var_ptr = this->determine_variable_group( raw_physics_name,
                                                                            bc_type_str,
                                                                            variable_group_name );

        libmesh_assert(fe_var_ptr);

        // We need the var_names for the old style parsing
        std::vector<std::string> var_names;
        var_names = fe_var_ptr->active_var_names();

        // Axisymmetric is special. It depends on the variable type.
        // So, we prepend the type with the variable name in that
        // case.
        if( bc_type == "axisymmetric_old_style" )
          bc_type = variable_group_name+"_"+bc_type;


        // For these types of boundary conditions, we need to treat one
        // variable at a time, so extract the relevant one.
        if( bc_type == std::string("parsed_dirichlet_old_style") ||
            bc_type == std::string("constant_dirichlet_old_style") ||
            bc_type == std::string("parsed_fem_dirichlet_old_style") ||
            bc_type == std::string("parsed_neumann_old_style") )
          {
            var_names.clear();
            var_names.resize(1, input(section_name+"/"+bc_var_str, std::string("DIE!"), i ) );
          }

        if( this->is_dirichlet_bc_type(bc_type) )
          {
            // Tell the old style DirichletBCFactory where to parse the value of the BC
            this->set_dirichlet_bc_factory_old_style_quantities<libMesh::FunctionBase<libMesh::Number> >
              ( bc_value_str, i, var_names );
            this->set_dirichlet_bc_factory_old_style_quantities<libMesh::FEMFunctionBase<libMesh::Number> >
              ( bc_value_str, i, var_names );

            this->construct_dbc_core( input, system, bc_ids, *fe_var_ptr,
                                      section_name, bc_type, dof_map );
          }
        else if( this->is_neumann_bc_type(bc_type) )
          {
            // Tell the old style NeumannBCFactory where to parse the value of the BC
            this->set_neumann_bc_factory_old_style_quantities<libMesh::FunctionBase<libMesh::Number> >
              ( bc_value_str, i, var_names );
            this->set_neumann_bc_factory_old_style_quantities<libMesh::FEMFunctionBase<libMesh::Number> >
              ( bc_value_str, i, var_names );

            this->construct_nbc_core( input, system, bc_ids, *fe_var_ptr,
                                      section_name, bc_type, neumann_bcs );
          }
        else
          libmesh_error_msg("ERROR: Invalid bc_type "+bc_type+"!");

      }
  }

const FEVariablesBase * GRINS::OldStyleBCBuilder::determine_variable_group ( const std::string &  raw_physics_name, const std::string &  bc_type_str, std::string &  var_section  )

private

Determine the FEVariable type from the raw_physics_name.

This will set var_section and return the FEVariablesBase pointer. We do it this way, instead of a void function, to avoid a [-Wunused-but-set-parameter] warning on setting the FEVariablesBase pointer.

Definition at line 140 of file old_style_bc_builder.C.

References GRINS::PhysicsNaming::axisymmetric_heat_transfer(), GRINS::PhysicsNaming::convection_diffusion(), GRINS::VariablesParsing::displacement_section(), GRINS::PhysicsNaming::elastic_cable(), GRINS::PhysicsNaming::elastic_membrane(), GRINS::GRINSPrivate::VariableWarehouse::get_variable(), GRINS::PhysicsNaming::heat_conduction(), GRINS::PhysicsNaming::heat_transfer(), GRINS::PhysicsNaming::incompressible_navier_stokes(), GRINS::VariablesParsing::single_var_section(), GRINS::PhysicsNaming::spalart_allmaras(), GRINS::VariablesParsing::species_mass_fractions_section(), GRINS::PhysicsNaming::stokes(), GRINS::VariablesParsing::temperature_section(), GRINS::VariablesParsing::turbulence_section(), and GRINS::VariablesParsing::velocity_section().

Referenced by construct_bcs_old_style().

  {
    if( bc_type_str == std::string("bc_types") )
      {
        if( raw_physics_name == PhysicsNaming::incompressible_navier_stokes() ||
            raw_physics_name == PhysicsNaming::stokes() )
          var_section = VariablesParsing::velocity_section();
        else if( raw_physics_name == PhysicsNaming::heat_conduction() ||
                 raw_physics_name == PhysicsNaming::heat_transfer() ||
                 raw_physics_name == PhysicsNaming::axisymmetric_heat_transfer() )
          var_section = VariablesParsing::temperature_section();
        else if( raw_physics_name == PhysicsNaming::spalart_allmaras() )
          var_section = VariablesParsing::turbulence_section();
        else if( raw_physics_name == PhysicsNaming::elastic_membrane() ||
                 raw_physics_name == PhysicsNaming::elastic_cable() )
          var_section = VariablesParsing::displacement_section();
        else if( raw_physics_name == PhysicsNaming::convection_diffusion() )
          var_section = VariablesParsing::single_var_section()+":"+raw_physics_name;
        else
          libmesh_error();
      }
    else if( bc_type_str == std::string("vel_bc_types") )
      var_section = VariablesParsing::velocity_section();

    else if( bc_type_str == std::string("temp_bc_types") )
      var_section = VariablesParsing::temperature_section();

    else if( bc_type_str == std::string("species_bc_types") )
      var_section = VariablesParsing::species_mass_fractions_section();

    else
      libmesh_error();

    return &GRINSPrivate::VariableWarehouse::get_variable(var_section);
  }

template<typename FunctionType >

void GRINS::OldStyleBCBuilder::set_dirichlet_bc_factory_old_style_quantities ( const std::string &  bc_value_str, unsigned int  value_idx, const std::vector< std::string > &  var_names  )

private

Definition at line 342 of file old_style_bc_builder.C.

References GRINS::DirichletBCFactoryFunctionOldStyleBase< FunctionType >::set_value_index_old_style(), GRINS::DirichletBCFactoryFunctionOldStyleBase< FunctionType >::set_value_var_old_style(), and GRINS::DirichletBCFactoryFunctionOldStyleBase< FunctionType >::set_var_names_old_style().

  {
    DirichletBCFactoryFunctionOldStyleBase<FunctionType>::set_value_var_old_style( bc_value_str );
    DirichletBCFactoryFunctionOldStyleBase<FunctionType>::set_value_index_old_style( value_idx );
    DirichletBCFactoryFunctionOldStyleBase<FunctionType>::set_var_names_old_style( var_names );
  }

template<typename FunctionType >

void GRINS::OldStyleBCBuilder::set_neumann_bc_factory_old_style_quantities ( const std::string &  bc_value_str, unsigned int  value_idx, const std::vector< std::string > &  var_names  )

private

Definition at line 352 of file old_style_bc_builder.C.

References GRINS::NeumannBCOldStyleFactoryAbstract::set_value_index_old_style(), and GRINS::NeumannBCOldStyleFactoryAbstract::set_value_var_old_style().

  {
    ParsedFunctionNeumannOldStyleBCFactory<FunctionType>::set_value_var_old_style( bc_value_str );
    ParsedFunctionNeumannOldStyleBCFactory<FunctionType>::set_value_index_old_style( value_idx );
    //ParsedFunctionNeumannOldStyleBCFactory<FunctionType>::set_var_names_old_style( var_names );
  }

---

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

• src/boundary_conditions/include/grins/old_style_bc_builder.h
• src/boundary_conditions/src/old_style_bc_builder.C