ComponentArray.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_COMPONENTARRAY_H
#define THUNDEREGG_COMPONENTARRAY_H
#include <ThunderEgg/ComponentView.h>
namespace ThunderEgg {
template<int D>
class ComponentArray
{
private:
  std::vector<double> vector;
  ComponentView<double, D> view;
 
public:
  ComponentArray(const std::array<int, D>& lengths, int num_ghost_cells)
  {
    std::array<int, D> strides;
    strides[0] = 1;
    for (int i = 1; i < D; i++) {
      strides[i] = strides[i - 1] * (lengths[i - 1] + 2 * num_ghost_cells);
    }
    int size = strides[D - 1] * (lengths[D - 1] + 2 * num_ghost_cells);
    vector.resize(size);
    view = ComponentView<double, D>(vector.data(), strides, lengths, num_ghost_cells);
  }
 
  ComponentArray(const ComponentArray<D>& other)
    : vector(other.vector)
    , view(vector.data(),
           other.getStrides(),
           other.getGhostStart(),
           other.getStart(),
           other.getEnd(),
           other.getGhostEnd())
 
  {}
 
  ComponentArray<D>& operator=(const ComponentArray<D>& other)
  {
    vector = other.vector;
    view = ComponentView<double, D>(vector.data(),
                                    other.getStrides(),
                                    other.getGhostStart(),
                                    other.getStart(),
                                    other.getEnd(),
                                    other.getGhostEnd());
    return *this;
  }
  template<int M>
  inline View<double, M> 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> getSliceOn(Face<D, M> f, const std::array<int, D - M>& offset) const
  {
    return View<const double, M>(view.template getSliceOn<M>(f, offset));
  }
 
  template<int M>
  inline View<double, M> 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>& 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>& coord, double value) const { view.set(coord, value); }
  inline double& operator[](const std::array<int, D>& coord) { return view[coord]; }
  template<class... Types>
  inline double& operator()(Types... args)
  {
    return view(args...);
  }
  inline void set(const std::array<int, D>& coord, double value) { view.set(coord, value); }
 
  inline const std::array<int, D>& getStrides() const { return view.getStrides(); }
  inline const std::array<int, D>& getStart() const { return view.getStart(); }
  inline const std::array<int, D>& getEnd() const { return view.getEnd(); }
  inline const std::array<int, D>& getGhostStart() const { return view.getGhostStart(); }
  inline const std::array<int, D>& getGhostEnd() const { return view.getGhostEnd(); }
};
extern template class ComponentArray<1>;
extern template class ComponentArray<2>;
extern template class ComponentArray<3>;
} // namespace ThunderEgg
#endif