simple_state_wrapper.h

Go to the documentation of this file.

/*
This file is part of the Ristra Wonton project.
Please see the license file at the root of this repository, or at:
    https://github.com/laristra/wonton/blob/master/LICENSE
*/

#ifndef WONTON_SIMPLE_STATE_WRAPPER_H_
#define WONTON_SIMPLE_STATE_WRAPPER_H_

#include <string>

#include "wonton/state/simple/simple_state.h"

#include "wonton/support/wonton.h"

namespace Wonton {

class Simple_State_Wrapper {
 public:
  explicit Simple_State_Wrapper(Simple_State & state) : state_(state) { }

  Simple_State_Wrapper & operator=(Simple_State_Wrapper const &) = delete;

  ~Simple_State_Wrapper() { }

  //  void init_from_mesh() { state_.init_from_mesh(); }
  //  void export_to_mesh() { state_.export_to_mesh(); }

  int num_materials() const {
    return 0;
  }

  std::string material_name(int matid) const {
    assert(matid >= 0 && matid < num_materials());
    return "UNKNOWN";
  }

  int mat_get_num_cells(int matid) const {
    assert(matid >= 0 && matid < num_materials());
    return 0;
  }

  void mat_get_cells(int matid, std::vector<int> *matcells) const {
    assert(matid >= 0 && matid < num_materials());
    matcells->clear();
  }

  int cell_get_num_mats(int cellid) const {
    return 0;
  }

  void cell_get_mats(int cellid, std::vector<int> *cellmats) const {
    cellmats->clear();
  }

  int cell_index_in_material(int meshcell, int matid) const {
    return -1;
  }
  
  Field_type field_type(Entity_kind on_what, std::string const& var_name)
      const {
    return Field_type::MESH_FIELD;
  }

  void mesh_get_data(Entity_kind on_what, std::string const& name,
                double **data) {
    auto it = state_.find(name, on_what);
    if (it != state_.end()) {
      (*data) = &(it->second[0]);
      return;
    }

    std::cerr << "get_data: Could not find state variable " << name
              << std::endl;
    (*data) = nullptr;
  }

  void mesh_get_data(Entity_kind on_what, std::string const& name,
                  double const **data) const {
    auto it = state_.find(name, on_what);
    if (it != state_.end()) {
      (*data) = &(it->second[0]);
      return;
    }

    std::cerr << "get_data: Could not find state variable " << name
              << std::endl;
    (*data) = nullptr;
  }

  void mat_get_celldata(std::string const& var_name, int matid,
                        double const **data) const {
  }

  // TEMPORARY: UNTIL THIS GETS TEMPLATED ON TYPE OF DATA
  void mat_get_celldata(std::string const& var_name, int matid,
                        Wonton::Point<2> const **data) const {
  }
  void mat_get_celldata(std::string const& var_name, int matid,
                        Wonton::Point<3> const **data) const {
  }


  void mat_get_celldata(std::string const& var_name, int matid, double **data) {
  }

  void mesh_add_data(Entity_kind on_what, std::string const& name,
                  double const **data) const {
    auto vec = state_.add(name, on_what, *data);
  }

  void mat_add_celldata(std::string const& var_name, double value) {
  }


  void mat_add_celldata(std::string const& var_name,
                        double const * const *values = nullptr,
                        Data_layout layout = Data_layout::MATERIAL_CENTRIC) {
  }


  void mat_add_celldata(std::string const& var_name, int matid,
                        double const * values) {
  }


  void mat_add_celldata(std::string const& var_name, int matid, double value) {
  }


  void mat_add_cells(int matid, std::vector<int> const& newcells) {
  }


  void mat_rem_cells(int matid, std::vector<int> const& delcells) {
  }


  void add_material(std::string const& matname,
                    std::vector<int> const& matcells) {
  }

  Entity_kind get_entity(std::string const& name) const {
    // Find where the name is in the variable name part of the map's keys
    auto it = state_.begin();
    while (it != state_.end()) {
      if (it->first.first == name)
        break;
      else
        ++it;
    }
    // Now get the second part of the key, if it was found
    if (it != state_.end()) {
      return it->first.second;
    } else {
      // We don't know this variable, so bail.
      throw std::runtime_error("Requested variable not found.");
    }
  }

  int get_data_size(Entity_kind on_what, std::string const& name) const {
    auto it = state_.find(name, on_what);
    if (it != state_.end()) {
      return it->second.size();
    }

    std::cerr << "get_data_size: Could not find state variable " << name
              << std::endl;
    return 0;
  }



  const std::type_info& get_data_type(std::string const& var_name) const {
    auto it = state_.find(var_name);
    if (it != state_.end())
      return typeid(double);  // Thats the only type we can handle for now
    else
      return typeid(void);
  }

  Simple_State::name_vec_it names_begin() const {
    return state_.names_begin();
  }

  Simple_State::name_vec_it names_end() const {
    return state_.names_end();
  }

  typename Simple_State::name_vec names() const {return state_.names();}

 private:
  Simple_State & state_;
};  // class Simple_State_Wrapper
}  // namespace Wonton 

#endif  // WONTON_SIMPLE_STATE_WRAPPER_H_