jali_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_STATE_JALI_JALI_STATE_WRAPPER_H_
#define WONTON_STATE_JALI_JALI_STATE_WRAPPER_H_

#include <type_traits>
#include <string>
#include <vector>
#include <memory>

// Jali includes
#include "Mesh.hh"
#include "JaliState.h"

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

namespace Wonton {

class Jali_State_Wrapper {
 public:
  explicit Jali_State_Wrapper(Jali::State & jali_state)
      : jali_state_(jali_state) {}

  Jali_State_Wrapper(Jali_State_Wrapper & state) :
      jali_state_(state.jali_state_) {}

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

  ~Jali_State_Wrapper() {}


  void init_from_mesh() { jali_state_.init_from_mesh(); }

  void export_to_mesh() {jali_state_.export_to_mesh(); }


  int num_materials() const {
    return jali_state_.num_materials();
  }

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

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

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

  int cell_get_num_mats(int cellid) const {
    return jali_state_.num_cell_materials(cellid);
  }

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

  int cell_index_in_material(int meshcell, int matid) const {
    return jali_state_.cell_index_in_material(meshcell, matid);
  }

  Field_type field_type(Entity_kind on_what, std::string const& var_name) const {

    auto it = jali_state_.cbegin();
    while (it != jali_state_.cend()) {
      std::shared_ptr<Jali::StateVectorBase> bvec = *it;
      if (bvec->name() == var_name &&
          static_cast<Entity_kind>(bvec->entity_kind()) == on_what) {
        if (bvec->type() == Jali::StateVector_type::UNIVAL)
          return Field_type::MESH_FIELD;
        else
          return Field_type::MULTIMATERIAL_FIELD;
      }
      it++;
    }
    throw std::runtime_error("cannot retrieve field type");
  }


  template <class T>
  void mesh_get_data(Entity_kind on_what, std::string const& var_name,
                     T const **data) const {
    Jali::UniStateVector<T, Jali::Mesh> vector;
    if (jali_state_.get<T, Jali::Mesh, Jali::UniStateVector>(var_name,
                                                    jali_state_.mesh(),
                                                    (Jali::Entity_kind) on_what,
                                                    Jali::Entity_type::ALL,
                                                    &vector)) {
      *data = (T const *) vector.get_raw_data();
    } else {
      std::cerr << "Could not find state variable " << var_name << "\n";
      *data = nullptr;
    }
  }


  template <class T>
  void mesh_get_data(Entity_kind on_what, std::string const& var_name,
                     T **data) {
    using T1 = typename std::remove_const<T>::type;
    Jali::UniStateVector<T1, Jali::Mesh> vector;
    if (jali_state_.get<T1, Jali::Mesh, Jali::UniStateVector>(var_name,
                                                    jali_state_.mesh(),
                                                    (Jali::Entity_kind) on_what,
                                                    Jali::Entity_type::ALL,
                                                    &vector)) {
      *data = vector.get_raw_data();
    } else {
      std::cerr << "Could not find state variable " << var_name << "\n";
      *data = nullptr;
    }
  }


  template <class T>
  void mat_get_celldata(std::string const& var_name, int matid,
                        T const **data) const {
    Jali::MultiStateVector<T, Jali::Mesh> mmvector;
    if (jali_state_.get<T, Jali::Mesh, Jali::MultiStateVector>(var_name,
                                                      jali_state_.mesh(),
                                                      Jali::Entity_kind::CELL,
                                                      Jali::Entity_type::ALL,
                                                      &mmvector)) {
      // data copy
      *data = (T const *) mmvector.get_raw_data(matid);
    } else {
      std::cerr << "Could not find state variable " << var_name << "\n";
      *data = nullptr;
    }
  }


