subentitymapper.hh

Go to the documentation of this file.

 
#ifndef __DUNE_ACFEM_SUBENTITYMAPPER_HH__
#define __DUNE_ACFEM_SUBENTITYMAPPER_HH__
 
#include <dune/geometry/referenceelements.hh>
#include <dune/grid/common/intersection.hh>
#include <array>
#include <unordered_map>
 
namespace Dune {
 
  namespace ACFem {
 
    namespace {
 
      template<class DofMapper, int coDimension>
      struct MapEntityHierarchyHelper
      {
        typedef DofMapper DofMapperType;
        typedef typename DofMapperType::GridPartType GridPartType;
        typedef typename GridPartType::ctype FieldType;
        typedef typename DofMapperType::ElementType ElementType;
        typedef typename DofMapperType::GlobalKeyType GlobalKeyType;
        typedef ReferenceElements<FieldType, ElementType::dimension> ReferenceElementsType;
        typedef ReferenceElement<FieldType, ElementType::dimension> ReferenceElementType;
 
        // Recurse into the entity hierarchy.
        template<int codim>
        struct SubSubEntityFunctor
        {
          enum {
            subCoDimension = codim,
            gridDimension = GridPartType::dimension,
            subSubEntityDimension = gridDimension-subCoDimension
          };
          template<class RefElem, class Functor>
          static void apply(const DofMapperType& mapper, const ElementType& element, const RefElem& refElem, int subIndex, Functor f,
                            const std::unordered_map<GlobalKeyType, unsigned>& globalToLocal)
          {
            const int numSubSubEntities = refElem.size(subIndex, coDimension, subCoDimension);
 
            for (int i = 0; i < numSubSubEntities; ++i) {
              const unsigned subSubEntityIndex = refElem.subEntity(subIndex, coDimension, i, subCoDimension);
              const auto subSubEntity = element.template subEntity<subCoDimension>(subSubEntityIndex);
 
              mapper.mapEachEntityDof(subSubEntity, [f, globalToLocal] (unsigned localIndex, const GlobalKeyType& globalIndex) {
                  f(globalToLocal.at(globalIndex), globalIndex);
                });
            }
          }
        };
 
      };
 
    }
 
    template<class DofMapper, int coDimension, class Functor>
    void mapEntityHierarchy(const DofMapper& mapper,
                            const typename DofMapper::ElementType& element,
                            int subIndex,
                            const std::integral_constant<int, coDimension>& dummy,
                            Functor f)
    {
      typedef DofMapper DofMapperType;
      typedef MapEntityHierarchyHelper<DofMapperType, coDimension> HelperType;
      typedef typename HelperType::GridPartType GridPartType;
      typedef typename HelperType::FieldType FieldType;
      typedef typename HelperType::ElementType ElementType;
      typedef typename HelperType::GlobalKeyType GlobalKeyType;
      typedef typename HelperType::ReferenceElementType ReferenceElementType;
      typedef typename HelperType::ReferenceElementsType ReferenceElementsType;
 
      enum { dimension = GridPartType::dimension };
 
      // first construct a reverse lookup for the global keys
      std::unordered_map<GlobalKeyType, unsigned> globalToLocal;
      mapper.mapEach(element, [&globalToLocal] (unsigned local, const GlobalKeyType& global) {
          globalToLocal[global] = local;
        });
 
      // get codim-0 reference element
      const auto& refElem = ReferenceElementsType::general(element.type());
 
      // Use ForLoop in order to generate a constant co-dimension as
      // we need element.template subEntity<cdim>
#if DUNE_VERSION_NEWER(DUNE_COMMON, 2, 5)
      Hybrid::forEach(Std::make_index_sequence<dimension-coDimension+1>{},
        [&](auto i){
          HelperType::template SubSubEntityFunctor<i+coDimension>::apply(mapper, element, refElem, subIndex, f, globalToLocal);
        });
#else
      ForLoop<HelperType::template SubSubEntityFunctor, coDimension, dimension>::apply(mapper, element, refElem, subIndex, f, globalToLocal);
#endif
    }
 
    template<class DofMapper, class Intersection, class Functor>
    void mapEachFaceDof(const DofMapper& mapper,
                        const Intersection& intersection,
                        Functor f)
    {
      mapEntityHierarchy(mapper, intersection.inside(), intersection.indexInInside(),
                         std::integral_constant<int, 1>(), f);
    }
 
    template<class DofMapper, class Intersection, class LocalIndices, class GlobalIndices>
    unsigned mapFaceDofs(const DofMapper& mapper, const Intersection& intersection,
                         LocalIndices& localIndices, GlobalIndices& globalIndices)
    {
      typedef typename DofMapper::GlobalKeyType GlobalKeyType;
 
      unsigned count = 0;
      mapEachFaceDof(mapper, intersection,
                     [&localIndices, &globalIndices, &count] (unsigned localIndex, GlobalKeyType globalIndex) {
                       localIndices[count] = localIndex;
                       globalIndices[count] = globalIndex;
                       ++count;
                     });
 
      return count;
    }
 
  }
 
}
 
#endif  // __DUNE_ACFEM_SUBENTITYMAPPER_HH__