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