boundary_info.h

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2018 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);

public:
  BoundaryInfo & operator=(const BoundaryInfo & other_boundary_info);


  ~BoundaryInfo ();

  void clear ();

  void regenerate_id_sets ();


  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);

  void add_elements(const std::set<boundary_id_type> & requested_boundary_ids,
                    UnstructuredMesh & boundary_mesh,
                    const std::set<subdomain_id_type> & subdomains_relative_to);

  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_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 remove_id (boundary_id_type 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;

#ifdef LIBMESH_ENABLE_DEPRECATED
  std::vector<boundary_id_type> boundary_ids (const Node * node) const;
#endif

  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;

#ifdef LIBMESH_ENABLE_DEPRECATED
  std::vector<boundary_id_type> edge_boundary_ids (const Elem * const elem,
                                                   const unsigned short int edge) const;
#endif

  void edge_boundary_ids (const Elem * const elem,
                          const unsigned short int edge,
                          std::vector<boundary_id_type> & vec_to_fill) const;

#ifdef LIBMESH_ENABLE_DEPRECATED
  std::vector<boundary_id_type> raw_edge_boundary_ids (const Elem * const elem,
                                                       const unsigned short int edge) const;
#endif

  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;

#ifdef LIBMESH_ENABLE_DEPRECATED
  boundary_id_type boundary_id (const Elem * const elem,
                                const unsigned short int side) const;
#endif

  unsigned int n_boundary_ids (const Elem * const elem,
                               const unsigned short int side) const;

#ifdef LIBMESH_ENABLE_DEPRECATED
  std::vector<boundary_id_type> boundary_ids (const Elem * const elem,
                                              const unsigned short int side) const;
#endif

  void boundary_ids (const Elem * const elem,
                     const unsigned short int side,
                     std::vector<boundary_id_type> & vec_to_fill) const;

#ifdef LIBMESH_ENABLE_DEPRECATED
  std::vector<boundary_id_type> raw_boundary_ids (const Elem * const elem,
                                                  const unsigned short int side) const;
#endif

  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;

  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;

  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;

#ifdef LIBMESH_ENABLE_DEPRECATED
  void build_node_list (std::vector<dof_id_type> &      node_id_list,
                        std::vector<boundary_id_type> & bc_id_list) const;
#endif

  std::vector<std::tuple<dof_id_type, boundary_id_type>>
  build_node_list() const;

  void build_node_list_from_side_list();

  void build_side_list_from_node_list();

#ifdef LIBMESH_ENABLE_DEPRECATED
  void build_side_list (std::vector<dof_id_type> &        element_id_list,
                        std::vector<unsigned short int> & side_list,
                        std::vector<boundary_id_type> &   bc_id_list) const;
#endif

  std::vector<std::tuple<dof_id_type, unsigned short int, boundary_id_type>>
  build_side_list() const;

#ifdef LIBMESH_ENABLE_DEPRECATED
  void build_active_side_list (std::vector<dof_id_type> &        element_id_list,
                               std::vector<unsigned short int> & side_list,
                               std::vector<boundary_id_type> &   bc_id_list) const;
#endif

  std::vector<std::tuple<dof_id_type, unsigned short int, boundary_id_type>>
  build_active_side_list () const;

#ifdef LIBMESH_ENABLE_DEPRECATED
  void build_edge_list (std::vector<dof_id_type> &        element_id_list,
                        std::vector<unsigned short int> & edge_list,
                        std::vector<boundary_id_type> &   bc_id_list) const;
#endif

  std::vector<std::tuple<dof_id_type, unsigned short int, boundary_id_type>>
  build_edge_list() const;

#ifdef LIBMESH_ENABLE_DEPRECATED
  void build_shellface_list (std::vector<dof_id_type> &        element_id_list,
                             std::vector<unsigned short int> & shellface_list,
                             std::vector<boundary_id_type> &   bc_id_list) const;
#endif

  std::vector<std::tuple<dof_id_type, unsigned short int, boundary_id_type>>
  build_shellface_list() const;

  const std::set<boundary_id_type> & get_boundary_ids () const
  { return _boundary_ids; }

  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=libMesh::out) const;

  void print_summary (std::ostream & out=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);

  boundary_id_type get_id_by_name(const std::string & 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; }

  static const boundary_id_type invalid_id;


private:

  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;

  std::set<boundary_id_type> _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;
};

} // namespace libMesh

#endif // LIBMESH_BOUNDARY_INFO_H