world_queries.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2025 VTT Technical Research Centre of Finland Ltd
// SPDX-License-Identifier: AGPL-3.0-or-later
 
#pragma once
 
#include "csys.hpp"
#include "types.hpp"
#include "world.hpp"
#include <vector>
 
namespace pfc {
namespace world {
 
using pfc::csys::CoordinateSystem;
using pfc::types::Int3;
using pfc::types::Real3;
 
// ============================================================================
// Core Property Queries
// ============================================================================
 
template <typename T> inline Int3 get_size(const World<T> &world) noexcept {
  return world.m_size;
}
 
template <typename T> inline int get_size(const World<T> &world, int index) {
  return get_size(world).at(index);
}
 
template <typename T> inline size_t get_total_size(const World<T> &world) noexcept {
  return get_size(world, 0) * get_size(world, 1) * get_size(world, 2);
}
 
inline const auto &get_lower(const CartesianWorld &world) noexcept {
  return world.m_lower;
}
 
inline const auto &get_lower(const CartesianWorld &world, int index) {
  return get_lower(world).at(index);
}
 
inline const auto &get_upper(const CartesianWorld &world) noexcept {
  return world.m_upper;
}
 
inline auto get_upper(const CartesianWorld &world, int index) {
  return get_upper(world).at(index);
}
 
// ============================================================================
// Coordinate System Queries
// ============================================================================
 
template <typename T>
inline const auto &get_coordinate_system(const World<T> &world) noexcept {
  return world.m_cs;
}
 
inline const Real3 &get_spacing(const CartesianWorld &world) noexcept {
  return get_spacing(get_coordinate_system(world));
}
 
inline double get_spacing(const CartesianWorld &world, int index) noexcept {
  return get_spacing(get_coordinate_system(world), index);
}
 
inline const Real3 &get_origin(const CartesianWorld &world) noexcept {
  return get_offset(get_coordinate_system(world));
}
 
inline double get_origin(const CartesianWorld &world, int index) noexcept {
  return get_offset(get_coordinate_system(world), index);
}
 
// ============================================================================
// Coordinate Transformations
// ============================================================================
 
template <typename T>
inline auto to_coords(const World<T> &world, const Int3 &indices) noexcept {
  return to_coords(get_coordinate_system(world), indices);
}
 
template <typename T>
inline auto to_indices(const World<T> &world, const Real3 &coords) noexcept {
  return to_index(get_coordinate_system(world), coords);
}
 
// ============================================================================
// Physical Domain Queries
// ============================================================================
 
template <typename T> inline double physical_volume(const World<T> &world) noexcept {
  const auto spacing = get_spacing(world);
  const auto size = get_size(world);
  return spacing[0] * spacing[1] * spacing[2] * size[0] * size[1] * size[2];
}
 
template <typename T> inline bool is_1d(const World<T> &world) noexcept {
  const auto size = get_size(world);
  return (size[0] > 1) && (size[1] == 1) && (size[2] == 1);
}
 
template <typename T> inline bool is_2d(const World<T> &world) noexcept {
  const auto size = get_size(world);
  return (size[0] > 1) && (size[1] > 1) && (size[2] == 1);
}
 
template <typename T> inline bool is_3d(const World<T> &world) noexcept {
  const auto size = get_size(world);
  return (size[0] > 1) && (size[1] > 1) && (size[2] > 1);
}
 
template <typename T> inline int dimensionality(const World<T> &world) noexcept {
  if (is_3d(world)) return 3;
  if (is_2d(world)) return 2;
  if (is_1d(world)) return 1;
  return 0; // Degenerate case (all dimensions size 1)
}
 
template <typename T> inline Real3 get_lower_bounds(const World<T> &world) noexcept {
  return to_coords(world, {0, 0, 0});
}
 
template <typename T> inline Real3 get_upper_bounds(const World<T> &world) noexcept {
  const auto size = get_size(world);
  return to_coords(world, {size[0] - 1, size[1] - 1, size[2] - 1});
}
 
} // namespace world
} // namespace pfc
 
namespace pfc {
namespace world {
 
template <typename T>
inline std::array<std::vector<double>, 3>
coordinates(const World<T> &world) noexcept {
  std::array<std::vector<double>, 3> result;
  const auto size = get_size(world);
  const auto origin = get_origin(world);
  const auto spacing = get_spacing(world);
  for (int d = 0; d < 3; ++d) {
    result[d].resize(size[d]);
    for (int i = 0; i < size[d]; ++i) {
      result[d][i] = origin[d] + i * spacing[d];
    }
  }
  return result;
}
 
} // namespace world
} // namespace pfc