boundary_info.h

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2026 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
 
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
 
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
 
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 
 
#ifndef LIBMESH_BOUNDARY_INFO_H
#define LIBMESH_BOUNDARY_INFO_H
 
// Local includes
#include "libmesh/libmesh_common.h"
#include "libmesh/id_types.h"
#include "libmesh/parallel_object.h"
 
// C++ includes
#include <cstddef>
#include <map>
#include <set>
#include <vector>
#include <tuple>
 
namespace libMesh
{
 
 
// Forward declarations
class Elem;
class Node;
class MeshBase;
class UnstructuredMesh;
 
 
class BoundaryInfo : public ParallelObject
{
protected:
  friend class MeshBase;
 
  BoundaryInfo (MeshBase & m);
 
  void set_mesh (MeshBase & m) { _mesh = &m; }
 
public:
  BoundaryInfo & operator=(const BoundaryInfo & other_boundary_info);
 
  bool operator== (const BoundaryInfo & other_boundary_info) const;
 
  bool operator!= (const BoundaryInfo & other_boundary_info) const
  {
    return !(*this == other_boundary_info);
  }
 
  ~BoundaryInfo ();
 
  void clear ();
 
  void regenerate_id_sets ();
 
  void synchronize_global_id_set ();
 
  void sync (UnstructuredMesh & boundary_mesh);
 
  void sync (const std::set<boundary_id_type> & requested_boundary_ids,
             UnstructuredMesh & boundary_mesh);
 
  void sync (const std::set<boundary_id_type> & requested_boundary_ids,
             UnstructuredMesh & boundary_mesh,
             const std::set<subdomain_id_type> & subdomains_relative_to);
 
  void get_side_and_node_maps (UnstructuredMesh & boundary_mesh,
                               std::map<dof_id_type, dof_id_type> & node_id_map,
                               std::map<dof_id_type, unsigned char> & side_id_map,
                               Real tolerance=1.e-6);
 
  void add_elements (const std::set<boundary_id_type> & requested_boundary_ids,
                     UnstructuredMesh & boundary_mesh,
                     bool store_parent_side_ids = false,
                     const std::vector<subdomain_id_type> & new_subdomain_ids = {});
 
  void add_elements(const std::set<boundary_id_type> & requested_boundary_ids,
                    UnstructuredMesh & boundary_mesh,
                    const std::set<subdomain_id_type> & subdomains_relative_to,
                    bool store_parent_side_ids = false,
                    const std::vector<subdomain_id_type> & new_subdomain_ids = {});
 
  void add_node (const Node * node,
                 const boundary_id_type id);
 
  void add_node (const dof_id_type node,
                 const boundary_id_type id);
 
  void add_node (const Node * node,
                 const std::vector<boundary_id_type> & ids);
 
  void clear_boundary_node_ids();
 
  void add_edge (const dof_id_type elem,
                 const unsigned short int edge,
                 const boundary_id_type id);
 
  void add_edge (const Elem * elem,
                 const unsigned short int edge,
                 const boundary_id_type id);
 
  void add_edge (const Elem * elem,
                 const unsigned short int edge,
                 const std::vector<boundary_id_type> & ids);
 
  void add_shellface (const dof_id_type elem,
                      const unsigned short int shellface,
                      const boundary_id_type id);
 
  void add_shellface (const Elem * elem,
                      const unsigned short int shellface,
                      const boundary_id_type id);
 
  void add_shellface (const Elem * elem,
                      const unsigned short int shellface,
                      const std::vector<boundary_id_type> & ids);
 
  void add_side (const dof_id_type elem,
                 const unsigned short int side,
                 const boundary_id_type id);
 
  void add_side (const Elem * elem,
                 const unsigned short int side,
                 const boundary_id_type id);
 
  void add_side (const Elem * elem,
                 const unsigned short int side,
                 const std::vector<boundary_id_type> & ids);
 
  void remove (const Node * node);
 
  void remove (const Elem * elem);
 
  void remove_node (const Node * node,
                    const boundary_id_type id);
 
  void remove_edge (const Elem * elem,
                    const unsigned short int edge);
 
  void remove_edge (const Elem * elem,
                    const unsigned short int edge,
                    const boundary_id_type id);
 
  void remove_shellface (const Elem * elem,
                         const unsigned short int shellface);
 
  void remove_shellface (const Elem * elem,
                         const unsigned short int shellface,
                         const boundary_id_type id);
 
  void remove_side (const Elem * elem,
                    const unsigned short int side);
 
  void remove_side (const Elem * elem,
                    const unsigned short int side,
                    const boundary_id_type id);
 
  void clear_stitched_boundary_side_ids (boundary_id_type sideset_id,
                                         boundary_id_type other_sideset_id,
                                         bool clear_nodeset_data = false);
 
  void remove_id (boundary_id_type id, bool global = false);
 
