65    : embeddingsPtr_(embeddings)
 
   66    , bulkVertexMapper_(embeddings->template gridView<bulkGridId>(), 
Dune::mcmgVertexLayout())
 
   69        const auto& bulkGridView = embeddings->template gridView<bulkGridId>();
 
   70        bulkInsertionToGridVIdx_.resize(bulkGridView.size(BulkGridView::dimension));
 
   71        for (
const auto& v : vertices(bulkGridView))
 
   72            bulkInsertionToGridVIdx_[embeddings->template insertionIndex<bulkGridId>(v)] = bulkVertexMapper_.index(v);
 
   78        hierarchyToBulkInsertionIdx_.resize(embeddingsPtr_->numVerticesInHierarchy());
 
   79        bulkGridHasHierarchyVertex_.resize(embeddingsPtr_->numVerticesInHierarchy(), 
false);
 
   80        const auto& bulkHierarchyIndices = embeddingsPtr_->gridHierarchyIndices(bulkGridId);
 
   81        for (std::size_t insIdx = 0; insIdx < bulkHierarchyIndices.size(); ++insIdx)
 
   83            hierarchyToBulkInsertionIdx_[ bulkHierarchyIndices[insIdx] ] = insIdx;
 
   84            bulkGridHasHierarchyVertex_[ bulkHierarchyIndices[insIdx] ] = 
true;
 
   88        bulkVertexIsOnFacetGrid_.resize(bulkGridView.size(BulkGridView::dimension), 
false);
 
   89        const auto& facetGridView = embeddings->template gridView<facetGridId>();
 
   90        for (
const auto& v : vertices(facetGridView))
 
   92            const auto insIdx = embeddings->template insertionIndex<facetGridId>(v);
 
   93            const auto hierarchyInsIdx = embeddings->gridHierarchyIndices(facetGridId)[insIdx];
 
   95            if (bulkGridHasHierarchyVertex_[hierarchyInsIdx])
 
   96                bulkVertexIsOnFacetGrid_[ getBulkGridVertexIndex_(hierarchyInsIdx) ] = 
true;
 
  100        facetElementCorners_.resize(facetGridView.size(0));
 
  101        facetElementsAtBulkVertex_.resize(bulkGridView.size(BulkGridView::dimension));
 
  103        std::size_t facetElementCounter = 0;
 
  104        for (
const auto& element : elements(facetGridView))
 
  109                const auto numCorners = element.subEntities(FacetGridView::dimension);
 
  110                std::vector<BulkIndexType> cornerIndices(numCorners);
 
  111                for (
int i = 0; i < numCorners; ++i)
 
  112                    cornerIndices[i] = 
bulkGridVertexIndex(element.template subEntity<FacetGridView::dimension>(i));
 
  115                for (
auto bulkVIdx : cornerIndices)
 
  116                    facetElementsAtBulkVertex_[bulkVIdx].push_back(facetElementCounter);
 
  119                std::sort(cornerIndices.begin(), cornerIndices.end());
 
  120                facetElementCorners_[facetElementCounter] = std::move(cornerIndices);
 
  123            facetElementCounter++;
 
 
  157    bool isOnFacetGrid(
const BulkGridElement& element, 
const BulkGridIntersection& intersection)
 const 
  160        const auto refElement = referenceElement(element);
 
  161        const auto numCorners = intersection.geometry().corners();
 
  162        const auto facetIdx = intersection.indexInInside();
 
  164        std::vector<BulkIndexType> cornerIndices(numCorners);
 
  165        for (
int i = 0; i < numCorners; ++i)
 
  166            cornerIndices[i] = bulkVertexMapper_.subIndex( element,
 
  167                                                           refElement.subEntity(facetIdx, 1, i, BulkGridView::dimension),
 
  168                                                           BulkGridView::dimension );
 
 
  183        std::vector<std::size_t> facetElemIndices;
 
  184        for (
auto bulkVIdx : bulkVertexIndices)
 
  185            facetElemIndices.insert( facetElemIndices.end(),
 
  186                                     facetElementsAtBulkVertex_[bulkVIdx].begin(),
 
  187                                     facetElementsAtBulkVertex_[bulkVIdx].end() );
 
  190        if (facetElemIndices.size() == 0)
 
  194        std::sort(facetElemIndices.begin(), facetElemIndices.end());
 
  195        facetElemIndices.erase(std::unique(facetElemIndices.begin(), facetElemIndices.end()), facetElemIndices.end());
 
  198        auto cornerIndexCopy = bulkVertexIndices;
 
  199        std::sort(cornerIndexCopy.begin(), cornerIndexCopy.end());
 
  200        for (
const auto& facetElemIdx : facetElemIndices)
 
  202            const auto& facetElemCorners = facetElementCorners_[facetElemIdx];
 
  203            if (facetElemCorners.size() != cornerIndexCopy.size())
 
  206            if ( std::equal(cornerIndexCopy.begin(), cornerIndexCopy.end(),
 
  207                            facetElemCorners.begin(), facetElemCorners.end()) )