rcpp_data.hpp

Go to the documentation of this file.

 
#ifndef FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_DATA_HPP
#define FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_DATA_HPP
 
#include "rcpp_interface_base.hpp"
#include "common/information.hpp"
 
class DataInterfaceBase : public FIMSRcppInterfaceBase {
 public:
  Rcpp::NumericVector observed_data;
  Rcpp::NumericVector uncertainty;
  static uint32_t id_g;
  uint32_t id;
  static std::map<uint32_t, std::shared_ptr<DataInterfaceBase>> live_objects;
 
  DataInterfaceBase() {
    this->id = DataInterfaceBase::id_g++;
    /* Create instance of map: key is id and value is pointer to
    DataInterfaceBase */
    // DataInterfaceBase::live_objects[this->id] = this;
  }
 
  DataInterfaceBase(const DataInterfaceBase &other)
      : observed_data(other.observed_data),
        uncertainty(other.uncertainty),
        id(other.id) {}
 
  virtual ~DataInterfaceBase() {}
 
  virtual uint32_t get_id() { return this->id; }
 
  virtual bool add_to_fims_tmb() { return true; };
};
 
class AgeCompDataInterface : public DataInterfaceBase {
 public:
  fims_int amax = 0;
  fims_int ymax = 0;
  RealVector age_comp_data;
  RealVector uncertainty;
 
  AgeCompDataInterface(int ymax = 0, int amax = 0) : DataInterfaceBase() {
    this->amax = amax;
    this->ymax = ymax;
    this->age_comp_data.resize(amax * ymax);
    this->uncertainty.resize(amax * ymax);
    DataInterfaceBase::live_objects[this->id] =
        std::make_shared<AgeCompDataInterface>(*this);
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(
        DataInterfaceBase::live_objects[this->id]);
  }
 
  AgeCompDataInterface(const AgeCompDataInterface &other)
      : DataInterfaceBase(other),
        amax(other.amax),
        ymax(other.ymax),
        age_comp_data(other.age_comp_data),
        uncertainty(other.uncertainty) {}
 
  virtual ~AgeCompDataInterface() {}
 
  virtual uint32_t get_id() { return this->id; }
 
  virtual std::string to_json() {
    std::stringstream ss;
 
    ss << "{\n";
    ss << " \"name\": \"AgeComp\",\n";
    ss << " \"id\":" << this->id << ",\n";
    ss << " \"type\": \"data\",\n";
    ss << " \"dimensionality\": {\n";
    ss << "  \"header\": [" << "\"n_ages\", \"n_years\"" << "],\n";
    ss << "  \"dimensions\": [" << amax << ", " << ymax << "]\n},\n";
    ss << " \"value\": [";
    for (size_t i = 0; i < age_comp_data.size() - 1; i++) {
      ss << age_comp_data[i] << ", ";
    }
    ss << age_comp_data[age_comp_data.size() - 1] << "],\n";
    ss << "\"uncertainty\":[ ";
    for (size_t i = 0; i < uncertainty.size() - 1; i++) {
      ss << uncertainty[i] << ", ";
    }
    ss << uncertainty[uncertainty.size() - 1] << "]\n";
    ss << "}";
    return ss.str();
  }
 
#ifdef TMB_MODEL
 
  template <typename Type>
  bool add_to_fims_tmb_internal() {
    std::shared_ptr<fims_data_object::DataObject<Type>> age_comp_data =
        std::make_shared<fims_data_object::DataObject<Type>>(this->ymax,
                                                             this->amax);
 
    age_comp_data->id = this->id;
    for (int y = 0; y < ymax; y++) {
      for (int a = 0; a < amax; a++) {
        int i_age_year = y * amax + a;
        age_comp_data->at(y, a) = this->age_comp_data[i_age_year];
        age_comp_data->uncertainty[i_age_year] = this->uncertainty[i_age_year];
      }
    }
 
    std::shared_ptr<fims_info::Information<Type>> info =
        fims_info::Information<Type>::GetInstance();
 
    info->data_objects[this->id] = age_comp_data;
 
    return true;
  }
 
  virtual bool add_to_fims_tmb() {
    this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
    this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();
 
    return true;
  }
 
#endif
};
 
