40    : gridView_(grid.levelGridView(0))
 
   41    , idSet_(grid.localIdSet())
 
   42    , userCellData_(cellData)
 
   43    , userPointData_(pointData)
 
   47        for (
const auto& [key, data] : userCellData_)
 
   48            cellData_[key] = std::move(userCellData_[key]);
 
   49        for (
const auto& [key, data] : userPointData_)
 
   50            pointData_[key] = std::move(userPointData_[key]);
 
   54        std::array<std::size_t, 2> numKeys{{ cellData_.size(), pointData_.size() }};
 
   55        Dune::MPIHelper::getCommunication().broadcast(numKeys.data(), 2, 0);
 
   59        std::vector<std::size_t> keyLengthAndComponents(2*(numKeys[0] + numKeys[1]), 0);
 
   64            for (
const auto& [key, data] : cellData_)
 
   65                keyLengthAndComponents[n++] = key.size();
 
   66            for (
const auto& [key, data] : pointData_)
 
   67                keyLengthAndComponents[n++] = key.size();
 
   70            for (
const auto& [key, data] : cellData_)
 
   71                keyLengthAndComponents[n++] = gridView_.size(0) > 0 ? data.size()/gridView_.size(0) : 0;
 
   72            for (
const auto& [key, data] : pointData_)
 
   73                keyLengthAndComponents[n++] = gridView_.size(Grid::dimension) > 0 ? data.size()/gridView_.size(Grid::dimension) : 0;
 
   76            assert((Dune::MPIHelper::instance().rank() == 0) == (n == keyLengthAndComponents.size()));
 
   78            Dune::MPIHelper::getCommunication().broadcast(keyLengthAndComponents.data(), keyLengthAndComponents.size(), 0);
 
   82        const auto begin = keyLengthAndComponents.begin() + numKeys[0] + numKeys[1];
 
   83        cellDataComponents_.assign(begin, begin + numKeys[0]);
 
   84        pointDataComponents_.assign(begin + numKeys[0], keyLengthAndComponents.end());
 
   85        numCellDataPerElement_ = std::accumulate(cellDataComponents_.begin(), cellDataComponents_.end(), 0UL);
 
   86        numPointDataPerVertex_ = std::accumulate(pointDataComponents_.begin(), pointDataComponents_.end(), 0UL);
 
   89        std::string keys; keys.resize(std::accumulate(keyLengthAndComponents.begin(), begin, 0UL));
 
   92            for (
const auto& [key, data] : cellData_)
 
   93                for (
const auto& c : key)
 
   95            for (
const auto& [key, data] : pointData_)
 
   96                for (
const auto& c : key)
 
  100            assert((Dune::MPIHelper::instance().rank() == 0) == (n == keys.size()));
 
  102            Dune::MPIHelper::getCommunication().broadcast(keys.data(), keys.size(), 0);
 
  106        std::size_t offset = 0;
 
  107        for (
int keyIdx = 0; keyIdx < numKeys[0]; ++keyIdx)
 
  109            if (std::string key{ keys, offset, keyLengthAndComponents[keyIdx] }; cellData_.count(key) == 0)
 
  110                cellData_[key] = Data{};
 
  112            offset += keyLengthAndComponents[keyIdx];
 
  114        for (
int keyIdx = numKeys[0]; keyIdx < numKeys[0] + numKeys[1]; ++keyIdx)
 
  116            if (std::string key{ keys, offset, keyLengthAndComponents[keyIdx] }; pointData_.count(key) == 0)
 
  117                pointData_[key] = Data{};
 
  119            offset += keyLengthAndComponents[keyIdx];
 
  123        for (
const auto& element : elements(gridView_, Dune::Partitions::interior))
 
  125            data_[idSet_.id(element)].resize(numCellDataPerElement_);
 
  128            for (
const auto& [key, data] : cellData_)
 
  130                const auto nComp = cellDataComponents_[l++];
 
  131                for (
int k = 0; k < nComp; ++k)
 
  132                    std::swap(cellData_[key][k + nComp*gridFactory.insertionIndex(element)], data_[idSet_.id(element)][n++]);
 
  135            assert(n == numCellDataPerElement_);
 
  138        for (
const auto& vertex : vertices(gridView_))
 
  140            data_[idSet_.id(vertex)].resize(numPointDataPerVertex_);
 
  143            for (
const auto& [key, data] : pointData_)
 
  145                const auto nComp = pointDataComponents_[l++];
 
  146                for (
int k = 0; k < nComp; ++k)
 
  147                    std::swap(pointData_[key][k + nComp*gridFactory.insertionIndex(vertex)], data_[idSet_.id(vertex)][n++]);
 
  150            assert(n == numPointDataPerVertex_);
 
 
  157        const auto& indexSet = gridView_.indexSet();
 
  161            for (
const auto& [key, data] : cellData_)
 
  162                cellData_[key].resize(indexSet.size(0)*cellDataComponents_[n++]);
 
  166            for (
const auto& [key, data] : pointData_)
 
  167                pointData_[key].resize(indexSet.size(GridView::dimension)*pointDataComponents_[n++]);
 
  170        for (
const auto& element : elements(gridView_))
 
  173            for (
const auto& [key, data] : cellData_)
 
  175                const auto nComp = cellDataComponents_[l++];
 
  176                for (
int k = 0; k < nComp; ++k)
 
  177                    std::swap(cellData_[key][k + nComp*indexSet.index(element)], data_[idSet_.id(element)][n++]);
 
  181        for (
const auto& vertex : vertices(gridView_))
 
  184            for (
const auto& [key, data] : pointData_)
 
  186                const auto nComp = pointDataComponents_[l++];
 
  187                for (
int k = 0; k < nComp; ++k)
 
  188                    std::swap(pointData_[key][k + nComp*indexSet.index(vertex)], data_[idSet_.id(vertex)][n++]);
 
  193        for (
const auto& [key, data] : cellData_)
 
  194            userCellData_[key] = std::move(cellData_[key]);
 
  195        for (
const auto& [key, data] : pointData_)
 
  196            userPointData_[key] = std::move(pointData_[key]);