  template <class T>
  void mat_get_celldata(std::string const& var_name, int matid, T **data) {
    using T1 = typename std::remove_const<T>::type;

    Jali::MultiStateVector<T1, Jali::Mesh> mmvector;
    if (jali_state_.get<T1, Jali::Mesh, Jali::MultiStateVector>(var_name,
                                                      jali_state_.mesh(),
                                                      Jali::Entity_kind::CELL,
                                                      Jali::Entity_type::ALL,
                                                      &mmvector)) {
      // data copy
      *data = mmvector.get_raw_data(matid);
    } else {
      std::cerr << "Could not find state variable " << var_name << "\n";
      *data = nullptr;
    }
  }


  template <class T>
  void mesh_add_data(Entity_kind on_what, std::string const& var_name,
                     T const * const values) {
    jali_state_.add(var_name, jali_state_.mesh(), (Jali::Entity_kind) on_what,
                    Jali::Entity_type::ALL, values);
  }

  template <class T>
  typename std::enable_if<(!std::is_pointer<T>::value &&
                           !std::is_array<T>::value),
                          void>::type
  mesh_add_data(Entity_kind on_what, std::string const& var_name,
                const T value) {
    // Compiler needs some help deducing template parameters here
    jali_state_.add<T, Jali::Mesh, Jali::UniStateVector>(var_name,
                                                    jali_state_.mesh(),
                                                    (Jali::Entity_kind) on_what,
                                                    Jali::Entity_type::ALL,
                                                    value);
  }


  template <class T>
  typename std::enable_if<(!std::is_pointer<T>::value &&
                           !std::is_array<T>::value),
                          void>::type
  mat_add_celldata(std::string const& var_name, T value) {
    jali_state_.add<T, Jali::Mesh, Jali::MultiStateVector>(var_name,
                                                        jali_state_.mesh(),
                                                        Jali::Entity_kind::CELL,
                                                        Jali::Entity_type::ALL,
                                                        value);
  }


  template <class T>
  void mat_add_celldata(std::string const& var_name,
                        T const * const *values = nullptr,
                        Data_layout layout = Data_layout::MATERIAL_CENTRIC) {
    jali_state_.add(var_name, jali_state_.mesh(), Jali::Entity_kind::CELL,
                    Jali::Entity_type::ALL, (Jali::Data_layout) layout, values);
  }


  template <class T>
  void mat_add_celldata(std::string const& var_name, int matid,
                        T const * values) {
    auto it = jali_state_.find<T, Jali::Mesh, Jali::MultiStateVector>(var_name,
                                                        jali_state_.mesh(),
                                                        Jali::Entity_kind::CELL,
                                                        Jali::Entity_type::ALL);

    if (it == jali_state_.end()) {
      Jali::MultiStateVector<T, Jali::Mesh>& mmvec =
          jali_state_.add<T, Jali::Mesh, Jali::MultiStateVector>(var_name,
                                                  jali_state_.mesh(),
                                                  Jali::Entity_kind::CELL,
                                                  Jali::Entity_type::ALL);
      std::vector<T>& matdata = mmvec.get_matdata(matid);
      int nmatcells = matdata.size();
      matdata.assign(values, values+nmatcells);
    } else {
      Jali::MultiStateVector<T, Jali::Mesh>& mmvec =
          *(std::dynamic_pointer_cast<
            Jali::MultiStateVector<T, Jali::Mesh>>(*it));
      std::vector<T>& matdata = mmvec.get_matdata(matid);
      int nmatcells = matdata.size();
      matdata.assign(values, values+nmatcells);
    }
  }


