data_object.hpp

Go to the documentation of this file.

 
#ifndef FIMS_COMMON_DATA_OBJECT_HPP
#define FIMS_COMMON_DATA_OBJECT_HPP
 
#include <exception>
#include <vector>
 
#include "model_object.hpp"
#include "fims_vector.hpp"
 
namespace fims_data_object {
 
template <typename Type>
struct DataObject : public fims_model_object::FIMSObject<Type> {
  static uint32_t id_g;                    
  fims::Vector<Type> data;                 
  fims::Vector<Type> uncertainty;          
  size_t dimensions;                       
  size_t imax;                             
  size_t jmax;                             
  size_t kmax;                             
  size_t lmax;                             
  Type na_value = static_cast<Type>(-999); 
  DataObject(size_t imax) : dimensions(1), imax(imax) {
    data.resize(imax);
    uncertainty.resize(imax);
    this->id = DataObject<Type>::id_g++;
    this->register_self(this->id);
  }
 
  DataObject(size_t imax, size_t jmax) : dimensions(2), imax(imax), jmax(jmax) {
    data.resize(imax * jmax);
    uncertainty.resize(imax * jmax);
    this->id = DataObject<Type>::id_g++;
    this->register_self(this->id);
  }
 
  DataObject(size_t imax, size_t jmax, size_t kmax)
      : dimensions(3), imax(imax), jmax(jmax), kmax(kmax) {
    data.resize(imax * jmax * kmax);
    uncertainty.resize(imax * jmax * kmax);
    this->id = DataObject<Type>::id_g++;
    this->register_self(this->id);
  }
 
  DataObject(size_t imax, size_t jmax, size_t kmax, size_t lmax)
      : dimensions(4), imax(imax), jmax(jmax), kmax(kmax), lmax(lmax) {
    data.resize(imax * jmax * kmax * lmax);
    uncertainty.resize(imax * jmax * kmax * lmax);
    this->id = DataObject<Type>::id_g++;
    this->register_self(this->id);
  }
 
  inline Type operator()(size_t i) { return data[i]; }
 
  inline Type& at(size_t i) {
    if (i >= this->data.size()) {
      throw std::overflow_error("DataObject error:i index out of bounds");
    }
    return data[i];
  }
 
  inline const Type operator()(size_t i, size_t j) {
    return data[i * jmax + j];
  }
 
  inline Type& at(size_t i, size_t j) {
    if ((i * jmax + j) >= this->data.size()) {
      throw std::overflow_error("DataObject error: index out of bounds");
    }
    return data[i * jmax + j];
  }
 
  inline const Type operator()(size_t i, size_t j, size_t k) {
    return data[i * jmax * kmax + j * kmax + k];
  }
 
  inline Type& at(size_t i, size_t j, size_t k) {
    if ((i * jmax * kmax + j * kmax + k) >= this->data.size()) {
      throw std::overflow_error("DataObject error: index out of bounds");
    }
    return data[i * jmax * kmax + j * kmax + k];
  }
 
  inline const Type operator()(size_t i, size_t j, size_t k, size_t l) {
    return data[i * jmax * kmax * lmax + j * kmax * lmax + k * lmax + l];
  }
 
  inline Type& at(size_t i, size_t j, size_t k, size_t l) {
    if ((i * jmax * kmax * lmax + j * kmax * lmax + k * lmax + l) >=
        this->data.size()) {
      throw std::overflow_error("DataObject error: index out of bounds");
    }
    return data[i * jmax * kmax * lmax + j * kmax * lmax + k * lmax + l];
  }
 
  size_t get_dimensions() const { return dimensions; }
 
  size_t get_imax() const { return imax; }
 
  size_t get_jmax() const { return jmax; }
 
  size_t get_kmax() const { return kmax; }
 
  size_t get_lmax() const { return lmax; }
};
 
template <typename Type>
uint32_t DataObject<Type>::id_g = 0;
 
}  // namespace fims_data_object
 
#endif