77    static std::size_t 
enrich(IndexMap& indexMap,
 
   78                              const std::vector<bool>& vertexMarkers,
 
   79                              const GridView& gridView,
 
   80                              const MCMGMapper& vertexMapper,
 
   81                              const MCMGMapper& elementMapper,
 
   82                              const CodimOneGridView& codimOneGridView,
 
   86        NodalElementPaths nodalPaths(gridView.size(dim));
 
   87        for (
const auto& e : elements(gridView))
 
   89            const auto eIdx = elementMapper.index(e);
 
   91            std::vector<unsigned int> handledFacets;
 
   92            const auto refElement = referenceElement(e);
 
   93            for (
const auto& is : intersections(gridView, e))
 
  100                if (std::find(handledFacets.begin(), handledFacets.end(), is.indexInInside()) != handledFacets.end())
 
  104                const auto numCorners = is.geometry().corners();
 
  105                std::vector<GridIndexType> faceVertexIndices(numCorners);
 
  106                for (
int i = 0; i < numCorners; ++i)
 
  107                    faceVertexIndices[i] = vertexMapper.subIndex( e,
 
  108                                                                  refElement.subEntity(is.indexInInside(), 1, i, dim),
 
  114                    handledFacets.push_back(is.indexInInside());
 
  115                    for (
int i = 0; i < numCorners; ++i)
 
  118                        const auto vIdxGlobal = faceVertexIndices[i];
 
  119                        if (!vertexMarkers[vIdxGlobal])
 
  124                        for (
const auto& path : nodalPaths[vIdxGlobal])
 
  125                            if (std::find(path.begin(), path.end(), eIdx) != path.end())
 
  126                            { found = 
true; 
break; }
 
  137                            path.push_back(eIdx);
 
  138                            continuePathSearch_(path, gridView, elementMapper, vertexMapper, codimOneGridAdapter, e, refElement, is, vIdxGlobal);
 
  139                            nodalPaths[vIdxGlobal].emplace_back(std::move(path));
 
  147        std::vector<std::size_t> bulkVertexIndexOffsets(gridView.size(dim), 0);
 
  148        for (
const auto& v : vertices(gridView))
 
  150            const auto vIdx = vertexMapper.index(v);
 
  151            if (vertexMarkers[vIdx])
 
  152                bulkVertexIndexOffsets[vIdx] = nodalPaths[vIdx].size()-1;
 
  156        std::size_t sumOffset = 0;
 
  157        std::size_t size = 0;
 
  158        for (
auto& nodalOffset : bulkVertexIndexOffsets)
 
  160            const auto os = nodalOffset;
 
  161            nodalOffset = sumOffset;
 
  163            size += (os == 0) ? 1 : os + 1;
 
  167        for (
const auto& e : elements(gridView))
 
  169            const auto& eg = e.geometry();
 
  170            const auto eIdx = elementMapper.index(e);
 
  171            for (
int i = 0; i < eg.corners(); ++i)
 
  173                const auto origVIdx = vertexMapper.subIndex(e, i, dim);
 
  176                if (!vertexMarkers[origVIdx])
 
  177                    indexMap[eIdx][i] += bulkVertexIndexOffsets[origVIdx];
 
  183                    const auto& paths = nodalPaths[ origVIdx ];
 
  184                    for (
int pathIdx = 0; pathIdx < paths.size(); ++pathIdx)
 
  186                        const auto& curPath = paths[pathIdx];
 
  187                        if ( std::find(curPath.begin(), curPath.end(), eIdx) != curPath.end() )
 
  189                            indexMap[eIdx][i] += bulkVertexIndexOffsets[origVIdx] + pathIdx;
 
  196                        DUNE_THROW(Dune::InvalidStateException, 
"Element not found in any path");