boundary_info.h

Go to the documentation of this file.

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

namespace libMesh
{


// Forward declarations
class Elem;
class Node;
class MeshBase;
class UnstructuredMesh;
class MeshData;


//------------------------------------------------------
// BoundaryInfo class definition
class BoundaryInfo : public ParallelObject
{
protected:
  friend class MeshBase;

  BoundaryInfo (const MeshBase& m);

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


  ~BoundaryInfo ();

  void clear ();

  void sync (UnstructuredMesh& boundary_mesh,
             MeshData* boundary_mesh_data=NULL,
             MeshData* this_mesh_data=NULL);

  void sync (const std::set<boundary_id_type> &requested_boundary_ids,
             UnstructuredMesh& boundary_mesh,
             MeshData* boundary_mesh_data=NULL,
             MeshData* this_mesh_data=NULL);

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

  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;

  std::vector<boundary_id_type> boundary_ids (const Node* node) 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;

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

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

  bool has_boundary_id (const Elem* const elem,
                        const unsigned short int side,
                        const boundary_id_type id) const;

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

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

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

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

  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;

  std::size_t n_boundary_conds () const;

  std::size_t n_edge_conds () const;

  std::size_t n_nodeset_conds () const;

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

  void build_node_list_from_side_list();

  void build_side_list_from_node_list();

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

  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;

  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_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:


  const 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_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::map<boundary_id_type, std::string> _ss_id_to_name;

  std::map<boundary_id_type, std::string> _ns_id_to_name;


  //   /**
  //    * Functor class for printing a single node's info
  //    * To be used with "for_each".
  //    */
  //   class PrintNodeInfo
  //   {
  //   public:
  //     inline
  //     void operator() (const std::pair<const Node*, short int>& np) const
  //     {
  //       libMesh::out << "  (" << np.first->id()
  //      << ", "  << np.second
  //      << ")"  << std::endl;
  //     }
  //   };


  //   /**
  //    * Functor class for printing a single side's info.
  //    * To be used with "for_each".
  //    */
  //   class PrintSideInfo
  //   {
  //   public:
  //     PrintSideInfo() {}
  //     inline
  //     void operator() (const std::pair<const Elem*, std::pair<unsigned short int,short int> >& sp) const
  //     {
  //       libMesh::out << "  (" << sp.first->id()
  //      << ", "  << sp.second.first
  //      << ", "  << sp.second.second
  //      << ")"   << std::endl;
  //     }
  //   };



  class Fill
  {
  public:
    Fill(std::map<boundary_id_type, dof_id_type>& im) : id_map(im), cnt(0) {}

    ~Fill()
    {
      id_map[invalid_id] = cnt;
    }

    inline
    void operator() (const boundary_id_type& pos)
    {
      id_map[pos] = cnt++;
    }

  private:
    std::map<boundary_id_type, dof_id_type>& id_map;
    dof_id_type cnt;
  };

};






// ------------------------------------------------------------
// BoundaryInfo inline methods
inline
void BoundaryInfo::remove (const Node* node)
{
  libmesh_assert(node);

  // Erase everything associated with node
  _boundary_node_id.erase (node);
}



inline
void BoundaryInfo::remove (const Elem* elem)
{
  libmesh_assert(elem);

  // Erase everything associated with elem
  _boundary_edge_id.erase (elem);
  _boundary_side_id.erase (elem);
}

} // namespace libMesh

#endif // LIBMESH_BOUNDARY_INFO_H