two_refinement_data.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
#include <kernel/geometry/raw_refinement_templates.hpp>
#include <kernel/geometry/refinement_types.hpp>
#include <kernel/shape.hpp>
 
namespace FEAT::Geometry
{
  class TwoRefinementData
  {
  public:
    using MaxShape = Shape::Hypercube<3>;
 
    using RawEdgeTemplate = RawTemplate<Shape::Hypercube<1>>;
    using RawFaceTemplate = RawTemplate<Shape::Hypercube<2>>;
    using RawCellTemplate = RawTemplate<Shape::Hypercube<3>>;
 
    template<int dim_>
    using RefinementTypeByDim = StandardRefinementType<Shape::Hypercube<dim_>>;
 
    template<typename Shape__>
    using RefinementTypeByShape = StandardRefinementType<Shape__>;
 
    template<int dim_>
    using TemplateMapByDim = std::unordered_map<RefinementTypeByDim<dim_>, RawTemplate<Shape::Hypercube<dim_>>>;
 
    using EdgeRefinementType = RefinementTypeByDim<1>;
    using FaceRefinementType = RefinementTypeByDim<2>;
    using CellRefinementType = RefinementTypeByDim<3>;
 
    using EdgeMap = TemplateMapByDim<1>;
    using FaceMap = TemplateMapByDim<2>;
    using CellMap = TemplateMapByDim<3>;
 
    template<typename Shape_>
    static constexpr bool is_shape_compatible()
    {
      return std::is_same_v<Shape_, Shape::Quadrilateral> || std::is_same_v<Shape_, Shape::Hexahedron>;
    }
 
    template<int template_dim_, int child_dim_>
    static constexpr int max_children()
    {
      static_assert(template_dim_ <= 3);
      static_assert(child_dim_ <= 3);
      const constexpr std::array<std::array<int, 4>, 4> children = {{
        {0, 0, 0, 0},
        {1, 2, 0, 0},
        {1, 4, 4, 0},
        {1, 6, 12, 8},
      }};
      return children[template_dim_][child_dim_];
    }
 
    template<int dim_>
    static TemplateMapByDim<dim_>& raw_templates()
    {
      if constexpr(dim_ == 1)
      {
        return raw_edges();
      }
      if constexpr(dim_ == 2)
      {
        return raw_faces();
      }
      if constexpr(dim_ == 3)
      {
        return raw_cells();
      }
      XABORTM("TwoRefinementRawData supplied no templates of dimension " + stringify(dim_));
    }
 
    static EdgeMap& raw_edges()
    {
      using V = typename RawEntity<Shape::Hypercube<1>>::VertexType;
      static EdgeMap result = {};
 
      if(result.empty())
      {
        result.insert({RefinementTypeByDim<1>(0b00), RawEdgeTemplate()});
        result.insert({RefinementTypeByDim<1>(0b11), RawEdgeTemplate().grid({2}, V{1.0 / 2.0})});
      }
      return result;
    }
 
    static FaceMap& raw_faces()
    {
      using V = typename RawEntity<Shape::Hypercube<2>>::VertexType;
      static FaceMap result = {};
 
      if(result.empty())
      {
        result.insert({RefinementTypeByDim<2>(0b0000), RawFaceTemplate()});
        result.insert({RefinementTypeByDim<2>(0b1111), RawFaceTemplate().grid({2, 2}, V{1.0 / 2.0, 1.0 / 2.0})});
      }
      return result;
    }
 
    static CellMap& raw_cells()
    {
      using V = typename RawCellTemplate::VertexType;
      static CellMap result = {};
 
      if(result.empty())
      {
        result.insert({RefinementTypeByDim<3>(0b00000000), RawCellTemplate()});
        result.insert(
          {RefinementTypeByDim<3>(0b11111111), RawCellTemplate().grid({2, 2, 2}, V{1.0 / 2.0, 1.0 / 2.0, 1.0 / 2.0})});
      }
      return result;
    }
  }; // class TwoRefinementData
} // namespace FEAT::Geometry