face_element.h

Go to the documentation of this file.

#ifndef FACE_ELEMENT_H
#define FACE_ELEMENT_H
 
#include "bitrl/bitrl_consts.h"
#include "bitrl/bitrl_types.h"
#include "bitrl/utils/geometry/geom_point.h"
#include "bitrl/utils/geometry/mesh/edge_face_selector.h"
#include "bitrl/utils/geometry/mesh/mesh_entity.h"
 
#include <any>
#include <array>
 
namespace bitrl
{
namespace utils
{
namespace geom
{
 
// template<int spacedim> class Mesh;
 
template <int dim> class Element;
template <int dim> class Node;
template <int dim, int topodim> class FaceElement;
 
template <int spacedim>
class FaceElement<spacedim, 0> : public GeomPoint<spacedim>, public MeshEntity
{
 
  public:
    FaceElement();
 
    explicit FaceElement(uint_t global_id, real_t val = 0.0, uint_t pid = 0,
                         const std::any &data = std::any());
 
    FaceElement(const std::array<real_t, spacedim> &coords, uint_t global_id, uint_t pid = 0,
                const std::any &data = std::any());
 
    FaceElement(const GeomPoint<spacedim> &point, uint_t global_id, uint_t pid,
                const std::any &data);
 
    FaceElement(const FaceElement &t);
 
    FaceElement &operator=(const FaceElement &t);
 
    virtual ~FaceElement() {}
 
    void make_vertex() { is_vertex_ = true; }
 
    bool is_vertex() const { return is_vertex_; }
 
    real_t volume() const { return 0.0; }
 
    GeomPoint<spacedim> centroid() const { return *this; }
 
    bool on_boundary() const { return boundary_indicator_ != bitrl::consts::INVALID_ID; }
    uint_t boundary_indicator() const { return boundary_indicator_; }
 