class LengthCompDataInterface : public DataInterfaceBase {
 public:
  fims_int lmax = 0;
  fims_int ymax = 0;
  RealVector length_comp_data;
  RealVector uncertainty;
 
  LengthCompDataInterface(int ymax = 0, int lmax = 0) : DataInterfaceBase() {
    this->lmax = lmax;
    this->ymax = ymax;
    this->length_comp_data.resize(lmax * ymax);
    this->uncertainty.resize(lmax * ymax);
    DataInterfaceBase::live_objects[this->id] =
        std::make_shared<LengthCompDataInterface>(*this);
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(
        DataInterfaceBase::live_objects[this->id]);
  }
 
  LengthCompDataInterface(const LengthCompDataInterface &other)
      : DataInterfaceBase(other),
        lmax(other.lmax),
        ymax(other.ymax),
        length_comp_data(other.length_comp_data),
        uncertainty(other.uncertainty) {}
 
  virtual ~LengthCompDataInterface() {}
 
  virtual uint32_t get_id() { return this->id; }
 
  virtual std::string to_json() {
    std::stringstream ss;
 
    ss << "{\n";
    ss << " \"name\": \"LengthComp\",\n";
    ss << " \"id\":" << this->id << ",\n";
    ss << " \"type\": \"data\",\n";
    ss << " \"dimensionality\": {\n";
    ss << "  \"header\": [" << "\"n_lengths\", \"n_years\"" << "],\n";
    ss << "  \"dimensions\": [" << lmax << ", " << ymax << "]\n},\n";
    ss << " \"value\": [";
    for (size_t i = 0; i < length_comp_data.size() - 1; i++) {
      ss << length_comp_data[i] << ", ";
    }
    ss << length_comp_data[length_comp_data.size() - 1] << "],\n";
    ss << "\"uncertainty\": [ ";
    for (size_t i = 0; i < uncertainty.size() - 1; i++) {
      ss << uncertainty[i] << ", ";
    }
    ss << uncertainty[uncertainty.size() - 1] << "]\n";
    ss << "}";
    return ss.str();
  }
 
#ifdef TMB_MODEL
  template <typename Type>
  bool add_to_fims_tmb_internal() {
    std::shared_ptr<fims_data_object::DataObject<Type>> length_comp_data =
        std::make_shared<fims_data_object::DataObject<Type>>(this->ymax,
                                                             this->lmax);
    length_comp_data->id = this->id;
    for (int y = 0; y < ymax; y++) {
      for (int l = 0; l < lmax; l++) {
        int i_length_year = y * lmax + l;
        length_comp_data->at(y, l) = this->length_comp_data[i_length_year];
        length_comp_data->uncertainty[i_length_year] =
            this->uncertainty[i_length_year];
      }
    }
    std::shared_ptr<fims_info::Information<Type>> info =
        fims_info::Information<Type>::GetInstance();
    info->data_objects[this->id] = length_comp_data;
    return true;
  }
 
  virtual bool add_to_fims_tmb() {
    this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
    this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();
 
    return true;
  }
#endif
};
 
class IndexDataInterface : public DataInterfaceBase {
 public:
  fims_int ymax = 0;
  RealVector index_data;
  RealVector uncertainty;
 
  IndexDataInterface(int ymax = 0) : DataInterfaceBase() {
    this->ymax = ymax;
    this->index_data.resize(ymax);
    this->uncertainty.resize(ymax);
    DataInterfaceBase::live_objects[this->id] =
        std::make_shared<IndexDataInterface>(*this);
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(
        DataInterfaceBase::live_objects[this->id]);
  }
 
  IndexDataInterface(const IndexDataInterface &other)
      : DataInterfaceBase(other),
        ymax(other.ymax),
        index_data(other.index_data),
        uncertainty(other.uncertainty) {}
 
  virtual ~IndexDataInterface() {}
 
  virtual uint32_t get_id() { return this->id; }
 