  void remove_side_id (boundary_id_type id, bool global = false);
 
  void remove_edge_id (boundary_id_type id, bool global = false);
 
  void remove_shellface_id (boundary_id_type id, bool global = false);
 
  void remove_node_id (boundary_id_type id, bool global = false);
 
  void renumber_id (boundary_id_type old_id, boundary_id_type new_id);
 
  void renumber_side_id (boundary_id_type old_id, boundary_id_type new_id);
 
  void renumber_edge_id (boundary_id_type old_id, boundary_id_type new_id);
 
  void renumber_shellface_id (boundary_id_type old_id, boundary_id_type new_id);
 
  void renumber_node_id (boundary_id_type old_id, boundary_id_type new_id);
 
  std::size_t n_boundary_ids () const { return _boundary_ids.size(); }
 
  bool has_boundary_id (const Node * const node,
                        const boundary_id_type id) const;
 
  void boundary_ids (const Node * node,
                     std::vector<boundary_id_type> & vec_to_fill) const;
 
  unsigned int n_boundary_ids (const Node * node) const;
 
  unsigned int n_edge_boundary_ids (const Elem * const elem,
                                    const unsigned short int edge) const;
 
  void edge_boundary_ids (const Elem * const elem,
                          const unsigned short int edge,
                          std::vector<boundary_id_type> & vec_to_fill) const;
 
  void raw_edge_boundary_ids (const Elem * const elem,
                              const unsigned short int edge,
                              std::vector<boundary_id_type> & vec_to_fill) const;
 
  unsigned int n_shellface_boundary_ids (const Elem * const elem,
                                         const unsigned short int shellface) const;
 
  void shellface_boundary_ids (const Elem * const elem,
                               const unsigned short int shellface,
                               std::vector<boundary_id_type> & vec_to_fill) const;
 
  void raw_shellface_boundary_ids (const Elem * const elem,
                                   const unsigned short int shellface,
                                   std::vector<boundary_id_type> & vec_to_fill) const;
 
  bool has_boundary_id (const Elem * const elem,
                        const unsigned short int side,
                        const boundary_id_type id) const;
 
  unsigned int n_boundary_ids (const Elem * const elem,
                               const unsigned short int side) const;
 
  unsigned int n_raw_boundary_ids (const Elem * const elem,
                                   const unsigned short int side) const;
 
  void side_boundary_ids (const Elem * const elem,
                          std::vector<std::vector<boundary_id_type>> & vec_to_fill) const;
 
  void boundary_ids (const Elem * const elem,
                     const unsigned short int side,
                     std::vector<boundary_id_type> & vec_to_fill) const;
 
  void raw_boundary_ids (const Elem * const elem,
                         const unsigned short int side,
                         std::vector<boundary_id_type> & vec_to_fill) const;
 
  /*
   * Copy boundary ids associated with old_elem (but not its nodes)
   * from old_boundary_info (which may be this) into this boundary
   * info, associating them with new_elem.
   */
  void copy_boundary_ids (const BoundaryInfo & old_boundary_info,
                          const Elem * const old_elem,
                          const Elem * const new_elem);
 
  unsigned int side_with_boundary_id(const Elem * const elem,
                                     const boundary_id_type boundary_id) const;
 
  std::vector<unsigned int>
  sides_with_boundary_id(const Elem * const elem,
                         const boundary_id_type boundary_id) const;
 
  void build_node_boundary_ids(std::vector<boundary_id_type> & b_ids) const;
 
  void build_side_boundary_ids(std::vector<boundary_id_type> & b_ids) const;
 
  void build_shellface_boundary_ids(std::vector<boundary_id_type> & b_ids) const;
 
#ifdef LIBMESH_ENABLE_AMR
  void transfer_boundary_ids_from_children(const Elem * const parent);
#endif
 
  std::size_t n_boundary_conds () const;
 
  std::size_t n_edge_conds () const;
 
  std::size_t n_shellface_conds () const;
 
  std::size_t n_nodeset_conds () const;
 
  typedef std::tuple<dof_id_type, boundary_id_type> NodeBCTuple;
  enum class NodeBCTupleSortBy {NODE_ID, BOUNDARY_ID, UNSORTED};
  std::vector<NodeBCTuple> build_node_list(NodeBCTupleSortBy sort_by = NodeBCTupleSortBy::NODE_ID) const;
 
  void build_node_list_from_side_list(const std::set<boundary_id_type> & sideset_list = {});
 
  void build_side_list_from_node_list(const std::set<boundary_id_type> & nodeset_list = {});
 
  typedef std::tuple<dof_id_type, unsigned short int, boundary_id_type> BCTuple;
  enum class BCTupleSortBy {ELEM_ID, SIDE_ID, BOUNDARY_ID, UNSORTED};
  std::vector<BCTuple> build_side_list(BCTupleSortBy sort_by = BCTupleSortBy::ELEM_ID) const;
 
