gridded_fields.h

Go to the documentation of this file.

 
#ifndef gridded_fields_h
#define gridded_fields_h
 
#include <stdexcept>
#include <utility>
 
#include "array.h"
#include "matpack_arrays.h"
#include "matpack_data.h"
#include "mystring.h"
 
namespace GriddedFieldGrids {
inline constexpr Index GFIELD1_F_GRID = 0;
 
inline constexpr Index GFIELD3_P_GRID = 0;
 
inline constexpr Index GFIELD3_LAT_GRID = 1;
 
inline constexpr Index GFIELD3_LON_GRID = 2;
 
inline constexpr Index GFIELD4_FIELD_NAMES = 0;
 
inline constexpr Index GFIELD4_IA_GRID = 0;
 
inline constexpr Index GFIELD4_P_GRID = 1;
 
inline constexpr Index GFIELD4_F_GRID = 1;
 
inline constexpr Index GFIELD4_LAT_GRID = 2;
 
inline constexpr Index GFIELD4_ZA_GRID = 2;
 
inline constexpr Index GFIELD4_LON_GRID = 3;
 
inline constexpr Index GFIELD4_AA_GRID = 3;
}  // namespace GriddedFieldGrids
 
enum GridType { GRID_TYPE_NUMERIC, GRID_TYPE_STRING };
 
using ArrayOfGridType = Array<GridType>;
 
#define CHECK_ERROR_BOILERPLATE                           \
  "size mismatch between grids and data.\n"               \
  "Note that a grid is allowed to be empty, but in the\n" \
  "data that dimension must have exactly one element.\n"
 
template <Index N, typename GriddedFieldType>
String metaErrorData(const GriddedFieldType& gf) {
  std::ostringstream os;
  os << "GriddedField" << N << " ";
  if (gf.get_name().length()) os << "(" << gf.get_name() << ") ";
  os << CHECK_ERROR_BOILERPLATE;
  for (Index i = 0; i < N; i++) {
    os << "Grid";
    if (gf.get_grid_name(i).nelem()) os << " (" << gf.get_grid_name(i) << ")";
    os << " = " << gf.get_grid_size(i) << "\n";
  }
  os << "Data =";
  if constexpr (N > 6)
    os << ' ' <<gf.data.nlibraries();
  if constexpr (N > 5)
    os << ' ' <<gf.data.nvitrines();
  if constexpr (N > 4)
    os << ' ' <<gf.data.nshelves();
  if constexpr (N > 3)
    os << ' ' <<gf.data.nbooks();
  if constexpr (N > 2)
    os << ' ' <<gf.data.npages();
  if constexpr (N > 1)
    os << ' ' <<gf.data.nrows() << ' ' << gf.data.ncols();
  else
    os << ' ' << gf.data.nelem();
  return os.str();
}
 
class GriddedField {
 private:
  Index dim;
  String mname;
  Array<GridType> mgridtypes;
  ArrayOfString mgridnames;
  Array<ArrayOfString> mstringgrids;
  ArrayOfVector mnumericgrids;
 
 protected:
 
  GriddedField()
      : dim(0),
        mname(),
        mgridtypes(),
        mgridnames(),
        mstringgrids(),
        mnumericgrids() { /* Nothing to do here */
  }
 
 
  GriddedField(const Index d, String s)
      : dim(d),
        mname(std::move(s)),
        mgridtypes(d, GRID_TYPE_NUMERIC),
        mgridnames(d),
        mstringgrids(d),
        mnumericgrids(d) { /* Nothing to do here */
  }
 
 public:
  virtual ~GriddedField() = default;
  GriddedField(const GriddedField&) = default;
  GriddedField(GriddedField&&) = default;
  GriddedField& operator=(const GriddedField&) = default;
  GriddedField& operator=(GriddedField&&) = default;
 
 
  [[nodiscard]] Index get_dim() const { return dim; }
 
  void copy_grids(const GriddedField& gf);
 
 
  [[nodiscard]] const String& get_grid_name(Index i) const { return mgridnames[i]; }
 
 
  [[nodiscard]] Index get_grid_size(Index i) const {
    Index ret = 0;
    ARTS_ASSERT(i < dim);
    switch (mgridtypes[i]) {
      case GRID_TYPE_NUMERIC:
        ret = mnumericgrids[i].nelem();
        break;
      case GRID_TYPE_STRING:
        ret = mstringgrids[i].nelem();
        break;
    }
 
    return ret;
  }
 
 
  [[nodiscard]] GridType get_grid_type(Index i) const { return mgridtypes[i]; }
 
  [[nodiscard]] const Vector& get_numeric_grid(Index i) const;
 
  Vector& get_numeric_grid(Index i);
 
  [[nodiscard]] const ArrayOfString& get_string_grid(Index i) const;
 
