flecsi_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
*/

#pragma once

// system includes
#include <utility>
#include <cstring>
#include <string>
#include <vector>
#include <typeinfo>

#include "wonton/support/wonton.h"

namespace Wonton {

template< typename M >
class flecsi_state_t {
  //============================================================================
  // Typedefs
  //============================================================================

  using mesh_t = M;
  using size_t = typename mesh_t::size_t;
  using real_t = typename mesh_t::real_t;


  using entity_kind_t = Entity_kind;
  using entity_type_t = Entity_type;

 public:
  //============================================================================
  // Constructors
  //============================================================================

  explicit flecsi_state_t(mesh_t & mesh) : mesh_(&mesh)
  {}

  flecsi_state_t() = default;

  flecsi_state_t(const flecsi_state_t &) = default;

  flecsi_state_t & operator=(const flecsi_state_t &) = default;

  //============================================================================
  // Public Members
  //============================================================================



  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;  // MULTI-MATERIAL FIELDS NOT ACCESSED YET
  }


  entity_kind_t get_entity(std::string const& var_name) const {
    auto cell_field_list = flecsi_get_accessors_all(
        *mesh_, real_t, dense, 0, flecsi_is_at(cells));

    for (auto var : cell_field_list)
      if (var.label() == var_name)
        return entity_kind_t::CELL;

    auto nodal_field_list = flecsi_get_accessors_all(
        *mesh_, real_t, dense, 0, flecsi_is_at(vertices));
    for (auto var : nodal_field_list)
      if (var.label() == var_name)
        return entity_kind_t::NODE;

    return entity_kind_t::UNKNOWN_KIND;
  }


  template <class T>
  void mesh_get_data(entity_kind_t on_what, std::string const& var_name,
                     T ** data) const {
    // Ignore on_what here - the state manager knows where it lives
    // based on its name

    // first check cells
    auto cell_field_list = flecsi_get_accessors_all(
        *mesh_, real_t, dense, 0, flecsi_is_at(cells));
    for (auto var : cell_field_list)
      if (var.label() == var_name) {
        *data = &var[0];
        return;
      }

    // now check nodes
    auto nodal_field_list = flecsi_get_accessors_all(
        *mesh_, real_t, dense, 0, flecsi_is_at(vertices));
    for (auto var : nodal_field_list)
      if (var.label() == var_name)  {
        *data = &var[0];
        return;
      }

    // if we got here, there is something wrong
    raise_runtime_error("Could not find variable to ReMAP!");
  }


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

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


  void mesh_add_data(Entity_kind on_what, std::string const& name,
                  double const **data) const {
  }



  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,
                        Point<2> const *values) {
  }

  void mat_add_celldata(std::string const& var_name, int matid,
                        Point<3> 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) {
  }


  int get_data_size(entity_kind_t on_what, std::string const& var_name) const {
    raise_runtime_error("get_data_size not implemented yet!");
  }




  const std::type_info& get_data_type(std::string const& var_name) const {
    return typeid(double);  // thats the only type we can represent
  }

  std::vector<std::string> names() const {
    return std::vector<std::string>{};
  }


#if 0

  template <class T>
  void mesh_get_data(entity_kind_t on_what,
                     std::string const& var_name, T** data) {
    // Ignore on_what here - the state manager knows where it lives
    // based on its name
    // NOTE: access_state needs a const_string_t, which is a flecsi
    // datatype that apparently can't convert from a std::string...
    // I added to the case where it can create from a char*
    const const_string_t flecsiname(var_name.c_str());
    auto dat = access_state(flecsi_mesh_,
                            std::forward<const const_string_t>(flecsiname),
                            real_t);
    // note this might be fragile in the case of non-dense storage
    *data = &dat[0];
  }

  int get_data_size(entity_kind_t on_what, std::string const& var_name) const {
    const const_string_t flecsiname(var_name.c_str());
    auto dat = access_state(flecsi_mesh_,
                            std::forward<const const_string_t>(flecsiname),
                            real_t);
    return (dat.size());
  }

#endif

 private:
  mesh_t * mesh_ = nullptr;
};  // Flecsi_State_Wrapper

}  // namespace Wonton