hybrid2d_refinement_pattern.h

#ifndef INCG_LF_REFINEMENT_PAT_H_
#define INCG_LF_REFINEMENT_PAT_H_
 
#include <lf/mesh/mesh.h>
 
namespace lf::refinement {
// Convenient types inherited from base namespace
using lf::base::dim_t;
using lf::base::glb_idx_t;
using lf::base::size_type;
using lf::base::sub_idx_t;
const unsigned int idx_nil = lf::base::kIdxNil;
 
enum RefPat : int {
  rp_nil,          
  rp_copy,         
  rp_split,        
  rp_bisect,       
  rp_trisect,      
  rp_trisect_left, 
  rp_quadsect,     
  rp_threeedge,    
  rp_regular,      
  rp_barycentric   
};
 
std::ostream& operator<<(std::ostream& o, const RefPat& refpat);
 
class Hybrid2DRefinementPattern : public geometry::RefinementPattern {
  Hybrid2DRefinementPattern(const Hybrid2DRefinementPattern&) = default;
  Hybrid2DRefinementPattern(Hybrid2DRefinementPattern&&) = default;
  Hybrid2DRefinementPattern& operator=(const Hybrid2DRefinementPattern&) =
      default;
  Hybrid2DRefinementPattern& operator=(Hybrid2DRefinementPattern&&) = default;
  // TODO(ralfh):
  // We do not need the achor_set_ member, if we follow the convention that
  // lf::base::kIdxNil represents an invalid (= non-set) anchor index.
 
 public:
  explicit Hybrid2DRefinementPattern(lf::base::RefEl ref_el)
      : geometry::RefinementPattern(ref_el),
        anchor_(idx_nil),
        ref_pat_(rp_nil),
        anchor_set_(false) {}
 
  Hybrid2DRefinementPattern(lf::base::RefEl ref_el, RefPat ref_pat)
      : geometry::RefinementPattern(ref_el),
        anchor_(idx_nil),
        ref_pat_(ref_pat),
        anchor_set_(false) {}
 
  Hybrid2DRefinementPattern(lf::base::RefEl ref_el, RefPat ref_pat,
                            lf::base::sub_idx_t anchor)
      : geometry::RefinementPattern(ref_el),
        anchor_(anchor),
        ref_pat_(ref_pat),
        anchor_set_(anchor != idx_nil) {
    if (anchor_set_) {
      LF_VERIFY_MSG(
          anchor < ref_el_.NumSubEntities(1),
          "Anchor " << anchor << " invalid for " << ref_el_.ToString());
    }
  }
 
  [[nodiscard]] lf::base::size_type NumChildren(
      lf::base::dim_t codim) const override;
  [[nodiscard]] std::vector<Eigen::Matrix<int, Eigen::Dynamic, Eigen::Dynamic>>
  ChildPolygons(lf::base::dim_t codim) const override;
 
  Hybrid2DRefinementPattern& setAnchor(lf::base::sub_idx_t anchor) {
    anchor_ = anchor;
    anchor_set_ = anchor != idx_nil;
    if (anchor_set_) {
      LF_VERIFY_MSG(
          anchor < ref_el_.NumSubEntities(1),
          "Anchor " << anchor << " invalid for " << ref_el_.ToString());
    }
    return (*this);
  }
 
  Hybrid2DRefinementPattern& setRefPattern(RefPat ref_pat) {
    ref_pat_ = ref_pat;
    anchor_set_ = false;
    return *this;
  }
 
  [[nodiscard]] lf::base::sub_idx_t anchor() const { return anchor_; }
  [[nodiscard]] RefPat refpat() const {
    LF_VERIFY_MSG(
        !(((ref_pat_ == rp_bisect) || (ref_pat_ == rp_trisect) ||
           (ref_pat_ == rp_trisect_left) || (ref_pat_ == rp_quadsect) ||
           (ref_pat_ == rp_quadsect) || (ref_pat_ == rp_threeedge)) &&
          !anchor_set_),
        "ref pattern " << ref_pat_ << " needs anchor!");
    return ref_pat_;
  }
  ~Hybrid2DRefinementPattern() override = default;
 
 private:
  lf::base::sub_idx_t anchor_; 
  RefPat ref_pat_;             
  bool anchor_set_;            
};
 
}  // namespace lf::refinement
 
 
template <>
struct fmt::formatter<lf::refinement::RefPat> : ostream_formatter {};
 
#endif