index_set_filler.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/geometry/index_set.hpp>
 
// includes, system
#include <vector>
 
namespace FEAT
{
  namespace Geometry
  {
    namespace Intern
    {
      template<int dim>
      struct IndexSetFiller
      {
        template<typename IndexSetHolderType, typename TargetSetHolderType, typename ParentIndexSetHolderType>
        static void fill_ish(IndexSetHolderType& ish, const TargetSetHolderType& tsh, const ParentIndexSetHolderType& parent_ish)
        {
          // Recurse down
          IndexSetFiller<dim-1>::fill_ish(ish, tsh, parent_ish);
 
          // The MeshPart's vertex@shape set
          auto& index_set(ish.template get_index_set<dim, 0>());
          // The Mesh's vertex@shape set
          auto& index_set_parent(parent_ish.template get_index_set<dim, 0>());
 
          auto& target_set_vertex(tsh.template get_target_set<0>());
          auto& target_set_dim(tsh.template get_target_set<dim>());
 
          // For every vertex in the parent, this will contain its index in the MeshPart
          std::vector<Index> inverse_target_map(index_set_parent.get_index_bound());
 
          // Set every index to something out of range to catch errors
          for(Index i(0); i < index_set_parent.get_index_bound(); ++i)
            inverse_target_map[i] = target_set_vertex.get_num_entities() + Index(1);
 
          for(Index i(0); i < target_set_vertex.get_num_entities(); ++i)
            inverse_target_map[target_set_vertex[i]] = i;
 
          // Now we can just iterate over the shapes of the MeshPart
          for(Index cell(0); cell < target_set_dim.get_num_entities(); ++cell)
          {
            // For the shape cell, get its index in the parent. Then get the local vertex' index in the parent and
            // map that back to the MeshPart with the inverse_target_map. Ez!
            for(int i(0); i < index_set_parent.get_num_indices(); ++i)
              index_set[cell][i] = inverse_target_map[index_set_parent[target_set_dim[cell]][i]];
          }
        }
      }; // struct IndexSetFiller<int>
 
      template<>
      struct IndexSetFiller<0>
      {
        template<typename IndexSetHolderType, typename TargetSetHolderType, typename ParentIndexSetHolderType>
        static void fill_ish(IndexSetHolderType& DOXY(ish), const TargetSetHolderType& DOXY(tsh), const ParentIndexSetHolderType& DOXY(parent_ish))
        {
        }
      }; // struct IndexSetFiller<0>
    } // namespace Intern
  } // namespace Geometry
} // namespace FEAT