  private:
    bool is_vertex_;
    uint_t boundary_indicator_;
};
 
template <> class FaceElement<2, 1>
{
 
  public:
    static const int dim_ = 2;
    static const int topodim_ = 1;
 
    typedef Node<2> *node_ptr_t;
    typedef const Node<2> *cnode_ptr_t;
    typedef Node<2> &node_ref_t;
    typedef const Node<2> &cnode_ref_t;
    typedef EdgeSelector<2>::ptr_t edge_ptr_t;
    typedef EdgeSelector<2>::cptr_t cedge_ptr_t;
    typedef EdgeSelector<2>::ptr_t face_ptr_t;
    typedef EdgeSelector<2>::cptr_t cface_ptr_t;
 
    virtual ~FaceElement() {}
 
    virtual void resize_nodes();
 
    virtual uint_t n_nodes() const { return n_nodes_; }
 
    virtual void set_node(uint_t i, node_ptr_t node);
 
    virtual node_ptr_t node_ptr(uint_t n);
 
    virtual uint_t n_vertices() const { return 2; }
 
    virtual uint_t n_edges() const { return 2; }
 
    virtual uint_t n_faces() const { return 2; }
 
    void set_owner_element(Element<2> *o) { owner_ = o; }
 
    void set_shared_element(Element<2> *n) { neighbor_ = n; }
 
    void set_owner_shared_elements(Element<2> *o, Element<2> *n)
    {
        owner_ = o;
        neighbor_ = n;
    }
 
    void set_boundary_indicator(uint_t bind) { boundary_indicator_ = bind; }
 
    Element<2> *owner() { return owner_; }
 
    Element<2> *neighbor() { return neighbor_; }
 
    virtual std::vector<uint_t> get_vertices_ids() const;
 
    bool on_boundary() const { return boundary_indicator_ != bitrl::consts::INVALID_ID; }
 
    uint_t boundary_indicator() const { return boundary_indicator_; }
 
    real_t volume() const;
 
    real_t owner_neighbor_distance() const;
 
    virtual std::ostream &print_mesh_entity_info(std::ostream &out) const;
 
    const GeomPoint<2> centroid() const;
 
    bool is_owner(uint_t id) const;
 
    Element<2> &get_neighbor();
 
    const Element<2> &get_neighbor() const;
 
    Element<2> &get_owner();
 
    const Element<2> &get_owner() const;
 
    cnode_ref_t get_vertex(uint_t v) const;
 
    node_ref_t get_vertex(uint_t v);
 
    const DynVec<real_t> normal_vector() const;
 
    bool is_active() const { return true; }
    uint_t get_id() const { return id_; }
    void set_id(uint_t id) { id_ = id; }
    bool has_valid_id() const { return true; }
 
  protected:
    FaceElement();
    FaceElement(uint_t id, uint_t pid = 0);
    FaceElement(uint_t id, uint_t nnodes, uint_t pid);
 
    std::vector<node_ptr_t> nodes_;
 
  private:
    Element<2> *owner_;
 
    Element<2> *neighbor_;
 
    uint_t boundary_indicator_;
 
    std::ostream &print_(std::ostream &o) const;
 
    uint_t id_;
 
    uint_t n_nodes_;
};
 
inline std::ostream &FaceElement<2, 1>::print_mesh_entity_info(std::ostream &out) const
{
    return print_(out);
}
 
/*
 
//forward declaration
class Face;
 
template<>
class FaceElement<3,1>
{
 
 protected:
 
 
  FaceElement();
  FaceElement(uint_t id,uint_t pid=0);
  FaceElement(uint_t id, uint_t nnodes, uint_t pid);
 
 public:
 
 static const int dim_ = 3;
 static const int topodim_ = 1;
 
 typedef EdgeSelector<3>::ptr_t   edge_ptr_t;
 typedef EdgeSelector<3>::ptr_t face_ptr_t;
 
     virtual ~FaceElement(){}
 
 
     void set_owner_element(Face* o){owner_ = o;}
     void set_shared_element(Face* n){neighbor_ = n;}
     void set_owner_shared_elements(Face* o, Face* n)
     {owner_ = o; neighbor_ = n;}
      void set_boundary_indicator(uint_t bind){boundary_indicator_=bind;}
     Face* owner(){return owner_;}
     Face* neighbor(){return neighbor_;}
     bool on_boundary () const {return true;}
     uint_t boundary_indicator()const{return boundary_indicator_;}
 
 
 
      virtual std::ostream& print_mesh_entity_info(std::ostream &out)const;
 
     real_t volume()const{return 0.0;}
 
     GeomPoint<3> centroid()const{return GeomPoint<3>(0.0);}
 
     bool is_owner(uint_t id)const{return  true;}
 
     Element<3>& get_neighbor(){}
 
     const Element<3>& get_neighbor()const{}
 
     Element<3>& get_owner(){}
 
     const Element<3>& get_owner()const{}
 
       bool is_active()const{return true;}
 
       uint_t get_id()const{return id_;}
       void set_id(uint_t id){id_ = id;}
       bool has_valid_id()const{return true;}
 
private:
 
  Face* owner_;
  Face* neighbor_;
  uint_t boundary_indicator_;
 
  std::ostream& print_(std::ostream& o)const;
 
  uint_t id_;
 
 
};
 
inline
std::ostream&
FaceElement<3,1>::print_mesh_entity_info(std::ostream &out)const
{
  return print_(out);
}
 
*/
 
//
//  * A Face<3> IsA FaceElement<3,2>
//  *
//  * This is the base class for representing faces in MeshGeometry::dim_ = 3
//  * spatial dimension. Concrete classes of this class implement the pure virtual
//  * functions inherited by Element<3,2> class. Concrete classes of this class are
//  * Quad<3>, Tri<3>.
//  */
//
// template<>
// class FaceElement<3,2>
//{
//
// protected:
//
//
// FaceElement();
//
// FaceElement(uint_t id,uint_t pid=0);
//
// public:
//
//
// static const int dim_ = 3;
// static const int topodim_ = 2;
//
// typedef EdgeSelector<3>::ptr_t edge_ptr_t;
// typedef EdgeSelector<3>::ptr_t face_ptr_t;
//
//
// /**
//   *\detailed dtor
//   */
// virtual ~FaceElement(){}
//
//
// /**
//   *  set the pointer to the
//   *  element that holds the side.
//   */
// void set_owner_element(Element<3>* o){owner_ = o;}
//
//
// /**
//   * set the pointer to the element that
//   * shares this side. It also sets the old sharing element
//   * to the element we use before calling this function
//   */
// void set_shared_element(Element<3>* n){neighbor_ = n;}
//
//
// /**
//   * set the pointers for the shared and owner of this side
//   */
// void set_owner_shared_element(Element<3>* o, Element<3>* n)
// {owner_ = o; neighbor_ = n;}
//
//
// /**
//    *\detailed set the boundary indicator for the FaceElement
//    */
//  void set_boundary_indicator(uint_t bind){boundary_indicator_=bind;}
//
//
//
//
//  /**
//   *\detailed read/write access to the owner of this
//   * face. May return NULL
//   */
//  Element<3>* owner(){return owner_;}
//
//
//   /**
//   *\detailed read/write access to the neighbor of this
//   * face. May return NULL
//   */
//  Element<3>* neighbor(){return neighbor_;}
//
//
//  /**
//      * @returns \p true iff a boundary indicator has been set
//      */
//    bool on_boundary () const { return false;/*return
//    boundary_indicator_!=LibSimPP::internal_mesh_entity_id();*/}
//
//
// /**
//   *\detailed get the boundary indicator of the face
//   */
// uint_t boundary_indicator()const{return boundary_indicator_;}
//
//
//  /**
//   *\detailed print the information for the MeshEntity
//   */
//  virtual std::ostream& print_mesh_entity_info(std::ostream &out)const;
//
//    /// \brief
//    real_t volume()const{return 0.0;}
//
//    /// \brief Returns the centroid of the face element
//    /// \brief The centroid is the point itself
//    GeomPoint<3> centroid()const{return GeomPoint<3>(0.0);}
//
//    /// \brief computes a reference distance between the
//    /// centroids of the two elements sharing the FaceElement
//    /// If this lies on the the boundary then the centroid of
//    /// the FaceElementis used
//    real_t owner_neighbor_distance()const{return 0.0;}
//
//   bool is_active()const{return true;}
//
//   /// \brief Returns true if the owner of the cell has
//   /// the given id
//   bool is_owner(uint_t id)const{throw std::logic_error("Not implemented");}
//
//   /// \brief Read/write access to the neighbor element
//   Element<3>& get_neighbor(){throw std::logic_error("Not implemented");}
//
//   /// \brief Read reference to the neighbor of the side
//   const Element<3>& get_neighbor()const{throw std::logic_error("Not implemented");}
//
//
//   /// \brief Read/write access to the neighbor element
//   Element<3>& get_owner(){throw std::logic_error("Not implemented");}
//
//   /// \brief Read reference to the neighbor of the side
//   const Element<3>& get_owner()const{throw std::logic_error("Not implemented");}
//
//   /// \brief Returns the normal vector to the face
//   const DynVec<real_t> normal_vector()const{throw std::logic_error("Not implemented");}
//
//   uint_t get_id()const{return id_;}
//   void set_id(uint_t id){id_ = id;}
//   bool has_valid_id()const{return true;}
//
//  protected:
//
//
//  /**
//   *\detailed the owner of the FaceElement
//   */
//  Element<3>* owner_;
//
//
// /**
//   *\detailed the neighbor of the FaceElement
//   */
//  Element<3>* neighbor_;
//
//
//  /**
//    *\detailed the boundary indicator of the edge
//    */
//  uint_t boundary_indicator_;
//
//  uint_t id_;
//
//  /**
//    *\detailed we fail to link with the print_mesh_entity_info
//    */
//  std::ostream& print_(std::ostream& o)const;
//
//};
//
// inline
// std::ostream&
// FaceElement<3,2>::print_mesh_entity_info(std::ostream &out)const
//{
//  return print_(out);
//}
 
} // namespace geom
} // namespace utils
} // namespace bitrl
#endif