  ArrayOfString& get_string_grid(Index i);
 
 
  [[nodiscard]] const String& get_name() const { return mname; }
 
  void set_grid(Index i, const Vector& g);
 
  void set_grid(Index i, const ArrayOfString& g);
 
 
  void set_grid_name(Index i, const String& s) {
    ARTS_ASSERT(i < dim);
    mgridnames[i] = s;
  }
 
 
  void set_name(const String& s) { mname = s; }
 
 
  [[nodiscard]] virtual bool checksize() const = 0;
 
 
  virtual void checksize_strict() const = 0;
 
  friend std::ostream& operator<<(std::ostream& os, const GriddedField& gf);
};
 
class GriddedField1 final : public GriddedField {
 public:
  GriddedField1() : GriddedField(1, "") {}
 
  GriddedField1(const String& s) : GriddedField(1, s) {}
 
  [[nodiscard]] bool checksize() const final {
    return (!get_grid_size(0) && data.nelem() == 1) ||
           data.nelem() == get_grid_size(0);
  }
 
  void checksize_strict() const final {
    ARTS_USER_ERROR_IF (!checksize(), metaErrorData<1, GriddedField1>(*this))
  }
 
 
  void resize(const GriddedField1& gf) { data.resize(gf.get_grid_size(0)); }
 
 
  void resize(Index n) { data.resize(n); }
 
  friend std::ostream& operator<<(std::ostream& os, const GriddedField1& gf);
  
  friend String metaErrorData<1, GriddedField1>(const GriddedField1& gf);
 
  Vector data;
};
 
class GriddedField2 final : public GriddedField {
 public:
  GriddedField2() : GriddedField(2, "") {}
 
  GriddedField2(const String& s) : GriddedField(2, s) {}
 
  [[nodiscard]] bool checksize() const final {
    return ((!get_grid_size(1) && data.ncols() == 1) ||
            data.ncols() == get_grid_size(1)) &&
           ((!get_grid_size(0) && data.nrows() == 1) ||
            data.nrows() == get_grid_size(0));
  }
 
  void checksize_strict() const final {
    ARTS_USER_ERROR_IF (!checksize(), metaErrorData<2, GriddedField2>(*this))
  }
 
 
  void resize(const GriddedField2& gf) {
    data.resize(gf.get_grid_size(0), gf.get_grid_size(1));
  }
 
 
  void resize(Index r, Index c) { data.resize(r, c); }
 
  friend std::ostream& operator<<(std::ostream& os, const GriddedField2& gf);
  
  friend String metaErrorData<2, GriddedField2>(const GriddedField2& gf);
 
  Matrix data;
};
 
class GriddedField3 final : public GriddedField {
 public:
  GriddedField3() : GriddedField(3, "") {}
 
  GriddedField3(const String& s) : GriddedField(3, s) {}
 
  GriddedField3& operator=(Numeric n) {
    data = n;
 
    return *this;
  }
 
  [[nodiscard]] bool checksize() const final {
    return ((!get_grid_size(2) && data.ncols() == 1) ||
            data.ncols() == get_grid_size(2)) &&
           ((!get_grid_size(1) && data.nrows() == 1) ||
            data.nrows() == get_grid_size(1)) &&
           ((!get_grid_size(0) && data.npages() == 1) ||
            data.npages() == get_grid_size(0));
  }
 
  void checksize_strict() const final {
    ARTS_USER_ERROR_IF (!checksize(), metaErrorData<3, GriddedField3>(*this))
  }
 
 
  void resize(const GriddedField3& gf) {
    data.resize(gf.get_grid_size(0), gf.get_grid_size(1), gf.get_grid_size(2));
  }
 
 
  void resize(Index p, Index r, Index c) { data.resize(p, r, c); }
 
  friend std::ostream& operator<<(std::ostream& os, const GriddedField3& gf);
  
  friend String metaErrorData<3, GriddedField3>(const GriddedField3& gf);
 
  Tensor3 data;
};
 
class GriddedField4 final : public GriddedField {
 public:
  GriddedField4() : GriddedField(4, "") {}
 
  GriddedField4(const String& s) : GriddedField(4, s) {}
 
  [[nodiscard]] bool checksize() const final {
    return ((!get_grid_size(3) && data.ncols() == 1) ||
            data.ncols() == get_grid_size(3)) &&
           ((!get_grid_size(2) && data.nrows() == 1) ||
            data.nrows() == get_grid_size(2)) &&
           ((!get_grid_size(1) && data.npages() == 1) ||
            data.npages() == get_grid_size(1)) &&
           ((!get_grid_size(0) && data.nbooks() == 1) ||
            data.nbooks() == get_grid_size(0));
  }
 
