FaceCenteredGrid.hpp

Go to the documentation of this file.

// This code is based on Jet framework.
// Copyright (c) 2018 Doyub Kim
// CubbyFlow is voxel-based fluid simulation engine for computer games.
// Copyright (c) 2020 CubbyFlow Team
// Core Part: Chris Ohk, Junwoo Hwang, Jihong Sin, Seungwoo Yoo
// AI Part: Dongheon Cho, Minseo Kim
// We are making my contributions/submissions to this project solely in our
// personal capacity and are not conveying any rights to any intellectual
// property of any third parties.
 
#ifndef CUBBYFLOW_FACE_CENTERED_GRID_HPP
#define CUBBYFLOW_FACE_CENTERED_GRID_HPP
 
#include <Core/Array/Array.hpp>
#include <Core/Array/ArraySamplers.hpp>
#include <Core/Grid/VectorGrid.hpp>
 
#include <array>
 
namespace CubbyFlow
{
template <size_t N>
class FaceCenteredGrid final : public VectorGrid<N>
{
 public:
    CUBBYFLOW_GRID_TYPE_NAME(FaceCenteredGrid, N)
 
    class Builder;
 
    using VectorGrid<N>::Resize;
    using VectorGrid<N>::Resolution;
    using VectorGrid<N>::GridSpacing;
 
    using ScalarDataView = ArrayView<double, N>;
 
    using ConstScalarDataView = ArrayView<const double, N>;
 
    FaceCenteredGrid();
 
    FaceCenteredGrid(
        const Vector<size_t, N>& resolution,
        const Vector<double, N>& gridSpacing =
            Vector<double, N>::MakeConstant(1.0),
        const Vector<double, N>& origin = Vector<double, N>{},
        const Vector<double, N>& initialValue = Vector<double, N>{});
 
    ~FaceCenteredGrid() override = default;
 
    FaceCenteredGrid(const FaceCenteredGrid& other);
 
    FaceCenteredGrid(FaceCenteredGrid&& other) noexcept;
 
    FaceCenteredGrid& operator=(const FaceCenteredGrid& other);
 
    FaceCenteredGrid& operator=(FaceCenteredGrid&& other) noexcept;
 
    void Swap(Grid<N>* other) override;
 
    void Set(const FaceCenteredGrid& other);
 
    [[nodiscard]] double& U(const Vector<size_t, N>& idx);
 
    template <typename... Indices>
    [[nodiscard]] double& U(size_t i, Indices... indices)
    {
        return U(Vector<size_t, N>(i, indices...));
    }
 
    [[nodiscard]] const double& U(const Vector<size_t, N>& idx) const;
 
    template <typename... Indices>
    [[nodiscard]] const double& U(size_t i, Indices... indices) const
    {
        return U(Vector<size_t, N>(i, indices...));
    }
 
    [[nodiscard]] double& V(const Vector<size_t, N>& idx);
 
    template <typename... Indices>
    [[nodiscard]] double& V(size_t i, Indices... indices)
    {
        return V(Vector<size_t, N>(i, indices...));
    }
 
    [[nodiscard]] const double& V(const Vector<size_t, N>& idx) const;
 
    template <typename... Indices>
    [[nodiscard]] const double& V(size_t i, Indices... indices) const
    {
        return V(Vector<size_t, N>(i, indices...));
    }
 
    template <size_t M = N>
    [[nodiscard]] std::enable_if_t<M == 3, double&> W(
        const Vector<size_t, N>& idx)
    {
        return m_data[2](idx);
    }
 
    template <size_t M = N, typename... Indices>
    [[nodiscard]] std::enable_if_t<M == 3, double&> W(size_t i,
                                                      Indices... indices)
    {
        return W(Vector<size_t, N>(i, indices...));
    }
 
    template <size_t M = N>
    std::enable_if_t<M == 3, const double&> W(
        const Vector<size_t, N>& idx) const
    {
        return m_data[2](idx);
    }
 
    template <size_t M = N, typename... Indices>
    [[nodiscard]] std::enable_if_t<M == 3, const double&> W(
        size_t i, Indices... indices) const
    {
        return W(Vector<size_t, N>(i, indices...));
    }
 
    [[nodiscard]] Vector<double, N> ValueAtCellCenter(
        const Vector<size_t, N>& idx) const;
 
    template <typename... Indices>
    [[nodiscard]] Vector<double, N> ValueAtCellCenter(size_t i,
                                                      Indices... indices) const
    {
        return ValueAtCellCenter(Vector<size_t, N>(i, indices...));
    }
 
    [[nodiscard]] double DivergenceAtCellCenter(
        const Vector<size_t, N>& idx) const;
 
    template <typename... Indices>
    [[nodiscard]] double DivergenceAtCellCenter(size_t i,
                                                Indices... indices) const
    {
        return DivergenceAtCellCenter(Vector<size_t, N>(i, indices...));
    }
 
    [[nodiscard]] typename GetCurl<N>::Type CurlAtCellCenter(
        const Vector<size_t, N>& idx) const;
 
    template <typename... Indices>
    [[nodiscard]] typename GetCurl<N>::Type CurlAtCellCenter(
        size_t i, Indices... indices) const
    {
        return CurlAtCellCenter(Vector<size_t, N>(i, indices...));
    }
 
    [[nodiscard]] ScalarDataView UView();
 
    [[nodiscard]] ConstScalarDataView UView() const;
 
    [[nodiscard]] ScalarDataView VView();
 
    [[nodiscard]] ConstScalarDataView VView() const;
 
    template <size_t M = N>
    [[nodiscard]] std::enable_if_t<M == 3, ScalarDataView> WView()
    {
        return DataView(2);
    }
 
