field_info.h

Go to the documentation of this file.

 
#pragma once
 
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
#include "../utils/FrozenKeyIdxBiMap.h"
 
namespace field
{
 
// note: HYDRO includes GasEnergy (if present)
enum class Kind { HYDRO, PASSIVE_SCALAR, MAGNETIC };
 
enum class IOBuf { HOST, DEVICE };
 
class IdRange
{
  const std::vector<int>& id_vec_;
 
 public:
  explicit IdRange(const std::vector<int>& id_vec) : id_vec_(id_vec) {}
 
  // the fact that the iterator aliases a const iterator of a std::vector is an
  // implementation detail
  using iterator = std::vector<int>::const_iterator;
 
  iterator begin() const { return id_vec_.begin(); }
  iterator end() const { return id_vec_.end(); }
};
 
}  // namespace field
 
class FieldInfo
{
  utils::FrozenKeyIdxBiMap name_id_bimap_;
  std::vector<int> hydro_field_ids_;
  std::vector<int> scalar_field_ids_;
  std::vector<int> magnetic_field_ids_;
  std::vector<field::IOBuf> io_buf_;
 
  // We make the default-constructor private to force the use of the factory method
  FieldInfo() = default;
 
  const std::vector<int>& get_kind_ids_(field::Kind kind) const;
 
 public:
  static FieldInfo create();
 
  FieldInfo(FieldInfo&&)            = default;
  FieldInfo& operator=(FieldInfo&&) = default;
 
  // we delete copy constructor and copy-assignment to prevent accidental copies
  // (of course move constructors/move assignment remain possible)
  // In the unlikely event we decide to support copies, this can always change later...
  FieldInfo(const FieldInfo&)            = delete;
  FieldInfo& operator=(const FieldInfo&) = delete;
 
  const utils::FrozenKeyIdxBiMap& get_field_id_map() const { return name_id_bimap_; }
 
  std::optional<int> field_id(const char* field_name) const { return name_id_bimap_.find(field_name); }
  std::optional<int> field_id(std::string_view field_name) const { return name_id_bimap_.find(field_name); }
 
  std::optional<std::string> field_name(int field_id) const
  {
    bool bad_id = (field_id < 0 || field_id >= n_fields());
    return bad_id ? std::nullopt : std::optional<std::string>{name_id_bimap_.inverse_find(field_id)};
  }
 
  std::optional<bool> is_cell_centered(int field_id) const
  {
    if (field_id < 0 || field_id >= n_fields()) {
      return std::nullopt;
    }
    for (int id : magnetic_field_ids_) {
      if (field_id == id) {
        return std::optional<bool>{false};
      }
    }
    return std::optional<bool>{true};
  }
 
  std::optional<field::IOBuf> io_buf(int field_id) const
  {
    bool bad_id = (field_id < 0 || field_id >= n_fields());
    return bad_id ? std::nullopt : std::optional<field::IOBuf>{io_buf_[field_id]};
  }
 
  int n_fields() const { return static_cast<int>(name_id_bimap_.size()); }
 
  int n_fields(field::Kind kind) const { return static_cast<int>(get_kind_ids_(kind).size()); }
 
  std::optional<int> scalar_start() const
  {
    return scalar_field_ids_.empty() ? std::nullopt : std::optional<int>{scalar_field_ids_[0]};
  }
 
  field::IdRange get_id_range(field::Kind kind) const { return field::IdRange(get_kind_ids_(kind)); }
};