flat_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 FLAT_STATE_WRAPPER_H_
#define FLAT_STATE_WRAPPER_H_

#include <map>
#include <memory>
#include <vector>
#include <stdexcept>
#include <utility>
#include <algorithm>

#include "wonton/support/wonton.h"
#include "wonton/support/Point.h"

namespace Wonton {

template <class T=double>
class Flat_State_Wrapper {
 public:

  using pair_t = std::pair<std::string, Entity_kind>;

  Flat_State_Wrapper() = default;

  template <class State_Wrapper>
  void initialize(State_Wrapper const & input,
                   std::vector<std::string> const& var_names)
  {
          clear(); // forget everything

          for (auto varname : var_names)
          {
                  // get name
                  // get entity
                  Entity_kind entity = input.get_entity(varname);

                  // get pointer to data for state from input state wrapper
                  T const* data;
                  input.mesh_get_data(entity, varname, &data);

                  // copy input state data into new vector storage
                  size_t dataSize = input.get_data_size(entity, varname);
                  auto vdata = std::make_shared<std::vector<T>>(dataSize);
              std::copy(data, data+dataSize, vdata->begin());

              // add to database
                  mesh_add_data(entity, varname, vdata);
          }
  }

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

  ~Flat_State_Wrapper() = default;

  void initialize(std::vector<std::string> const& names,
                  std::vector<Entity_kind> const& entities,
                  std::vector<std::shared_ptr<std::vector<T>>> const& data)
  {
    if (not (names.size() == entities.size() and names.size() == data.size() and data.size() == entities.size())) {
        throw std::runtime_error("argument sizes do not agree");
    }

    clear();

    for (size_t i=0; i<names.size(); i++) {
        mesh_add_data(entities[i], names[i], data[i]);
    }
  }

  void get_names(Entity_kind on_what, std::vector<std::string>& names) {
    names.clear();
    for (auto iter=entity_map_.begin(); iter!=entity_map_.end(); iter++) {
      if (iter->second == on_what) {
        names.push_back(iter->first);
      }
    }
  }

  int num_materials() const {
    return 0;
  }

  int mat_get_num_cells(int matid) const {
    return 0;
  }

  void mat_get_cells(int matid, std::vector<int> *matcells) const {
    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;  // MULTI-MATERIAL FIELDS NOT IMPLEMENTED
  }

  void mesh_get_data(Entity_kind on_what, std::string const& var_name,
                     T** data) {
    pair_t pr(var_name, on_what);
    auto iter = name_map_.find(pr);
    if (iter != name_map_.end()) {
      (*data) = (T*)(&((*(state_[iter->second]))[0]));
    } else {
      (*data) = nullptr;
    }
  }

  void mesh_get_data(Entity_kind on_what, std::string const& var_name,
                     T const **data) const {
    pair_t pr(var_name, on_what);
    auto iter = name_map_.find(pr);
    if (iter != name_map_.end()) {
      (*data) = (T const *)(&((*(state_[iter->second]))[0]));
    } else {
      (*data) = nullptr;
    }
  }

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


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



  Entity_kind get_entity(std::string const& var_name) const {
    return entity_map_.at(var_name);
  }

  Entity_kind get_entity(int index) const
  {
    return entities_.at(index);
  }

  size_t get_entity_size(Entity_kind ent) {
    return entity_size_map_[ent];
  }


  const std::type_info& get_data_type(std::string const& name) const {
    size_t index = -1;
    pair_t name_cell_pair(name, Wonton::Entity_kind::CELL);
    auto it = name_map_.find(name_cell_pair);
    if (it != name_map_.end())
      index = get_vector_index(Wonton::Entity_kind::CELL, name);
    else {
      pair_t name_node_pair = std::make_pair(name, Wonton::Entity_kind::NODE);
      it = name_map_.find(name_node_pair);
      if (it != name_map_.end())
        index = get_vector_index(Wonton::Entity_kind::NODE, name);
    }

    if (index >= 0) {
      return typeid(T);
    } else {
      std::cerr << "Could not find state variable " << name << "\n";
      return typeid(0);
    }
  }


  size_t get_vector_index(Entity_kind ent, std::string const& name) {
    pair_t pair(name, ent);
    return name_map_[pair];
  }

  std::shared_ptr<std::vector<T>> get_vector(size_t index)
  {
    return state_[index];
  }

  std::shared_ptr<std::vector<Wonton::Point3>> get_gradients(size_t index)
  {
    return gradients_[index];
  }

  size_t get_num_vectors() { return state_.size(); }

  void add_gradients(std::shared_ptr<std::vector<Wonton::Point3>> new_grad)
  {
    if (new_grad->empty()) return;
    gradients_.push_back(new_grad);
  }

  size_t get_field_stride(size_t index)
  {
    return 1;
  }

  size_t get_num_gradients() { return gradients_.size(); }

private:
  std::vector<std::shared_ptr<std::vector<T>>> state_;
  int nmats_ = 0;
  std::map<pair_t, size_t> name_map_;
  std::vector<Entity_kind> entities_;
  std::map<std::string, Entity_kind> entity_map_;
  std::map<Entity_kind, size_t> entity_size_map_;
  std::vector<std::shared_ptr<std::vector<Wonton::Point3>>> gradients_;

  void clear(){
          state_.clear();
          name_map_.clear();
          entity_map_.clear();
          entity_size_map_.clear();
          gradients_.clear();
  }

  void mesh_add_data(Entity_kind on_what, std::string const& var_name,
                     std::shared_ptr<std::vector<T>> data) {
    // if we have seen this entity before - check size match, else
    // store this size
    auto sziter = entity_size_map_.find(on_what);
    if (sziter != entity_size_map_.end()) {
      if (sziter->second != data->size()) {
        throw std::runtime_error(std::string("variable ")+var_name+
                                 " has incompatible size on add");
      }
    } else {
      entity_size_map_[on_what] = data->size();
    }
    
    // store data and update internal book-keeping
    pair_t pair(var_name, on_what);
    auto iter = name_map_.find(pair);
    if (iter == name_map_.end()) {  // have not seen this entity-name combo before, add data
      state_.push_back(data);
      name_map_[pair] = state_.size() - 1;
      entities_.push_back(on_what);
      entity_map_[var_name] = on_what;
      entity_size_map_[on_what] = data->size();
    } else {  // have seen the entity-name combo already, replace data. already checked size.
      std::copy(data->begin(), data->end(), state_[iter->second]->begin());
    }
  }
};  // Flat_State_Wrapper

}  // namespace Wonton

#endif  // FLAT_STATE_WRAPPER_H_