  template <class T>
  typename
  std::enable_if<(!std::is_pointer<T>::value && !std::is_array<T>::value),
                 void>::type
  mat_add_celldata(std::string const& var_name, int matid, T value) {
    auto it = jali_state_.find<T, Jali::Mesh, Jali::MultiStateVector>(var_name,
                                                        jali_state_.mesh(),
                                                        Jali::Entity_kind::CELL,
                                                        Jali::Entity_type::ALL);

    if (it == jali_state_.end()) {
      Jali::MultiStateVector<T, Jali::Mesh>& mmvec =
          jali_state_.add<T, Jali::Mesh, Jali::MultiStateVector>(var_name,
                                                  jali_state_.mesh(),
                                                  Jali::Entity_kind::CELL,
                                                  Jali::Entity_type::ALL);
      std::vector<T>& matdata = mmvec.get_matdata(matid);
      int nmatcells = matdata.size();
      matdata.assign(nmatcells, value);
    } else {
      Jali::MultiStateVector<T, Jali::Mesh>& mmvec =
          *(std::dynamic_pointer_cast<
            Jali::MultiStateVector<T, Jali::Mesh>>(*it));
      std::vector<T>& matdata = mmvec.get_matdata(matid);
      int nmatcells = matdata.size();
      matdata.assign(nmatcells, value);
    }
  }



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


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


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

  Entity_kind get_entity(const std::string var_name) const {

    Jali::State::const_iterator it = jali_state_.find(var_name);
    if (it != jali_state_.cend()) {
      std::shared_ptr<Jali::StateVectorBase> vector = *it;
      if (vector)
        return (Entity_kind) vector->entity_kind();
    }

    // At the moment we are using this as the API function to tell whether a
    // state vector is defined. In particular we use this to test for the
    // non existence of material centroids which is acceptable in VOF. We 
    // don't have a runtime check of MOF vs. VOF vs other, so I (DWS) have
    // disabled the warning here. If a MOF problem doesn't have material 
    // centroids I'm guessing a warning will appear somewhere else. 
    if (var_name != "mat_centroids")
      std::cerr << "Could not find state variable " << var_name << "\n";

    return UNKNOWN_KIND;
  }


  int get_data_size(Entity_kind on_what, std::string const& var_name) const {

    Jali::State::const_iterator it = jali_state_.find(var_name);
    if (it != jali_state_.cend()) {
      std::shared_ptr<Jali::StateVectorBase> vector = *it;
      if (vector && on_what == (Entity_kind) vector->entity_kind()) {
        if (vector->type() == Jali::StateVector_type::UNIVAL) {
          auto uvec = std::dynamic_pointer_cast<
              Jali::UniStateVectorBase<Jali::Mesh>>(vector);
          if (uvec && uvec->domain() == jali_state_.mesh())
            return uvec->size();
        } else if (vector->type() == Jali::StateVector_type::MULTIVAL) {
          auto mmvec = std::dynamic_pointer_cast<
              Jali::MultiStateVectorBase<Jali::Mesh>>(vector);
          if (mmvec && mmvec->domain() == jali_state_.mesh())
              return (vector->size());
        }
      }
    }

    std::cerr << "Could not find state variable " << var_name << "\n";
    return 0;
  }


  const std::type_info& get_data_type(std::string const& var_name) const {

    Jali::State::const_iterator it =
        jali_state_.find(var_name, jali_state_.mesh());
    if (it != jali_state_.cend()) {
      std::shared_ptr<Jali::StateVectorBase> vector = *it;
      if (vector)
        return vector->data_type();
    }

    std::cerr << "Could not find state variable " << var_name << "\n";
    return typeid(0);
  }

  std::vector<std::string>::iterator names_begin() const {
    return jali_state_.names_begin();
  }

  std::vector<std::string>::iterator names_end() const {
    return jali_state_.names_end();
  }

  std::vector<std::string> names() const {
    std::vector<std::string> result(jali_state_.names_begin(),
                                    jali_state_.names_end());
    return result;
  }


  typedef Jali::State::string_permutation string_permutation;

  string_permutation names_entity_begin(Entity_kind const on_what) const {
    return jali_state_.names_entity_begin((Jali::Entity_kind)on_what);
  }

  string_permutation names_entity_end(Entity_kind const on_what) const {
    return jali_state_.names_entity_end((Jali::Entity_kind)on_what);
  }

 private:
  Jali::State & jali_state_;
};  // Jali_State_Wrapper

}  // namespace Wonton

#endif  // WONTON_STATE_JALI_JALI_STATE_WRAPPER_H_