mapping.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
 
// includes, FEAT
#include <kernel/trafo/mapping_base.hpp>
#include <kernel/trafo/isoparam/evaluator.hpp>
#include <kernel/geometry/mesh_part.hpp>
#include <kernel/geometry/atlas/chart.hpp>
 
namespace FEAT
{
  namespace Trafo
  {
    namespace Isoparam
    {
      namespace Intern
      {
        template<typename Shape_, int dim_ = Shape_::dimension-1>
        struct PartChartHelper
        {
          template<typename AVC_, typename Chart_>
          static void emplace(const Geometry::TargetSetHolder<Shape_>& tsh, AVC_& v, const Chart_& chart)
          {
            PartChartHelper<Shape_, dim_-1>::emplace(tsh, v, chart);
 
            const auto& trg = tsh.template get_target_set<dim_>();
            for(Index i(0); i < trg.get_num_entities(); ++i)
            {
              v[dim_].at(trg[i]) = &chart;
            }
          }
        };
 
        template<typename Shape_>
        struct PartChartHelper<Shape_,0>
        {
          template<typename AVC_, typename Chart_>
          static void emplace(const Geometry::TargetSetHolder<Shape_>&, AVC_&, const Chart_&)
          {
            // nothing to do here
          }
        };
      } // namespace Intern
 
      template<typename Mesh_, int degree_>
      class Mapping :
        public MappingBase<Mesh_>
      {
      public:
        static_assert(degree_ > 0, "invalid mapping degree");
        static_assert(degree_ < 4, "invalid mapping degree");
 
        typedef MappingBase<Mesh_> BaseClass;
        typedef Mesh_ MeshType;
        typedef Geometry::Atlas::ChartBase<MeshType> ChartType;
        typedef typename MeshType::VertexSetType::CoordType CoordType;
        typedef typename MeshType::ShapeType ShapeType;
        typedef typename Shape::FaceTraits<ShapeType, ShapeType::dimension - 1>::ShapeType FacetType;
 
        static constexpr int shape_dim = ShapeType::dimension;
 
      protected:
        // for each shape dimension, a vector of charts
        std::array<std::vector<const ChartType*>, shape_dim+1> _shape_charts;
 
      public:
        template<
          typename Shape_ = ShapeType,
          typename CoordType_ = Real>
        class Evaluator
        {
        private:
          typedef Trafo::StandardEvalPolicy<Shape_, CoordType_, MeshType::world_dim> EvalPolicy;
 
        public:
          typedef Trafo::Isoparam::Evaluator<Mapping, EvalPolicy, degree_> Type;
        };
 
      public:
        explicit Mapping(MeshType& mesh) :
          BaseClass(mesh)
        {
          // allocate chart vectors
          for(int dim(1); dim <= shape_dim; ++dim)
          {
            _shape_charts.at(std::size_t(dim)).resize(mesh.get_num_entities(dim), nullptr);
          }
        }
 
        void add_meshpart_chart(const Geometry::MeshPart<MeshType>& mesh_part, const Geometry::Atlas::ChartBase<MeshType>& chart)
        {
          Intern::PartChartHelper<ShapeType>::emplace(mesh_part.get_target_set_holder(), _shape_charts, chart);
        }
 
        void clear_charts()
        {
          for(int dim(1); dim <= shape_dim; ++dim)
          {
            for(auto& x : _shape_charts.at(std::size_t(dim)))
              x = nullptr;
          }
        }
 
        const std::vector<const ChartType*>& get_charts_vector(int dim) const
        {
          XASSERTM((dim >= 0) && (dim <= shape_dim), "invalid dimension");
          return _shape_charts.at(std::size_t(dim));
        }
      }; // class Mapping<...>
    } // namespace Isoparam
  } // namespace Trafo
} // namespace FEAT