grid3d.hpp

Go to the documentation of this file.

/// @file spatial/grid3d.hpp
/// @brief 3D Cartesian scalar grid backed by num::Vector storage.
///
/// Flat layout: idx = k*ny*nx + j*nx + i  (x is fastest, z is slowest)
/// Used by the field physics module for Poisson/diffusion solves.
#pragma once
 
#include "core/types.hpp"
#include "core/vector.hpp"
#include <vector>
 
namespace num {
 
class Grid3D {
public:
    /// @param nx,ny,nz  Number of cells in each dimension
    /// @param dx        Uniform cell size [m]
    Grid3D(int nx, int ny, int nz, double dx = 1.0);
 
    int    nx()   const { return nx_; }
    int    ny()   const { return ny_; }
    int    nz()   const { return nz_; }
    double dx()   const { return dx_; }
    int    size() const { return nx_ * ny_ * nz_; }
 
    real& operator()(int i, int j, int k)       { return data_[flat(i,j,k)]; }
    real  operator()(int i, int j, int k) const { return data_[flat(i,j,k)]; }
 
    void set(int i, int j, int k, real v) { data_[flat(i,j,k)] = v; }
    void fill(real v);
 
    /// Copy contents into a new Vector (for solver interop).
    Vector to_vector() const;
    /// Copy solver result back into grid.
    void   from_vector(const Vector& v);
 
private:
    int    nx_, ny_, nz_;
    double dx_;
    std::vector<real> data_;   // plain array for easy indexing
 
    idx flat(int i, int j, int k) const {
        return (idx)(k * ny_ * nx_ + j * nx_ + i);
    }
};
 
} // namespace num