ElementVector.hpp

#pragma once
 
#include <map>
#include <memory>
#include <optional>
#include <utility>
#include <vector>
 
#include <dune/common/concept.hh>
#include <dune/common/shared_ptr.hh>
#include <amdis/Observer.hpp>
 
namespace AMDiS
{
 
  template <class G, class T = double>
  class ElementVector
      : private Observer<event::preAdapt>
      , private Observer<event::adapt>
      , private Observer<event::postAdapt>
  {
    using Self = ElementVector;
 
  public:
    using Grid = G;
 
    using size_type  = std::size_t;
 
    using value_type = T;
 
    using Data = std::vector<T>;
 
  public:
    ElementVector(std::shared_ptr<G const> const& grid, T value = 0)
      : Observer<event::preAdapt>(*grid)
      , Observer<event::adapt>(*grid)
      , Observer<event::postAdapt>(*grid)
      , grid_(grid)
      , data_(grid->size(0), value)
    {}
 
    ElementVector(G const& grid, T value = 0)
      : ElementVector(Dune::wrap_or_move(FWD(grid)), value)
    {}
 
    auto gridView() const
    {
      return grid_->leafGridView();
    }
 
    Data const& data() const
    {
      return data_;
    }
 
    Data& data()
    {
      return data_;
    }
 
    void resize()
    {
      data_.resize(grid_->size(0));
    }
 
    void resizeZero()
    {
      data_.resize(grid_->size(0));
      std::fill(data_.begin(), data_.end(), T(0));
    }
 
  protected:
 
    void updateImpl(event::preAdapt e) override
    {
      persistentData_.emplace();
 
      // Store the data in a persistent container
      auto const& indexSet = grid_->leafIndexSet();
      auto const& idSet = grid_->localIdSet();
      for (auto const& e : elements(grid_->leafGridView())) {
        (*persistentData_)[idSet.id(e)] = data_[indexSet.index(e)];
 
        // store also the same value on all father elements
        if (e.mightVanish() && e.hasFather()) {
          T value = data_[indexSet.index(e)];
          auto father = e.father();
          for (; ; father = father.father()) {
            (*persistentData_)[idSet.id(father)] = value;
            if (!father.hasFather())
              break;
          }
        }
      }
    }
 
    void updateImpl(event::adapt e) override
    {
      resize();
 
      // interpolate the data
      auto const& indexSet = grid_->leafIndexSet();
      auto const& idSet = grid_->localIdSet();
      for (auto const& e : elements(grid_->leafGridView()))
      {
        T value = 0;
        auto father = e;
        if (e.isNew() && e.hasFather())
          father = e.father();
 
        for (; ; father = father.father()) {
          auto it = persistentData_->find(idSet.id(father));
          if (it != persistentData_->end()) {
            value = it->second;
            break;
          }
          if (!father.hasFather())
            break;
        }
 
        data_[indexSet.index(e)] = value;
      }
    }
 
    void updateImpl(event::postAdapt) override
    {
      persistentData_.reset();
    }
 
  private:
    std::shared_ptr<Grid const> grid_;
    Data data_;
 
    std::optional<std::map<typename Grid::LocalIdSet::IdType, T>> persistentData_;
  };
 
} // end namespace AMDiS