  virtual std::string to_json() {
    std::stringstream ss;
 
    ss << "{\n";
    ss << " \"name\": \"Index\",\n";
    ss << " \"id\": " << this->id << ",\n";
    ss << " \"type\": \"data\",\n";
    ss << " \"dimensionality\": {\n";
    ss << "  \"header\": [" << "\"n_years\"" << "],\n";
    ss << "  \"dimensions\": [" << ymax << "]\n},\n";
    ss << " \"value\": [";
    for (size_t i = 0; i < index_data.size() - 1; i++) {
      ss << index_data[i] << ", ";
    }
    ss << index_data[index_data.size() - 1] << "],\n";
    ss << "\"uncertainty\": [ ";
    for (size_t i = 0; i < uncertainty.size() - 1; i++) {
      ss << uncertainty[i] << ", ";
    }
    ss << uncertainty[uncertainty.size() - 1] << "]\n";
    ss << "}";
    return ss.str();
  }
 
#ifdef TMB_MODEL
 
  template <typename Type>
  bool add_to_fims_tmb_internal() {
    std::shared_ptr<fims_data_object::DataObject<Type>> data =
        std::make_shared<fims_data_object::DataObject<Type>>(this->ymax);
 
    data->id = this->id;
 
    for (int y = 0; y < ymax; y++) {
      data->at(y) = this->index_data[y];
      data->uncertainty[y] = this->uncertainty[y];
    }
 
    std::shared_ptr<fims_info::Information<Type>> info =
        fims_info::Information<Type>::GetInstance();
 
    info->data_objects[this->id] = data;
    return true;
  }
 
  virtual bool add_to_fims_tmb() {
    this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
    this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();
 
    return true;
  }
 
#endif
};
 
class LandingsDataInterface : public DataInterfaceBase {
 public:
  fims_int ymax = 0;
  RealVector landings_data;
  RealVector uncertainty;
 
  LandingsDataInterface(int ymax = 0) : DataInterfaceBase() {
    this->ymax = ymax;
    this->landings_data.resize(ymax);
    this->uncertainty.resize(ymax);
    DataInterfaceBase::live_objects[this->id] =
        std::make_shared<LandingsDataInterface>(*this);
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(
        DataInterfaceBase::live_objects[this->id]);
  }
 
  LandingsDataInterface(const LandingsDataInterface &other)
      : DataInterfaceBase(other),
        ymax(other.ymax),
        landings_data(other.landings_data),
        uncertainty(other.uncertainty) {}
 
  virtual ~LandingsDataInterface() {}
 
  virtual uint32_t get_id() { return this->id; }
 
  virtual std::string to_json() {
    std::stringstream ss;
 
    ss << "{\n";
    ss << " \"name\": \"Landings\",\n";
    ss << " \"id\": " << this->id << ",\n";
    ss << " \"type\": \"data\",\n";
    ss << " \"dimensionality\": {\n";
    ss << "  \"header\": [" << "\"n_years\"" << "],\n";
    ss << "  \"dimensions\": [" << ymax << "]\n},\n";
    ss << " \"value\": [";
    for (size_t i = 0; i < landings_data.size() - 1; i++) {
      ss << landings_data[i] << ", ";
    }
    ss << landings_data[landings_data.size() - 1] << "],\n";
    ss << "\"uncertainty\": [ ";
    for (size_t i = 0; i < uncertainty.size() - 1; i++) {
      ss << uncertainty[i] << ", ";
    }
    ss << uncertainty[uncertainty.size() - 1] << "]\n";
    ss << "}";
    return ss.str();
  }
 
#ifdef TMB_MODEL
 
  template <typename Type>
  bool add_to_fims_tmb_internal() {
    std::shared_ptr<fims_data_object::DataObject<Type>> data =
        std::make_shared<fims_data_object::DataObject<Type>>(this->ymax);
 
    data->id = this->id;
 
    for (int y = 0; y < ymax; y++) {
      data->at(y) = this->landings_data[y];
      data->uncertainty[y] = this->uncertainty[y];
    }
 
    std::shared_ptr<fims_info::Information<Type>> info =
        fims_info::Information<Type>::GetInstance();
 
    info->data_objects[this->id] = data;
    return true;
  }
 
  virtual bool add_to_fims_tmb() {
    this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
    this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();
 
    return true;
  }
 
#endif
};
 
#endif