PatchArray.h

Go to the documentation of this file.

/***************************************************************************
 *  ThunderEgg, a library for solvers on adaptively refined block-structured
 *  Cartesian grids.
 *
 *  Copyright (c) 2021      Scott Aiton
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 ***************************************************************************/
 
#ifndef THUNDEREGG_PATCHARRAY_H
#define THUNDEREGG_PATCHARRAY_H
 
#include <ThunderEgg/PatchView.h>
namespace ThunderEgg {
template<int D>
class PatchArray
{
private:
  std::vector<double> vector;
  PatchView<double, D> view;
 
public:
  PatchArray() = default;
  PatchArray(const std::array<int, D>& lengths, int num_components, int num_ghost_cells)
  {
    std::array<int, D + 1> view_lengths;
    for (int i = 0; i < D; i++) {
      view_lengths[i] = lengths[i];
    }
    view_lengths[D] = num_components;
    std::array<int, D + 1> strides;
    strides[0] = 1;
    for (int i = 1; i < D + 1; i++) {
      strides[i] = strides[i - 1] * (lengths[i - 1] + 2 * num_ghost_cells);
    }
    int size = strides[D] * num_components;
    vector.resize(size);
    view = PatchView<double, D>(vector.data(), strides, view_lengths, num_ghost_cells);
  }
 
  PatchArray(const PatchArray<D>& other)
    : vector(other.vector)
    , view(vector.data(),
           other.getStrides(),
           other.getGhostStart(),
           other.getStart(),
           other.getEnd(),
           other.getGhostEnd())
 
  {}
 
  PatchArray<D>& operator=(const PatchArray<D>& other)
  {
    vector = other.vector;
    view = PatchView<double, D>(vector.data(),
                                other.getStrides(),
                                other.getGhostStart(),
                                other.getStart(),
                                other.getEnd(),
                                other.getGhostEnd());
    return *this;
  }
 
  template<int M>
  inline View<double, M + 1> getSliceOn(Face<D, M> f, const std::array<int, D - M>& offset)
  {
    return view.template getSliceOn<M>(f, offset);
  }
 
  template<int M>
  inline View<const double, M + 1> getSliceOn(Face<D, M> f,
                                              const std::array<int, D - M>& offset) const
  {
    return View<const double, M + 1>(view.template getSliceOn<M>(f, offset));
  }
 
  template<int M>
  inline View<double, M + 1> getGhostSliceOn(Face<D, M> f,
                                             const std::array<size_t, D - M>& offset) const
  {
    return view.template getGhostSliceOn<M>(f, offset);
  }
 
  inline const double& operator[](const std::array<int, D + 1>& coord) const { return view[coord]; }
  template<class... Types>
  inline const double& operator()(Types... args) const
  {
    return view(args...);
  }
  inline void set(const std::array<int, D + 1>& coord, double value) const
  {
    view.set(coord, value);
  }
  inline double& operator[](const std::array<int, D + 1>& coord) { return view[coord]; }
  template<class... Types>
  inline double& operator()(Types... args)
  {
    return view(args...);
  }
  inline void set(const std::array<int, D + 1>& coord, double value) { view.set(coord, value); }
 
  inline const std::array<int, D + 1>& getStrides() const { return view.getStrides(); }
  inline const std::array<int, D + 1>& getStart() const { return view.getStart(); }
  inline const std::array<int, D + 1>& getEnd() const { return view.getEnd(); }
  inline const std::array<int, D + 1>& getGhostStart() const { return view.getGhostStart(); }
  inline const std::array<int, D + 1>& getGhostEnd() const { return view.getGhostEnd(); }
  const PatchView<double, D>& getView() { return view; }
};
extern template class PatchArray<1>;
extern template class PatchArray<2>;
extern template class PatchArray<3>;
} // namespace ThunderEgg
#endif