FaceCenteredGrid2.h

Go to the documentation of this file.

/*************************************************************************
> File Name: FaceCenteredGrid2.h
> Project Name: CubbyFlow
> Author: Chan-Ho Chris Ohk
> Purpose: 2-D face-centered (a.k.a MAC or staggered) grid.
> Created Time: 2017/08/03
> Copyright (c) 2018, Chan-Ho Chris Ohk
*************************************************************************/
#ifndef CUBBYFLOW_FACE_CENTERED_GRID2_H
#define CUBBYFLOW_FACE_CENTERED_GRID2_H

#include <Core/Array/Array2.h>
#include <Core/Array/ArraySamplers2.h>
#include <Core/Grid/VectorGrid2.h>

namespace CubbyFlow
{
    class FaceCenteredGrid2 final : public VectorGrid2
    {
    public:
        CUBBYFLOW_GRID2_TYPE_NAME(FaceCenteredGrid2)

        class Builder;

        using ScalarDataAccessor = ArrayAccessor2<double>;

        using ConstScalarDataAccessor = ConstArrayAccessor2<double>;

        FaceCenteredGrid2();

        FaceCenteredGrid2(
            size_t resolutionX, size_t resolutionY,
            double gridSpacingX = 1.0, double gridSpacingY = 1.0,
            double originX = 0.0, double originY = 0.0,
            double initialValueU = 0.0, double initialValueV = 0.0);

        FaceCenteredGrid2(
            const Size2& resolution,
            const Vector2D& gridSpacing = Vector2D(1.0, 1.0),
            const Vector2D& origin = Vector2D(),
            const Vector2D& initialValue = Vector2D());

        FaceCenteredGrid2(const FaceCenteredGrid2& other);

        void Swap(Grid2* other) override;

        void Set(const FaceCenteredGrid2& other);

        FaceCenteredGrid2& operator=(const FaceCenteredGrid2& other);

        double& GetU(size_t i, size_t j);

        const double& GetU(size_t i, size_t j) const;

        double& GetV(size_t i, size_t j);

        const double& GetV(size_t i, size_t j) const;

        Vector2D ValueAtCellCenter(size_t i, size_t j) const;

        double DivergenceAtCellCenter(size_t i, size_t j) const;

        double CurlAtCellCenter(size_t i, size_t j) const;

        ScalarDataAccessor GetUAccessor();

        ConstScalarDataAccessor GetUConstAccessor() const;

        ScalarDataAccessor GetVAccessor();

        ConstScalarDataAccessor GetVConstAccessor() const;

        DataPositionFunc GetUPosition() const;

        DataPositionFunc GetVPosition() const;

        Size2 GetUSize() const;

        Size2 GetVSize() const;

        Vector2D GetUOrigin() const;

        Vector2D GetVOrigin() const;

        void Fill(const Vector2D& value, ExecutionPolicy policy = ExecutionPolicy::Parallel) override;

        void Fill(const std::function<Vector2D(const Vector2D&)>& func, ExecutionPolicy policy = ExecutionPolicy::Parallel) override;

        std::shared_ptr<VectorGrid2> Clone() const override;

        void ForEachUIndex(const std::function<void(size_t, size_t)>& func) const;

        void ParallelForEachUIndex(const std::function<void(size_t, size_t)>& func) const;

        void ForEachVIndex(const std::function<void(size_t, size_t)>& func) const;

        void ParallelForEachVIndex(const std::function<void(size_t, size_t)>& func) const;

        // VectorField2 implementations
        Vector2D Sample(const Vector2D& x) const override;

        double Divergence(const Vector2D& x) const override;

        double Curl(const Vector2D& x) const override;

        std::function<Vector2D(const Vector2D&)> Sampler() const override;

        static Builder GetBuilder();

    protected:
        // VectorGrid2 implementations
        void OnResize(
            const Size2& resolution,
            const Vector2D& gridSpacing,
            const Vector2D& origin,
            const Vector2D& initialValue) final;

        void GetData(std::vector<double>* data) const override;

        void SetData(const std::vector<double>& data) override;

    private:
        Array2<double> m_dataU;
        Array2<double> m_dataV;
        Vector2D m_dataOriginU;
        Vector2D m_dataOriginV;
        LinearArraySampler2<double, double> m_uLinearSampler;
        LinearArraySampler2<double, double> m_vLinearSampler;
        std::function<Vector2D(const Vector2D&)> m_sampler;

        void ResetSampler();
    };

    using FaceCenteredGrid2Ptr = std::shared_ptr<FaceCenteredGrid2>;

    class FaceCenteredGrid2::Builder final : public VectorGridBuilder2
    {
    public:
        Builder& WithResolution(const Size2& resolution);

        Builder& WithResolution(size_t resolutionX, size_t resolutionY);

        Builder& WithGridSpacing(const Vector2D& gridSpacing);

        Builder& WithGridSpacing(double gridSpacingX, double gridSpacingY);

        Builder& WithOrigin(const Vector2D& gridOrigin);

        Builder& WithOrigin(double gridOriginX, double gridOriginY);

        Builder& WithInitialValue(const Vector2D& initialVal);

        Builder& WithInitialValue(double initialValX, double initialValY);

        FaceCenteredGrid2 Build() const;

        FaceCenteredGrid2Ptr MakeShared() const;

        VectorGrid2Ptr Build(
            const Size2& resolution,
            const Vector2D& gridSpacing,
            const Vector2D& gridOrigin,
            const Vector2D& initialVal) const override;

    private:
        Size2 m_resolution{ 1, 1 };
        Vector2D m_gridSpacing{ 1, 1 };
        Vector2D m_gridOrigin{ 0, 0 };
        Vector2D m_initialVal{ 0, 0 };
    };
}

#endif