world_helpers.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 "strong_types.hpp"
#include "types.hpp"
#include "world.hpp"
#include "world_factory.hpp"
#include <stdexcept>
#include <string>
 
namespace pfc {
namespace world {
 
using pfc::types::Bool3;
using pfc::types::Int3;
using pfc::types::Real3;
 
inline CartesianWorld uniform(int size) {
  if (size <= 0) {
    throw std::invalid_argument("Grid size must be positive, got: " +
                                std::to_string(size));
  }
  return create(GridSize({size, size, size}), PhysicalOrigin({0.0, 0.0, 0.0}),
                GridSpacing({1.0, 1.0, 1.0}));
}
 
inline CartesianWorld uniform(int size, double spacing) {
  if (size <= 0) {
    throw std::invalid_argument("Grid size must be positive, got: " +
                                std::to_string(size));
  }
  if (spacing <= 0.0) {
    throw std::invalid_argument("Spacing must be positive, got: " +
                                std::to_string(spacing));
  }
  return create(GridSize({size, size, size}), PhysicalOrigin({0.0, 0.0, 0.0}),
                GridSpacing({spacing, spacing, spacing}));
}
 
inline CartesianWorld from_bounds(Int3 size, Real3 lower, Real3 upper,
                                  Bool3 periodic = {true, true, true}) {
  // Validate inputs
  for (int i = 0; i < 3; ++i) {
    if (size[i] <= 0) {
      throw std::invalid_argument("Grid size must be positive in all dimensions");
    }
    if (upper[i] <= lower[i]) {
      throw std::invalid_argument("Upper bound must be greater than lower bound");
    }
  }
 
  // Compute spacing based on periodicity
  Real3 spacing;
  for (int i = 0; i < 3; ++i) {
    if (periodic[i]) {
      spacing[i] = (upper[i] - lower[i]) / size[i];
    } else {
      spacing[i] = (upper[i] - lower[i]) / (size[i] - 1);
    }
  }
 
  return create(GridSize(size), PhysicalOrigin(lower), GridSpacing(spacing));
}
 
inline CartesianWorld with_spacing(Int3 size, Real3 spacing) {
  // Validate
  for (int i = 0; i < 3; ++i) {
    if (size[i] <= 0) {
      throw std::invalid_argument("Grid size must be positive");
    }
    if (spacing[i] <= 0.0) {
      throw std::invalid_argument("Spacing must be positive");
    }
  }
 
  return create(GridSize(size), PhysicalOrigin({0.0, 0.0, 0.0}),
                GridSpacing(spacing));
}
 
inline CartesianWorld with_origin(Int3 size, Real3 origin) {
  // Validate
  for (int i = 0; i < 3; ++i) {
    if (size[i] <= 0) {
      throw std::invalid_argument("Grid size must be positive");
    }
  }
 
  return create(GridSize(size), PhysicalOrigin(origin),
                GridSpacing({1.0, 1.0, 1.0}));
}
 
} // namespace world
} // namespace pfc