    template <size_t M = N>
    [[nodiscard]] std::enable_if_t<M == 3, ConstScalarDataView> WView() const
    {
        return DataView(2);
    }
 
    [[nodiscard]] ScalarDataView DataView(size_t i);
 
    [[nodiscard]] ConstScalarDataView DataView(size_t i) const;
 
    [[nodiscard]] GridDataPositionFunc<N> UPosition() const;
 
    [[nodiscard]] GridDataPositionFunc<N> VPosition() const;
 
    template <size_t M = N>
    [[nodiscard]] std::enable_if_t<M == 3, GridDataPositionFunc<N>> WPosition()
        const
    {
        return DataPosition(2);
    }
 
    [[nodiscard]] GridDataPositionFunc<N> DataPosition(size_t i) const;
 
    [[nodiscard]] Vector<size_t, N> USize() const;
 
    [[nodiscard]] Vector<size_t, N> VSize() const;
 
    template <size_t M = N>
    [[nodiscard]] std::enable_if_t<M == 3, Vector<size_t, N>> WSize() const
    {
        return DataSize(2);
    }
 
    [[nodiscard]] Vector<size_t, N> DataSize(size_t i) const;
 
    [[nodiscard]] Vector<double, N> UOrigin() const;
 
    [[nodiscard]] Vector<double, N> VOrigin() const;
 
    template <size_t M = N>
    [[nodiscard]] std::enable_if_t<M == 3, Vector<double, N>> WOrigin() const
    {
        return DataOrigin(2);
    }
 
    [[nodiscard]] Vector<double, N> DataOrigin(size_t i) const;
 
    void Fill(const Vector<double, N>& value,
              ExecutionPolicy policy = ExecutionPolicy::Parallel) override;
 
    void Fill(
        const std::function<Vector<double, N>(const Vector<double, N>&)>& func,
        ExecutionPolicy policy = ExecutionPolicy::Parallel) override;
 
    [[nodiscard]] std::shared_ptr<VectorGrid<N>> Clone() const override;
 
    void ForEachUIndex(
        const std::function<void(const Vector<size_t, N>&)>& func) const;
 
    void ParallelForEachUIndex(
        const std::function<void(const Vector<size_t, N>&)>& func) const;
 
    void ForEachVIndex(
        const std::function<void(const Vector<size_t, N>&)>& func) const;
 
    void ParallelForEachVIndex(
        const std::function<void(const Vector<size_t, N>&)>& func) const;
 
    template <size_t M = N>
    std::enable_if_t<M == 3, void> ForEachWIndex(
        const std::function<void(const Vector<size_t, N>&)>& func) const
    {
        ForEachIndex(DataSize(2), GetUnroll<void, N>::Unroll(func));
    }
 
    template <size_t M = N>
    std::enable_if_t<M == 3, void> ParallelForEachWIndex(
        const std::function<void(const Vector<size_t, N>&)>& func) const
    {
        ParallelForEachIndex(DataSize(2), GetUnroll<void, N>::Unroll(func));
    }
 
    [[nodiscard]] Vector<double, N> Sample(
        const Vector<double, N>& x) const override;
 
    [[nodiscard]] double Divergence(const Vector<double, N>& x) const override;
 
    [[nodiscard]] typename GetCurl<N>::Type Curl(
        const Vector<double, N>& x) const override;
 
    [[nodiscard]] std::function<Vector<double, N>(const Vector<double, N>&)>
    Sampler() const override;
 
    static Builder GetBuilder();
 
 protected:
    using VectorGrid<N>::SwapGrid;
    using VectorGrid<N>::SetGrid;
 
    void OnResize(const Vector<size_t, N>& resolution,
                  const Vector<double, N>& gridSpacing,
                  const Vector<double, N>& origin,
                  const Vector<double, N>& initialValue) final;
 
    void GetData(Array1<double>& data) const override;
 
    void SetData(const ConstArrayView1<double>& data) override;
 
 private:
    std::array<Array<double, N>, N> m_data;
    std::array<Vector<double, N>, N> m_dataOrigins;
    std::array<LinearArraySampler<double, N>, N> m_linearSamplers;
    std::function<Vector<double, N>(const Vector<double, N>&)> m_sampler;
 
    void ResetSampler();
};
 
using FaceCenteredGrid2 = FaceCenteredGrid<2>;
 
using FaceCenteredGrid3 = FaceCenteredGrid<3>;
 
using FaceCenteredGrid2Ptr = std::shared_ptr<FaceCenteredGrid2>;
 
using FaceCenteredGrid3Ptr = std::shared_ptr<FaceCenteredGrid3>;
 
template <size_t N>
class FaceCenteredGrid<N>::Builder final : public VectorGridBuilder<N>
{
 public:
    Builder& WithResolution(const Vector<size_t, N>& resolution);
 
    Builder& WithGridSpacing(const Vector<double, N>& gridSpacing);
 
    Builder& WithOrigin(const Vector<double, N>& gridOrigin);
 
    Builder& WithInitialValue(const Vector<double, N>& initialVal);
 
    FaceCenteredGrid Build() const;
 
    std::shared_ptr<FaceCenteredGrid> MakeShared() const;
 
    std::shared_ptr<VectorGrid<N>> Build(
        const Vector<size_t, N>& resolution,
        const Vector<double, N>& gridSpacing,
        const Vector<double, N>& gridOrigin,
        const Vector<double, N>& initialVal) const override;
 
 private:
    Vector<size_t, N> m_resolution = Vector<size_t, N>::MakeConstant(1);
    Vector<double, N> m_gridSpacing = Vector<double, N>::MakeConstant(1.0);
    Vector<double, N> m_gridOrigin;
    Vector<double, N> m_initialVal;
};
}  // namespace CubbyFlow
 
#endif