  std::vector<BCTuple> build_active_side_list () const;
 
  std::vector<BCTuple> build_edge_list() const;
 
  std::vector<BCTuple> build_shellface_list() const;
 
  void parallel_sync_side_ids();
  void parallel_sync_node_ids();
 
  const std::set<boundary_id_type> & get_boundary_ids () const
  { return _boundary_ids; }
 
  const std::set<boundary_id_type> & get_global_boundary_ids () const;
 
  const std::set<boundary_id_type> & get_side_boundary_ids () const
  { return _side_boundary_ids; }
 
  const std::set<boundary_id_type> & get_edge_boundary_ids () const
  { return _edge_boundary_ids; }
 
  const std::set<boundary_id_type> & get_shellface_boundary_ids () const
  { return _shellface_boundary_ids; }
 
  const std::set<boundary_id_type> & get_node_boundary_ids () const
  { return _node_boundary_ids; }
 
 
  void print_info (std::ostream & out_stream=libMesh::out) const;
 
  void print_summary (std::ostream & out_stream=libMesh::out) const;
 
  const std::string & get_sideset_name(boundary_id_type id) const;
 
  std::string & sideset_name(boundary_id_type id);
 
  const std::string & get_nodeset_name(boundary_id_type id) const;
 
  std::string & nodeset_name(boundary_id_type id);
 
  const std::string & get_edgeset_name(boundary_id_type id) const;
 
  std::string & edgeset_name(boundary_id_type id);
 
  boundary_id_type get_id_by_name(std::string_view name) const;
 
  std::map<boundary_id_type, std::string> & set_sideset_name_map ()
  { return _ss_id_to_name; }
  const std::map<boundary_id_type, std::string> & get_sideset_name_map () const
  { return _ss_id_to_name; }
 
  std::map<boundary_id_type, std::string> & set_nodeset_name_map ()
  { return _ns_id_to_name; }
  const std::map<boundary_id_type, std::string> & get_nodeset_name_map () const
  { return _ns_id_to_name; }
 
  std::map<boundary_id_type, std::string> & set_edgeset_name_map ()
  { return _es_id_to_name; }
  const std::map<boundary_id_type, std::string> & get_edgeset_name_map () const
  { return _es_id_to_name; }
 
  static const boundary_id_type invalid_id;
 
  const std::multimap<const Node *, boundary_id_type> & get_nodeset_map () const
  { return _boundary_node_id; }
 
  const std::multimap<const Elem *, std::pair<unsigned short int, boundary_id_type>> & get_edgeset_map () const
  { return _boundary_edge_id; }
 
  const std::multimap<const Elem *, std::pair<unsigned short int, boundary_id_type>> & get_sideset_map() const
  { return _boundary_side_id; }
 
  bool is_children_on_boundary_side() const
  { return _children_on_boundary; }
 
  void allow_children_on_boundary_side(const bool children_on_boundary)
  { _children_on_boundary = children_on_boundary; }
 
private:
 
  void libmesh_assert_valid_multimaps() const;
 
  void _find_id_maps (const std::set<boundary_id_type> & requested_boundary_ids,
                      dof_id_type first_free_node_id,
                      std::map<dof_id_type, dof_id_type> * node_id_map,
                      dof_id_type first_free_elem_id,
                      std::map<std::pair<dof_id_type, unsigned char>, dof_id_type> * side_id_map,
                      const std::set<subdomain_id_type> & subdomains_relative_to);
 
  MeshBase * _mesh;
 
  std::multimap<const Node *,
                boundary_id_type> _boundary_node_id;
 
  std::multimap<const Elem *,
                std::pair<unsigned short int, boundary_id_type>>
  _boundary_edge_id;
 
  std::multimap<const Elem *,
                std::pair<unsigned short int, boundary_id_type>>
  _boundary_shellface_id;
 
  std::multimap<const Elem *,
                std::pair<unsigned short int, boundary_id_type>>
  _boundary_side_id;
 
  /*
   * Whether or not children elements are associated with any boundary
   * It is false by default. The flag will be turned on if `add_side`
   * function is called with a child element
   */
  bool _children_on_boundary;
 
  std::set<boundary_id_type> _boundary_ids;
 
  std::set<boundary_id_type> _global_boundary_ids;
 
  std::set<boundary_id_type> _side_boundary_ids;
 
  std::set<boundary_id_type> _edge_boundary_ids;
 
  std::set<boundary_id_type> _node_boundary_ids;
 
  std::set<boundary_id_type> _shellface_boundary_ids;
 
  std::map<boundary_id_type, std::string> _ss_id_to_name;
 
  std::map<boundary_id_type, std::string> _ns_id_to_name;
 
  std::map<boundary_id_type, std::string> _es_id_to_name;
};
 
} // namespace libMesh
 
#endif // LIBMESH_BOUNDARY_INFO_H