  void checksize_strict() const final {
    ARTS_USER_ERROR_IF (!checksize(), metaErrorData<4, GriddedField4>(*this))
  }
 
 
  void resize(const GriddedField4& gf) {
    data.resize(gf.get_grid_size(0),
                gf.get_grid_size(1),
                gf.get_grid_size(2),
                gf.get_grid_size(3));
  }
 
 
  void resize(Index b, Index p, Index r, Index c) { data.resize(b, p, r, c); }
 
  friend std::ostream& operator<<(std::ostream& os, const GriddedField4& gf);
  
  friend String metaErrorData<4, GriddedField4>(const GriddedField4& gf);
 
  Tensor4 data;
};
 
class GriddedField5 final : public GriddedField {
 public:
  GriddedField5() : GriddedField(5, "") {}
 
  GriddedField5(const String& s) : GriddedField(5, s) {}
 
  [[nodiscard]] bool checksize() const final {
    return ((!get_grid_size(4) && data.ncols() == 1) ||
            data.ncols() == get_grid_size(4)) &&
           ((!get_grid_size(3) && data.nrows() == 1) ||
            data.nrows() == get_grid_size(3)) &&
           ((!get_grid_size(2) && data.npages() == 1) ||
            data.npages() == get_grid_size(2)) &&
           ((!get_grid_size(1) && data.nbooks() == 1) ||
            data.nbooks() == get_grid_size(1)) &&
           ((!get_grid_size(0) && data.nshelves() == 1) ||
            data.nshelves() == get_grid_size(0));
  }
 
  void checksize_strict() const final {
    ARTS_USER_ERROR_IF (!checksize(), metaErrorData<5, GriddedField5>(*this))
  }
 
 
  void resize(const GriddedField5& gf) {
    data.resize(gf.get_grid_size(0),
                gf.get_grid_size(1),
                gf.get_grid_size(2),
                gf.get_grid_size(3),
                gf.get_grid_size(4));
  }
 
 
  void resize(Index s, Index b, Index p, Index r, Index c) {
    data.resize(s, b, p, r, c);
  }
 
  friend std::ostream& operator<<(std::ostream& os, const GriddedField5& gf);
  
  friend String metaErrorData<5, GriddedField5>(const GriddedField5& gf);
 
  Tensor5 data;
};
 
class GriddedField6 final : public GriddedField {
 public:
  GriddedField6() : GriddedField(6, "") {}
 
  GriddedField6(const String& s) : GriddedField(6, s) {}
 
  [[nodiscard]] bool checksize() const final {
    return ((!get_grid_size(5) && data.ncols() == 1) ||
            data.ncols() == get_grid_size(5)) &&
           ((!get_grid_size(4) && data.nrows() == 1) ||
            data.nrows() == get_grid_size(4)) &&
           ((!get_grid_size(3) && data.npages() == 1) ||
            data.npages() == get_grid_size(3)) &&
           ((!get_grid_size(2) && data.nbooks() == 1) ||
            data.nbooks() == get_grid_size(2)) &&
           ((!get_grid_size(1) && data.nshelves() == 1) ||
            data.nshelves() == get_grid_size(1)) &&
           ((!get_grid_size(0) && data.nvitrines() == 1) ||
            data.nvitrines() == get_grid_size(0));
  }
 
  void checksize_strict() const final {
    ARTS_USER_ERROR_IF (!checksize(), metaErrorData<6, GriddedField6>(*this))
  }
 
 
  void resize(const GriddedField6& gf) {
    data.resize(gf.get_grid_size(0),
                gf.get_grid_size(1),
                gf.get_grid_size(2),
                gf.get_grid_size(3),
                gf.get_grid_size(4),
                gf.get_grid_size(5));
  }
 
 
  void resize(Index v, Index s, Index b, Index p, Index r, Index c) {
    data.resize(v, s, b, p, r, c);
  }
 
  friend std::ostream& operator<<(std::ostream& os, const GriddedField6& gf);
  
  friend String metaErrorData<6, GriddedField6>(const GriddedField6& gf);
 
  Tensor6 data;
};
 
/************ Array types *************/
 
using ArrayOfGriddedField1 = Array<GriddedField1>;
using ArrayOfGriddedField2 = Array<GriddedField2>;
using ArrayOfGriddedField3 = Array<GriddedField3>;
using ArrayOfGriddedField4 = Array<GriddedField4>;
using ArrayOfGriddedField5 = Array<GriddedField5>;
using ArrayOfArrayOfGriddedField1 = Array<Array<GriddedField1>>;
using ArrayOfArrayOfGriddedField2 = Array<Array<GriddedField2>>;
using ArrayOfArrayOfGriddedField3 = Array<Array<GriddedField3>>;
 
#undef CHECK_ERROR_BOILERPLATE
 
#endif