FaceCenteredGrid3.h

Go to the documentation of this file.

/*************************************************************************
> File Name: FaceCenteredGrid3.h
> Project Name: CubbyFlow
> Author: Chan-Ho Chris Ohk
> Purpose: 3-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_GRID3_H
#define CUBBYFLOW_FACE_CENTERED_GRID3_H

#include <Core/Array/Array3.h>
#include <Core/Array/ArraySamplers3.h>
#include <Core/Grid/VectorGrid3.h>

namespace CubbyFlow
{
    class FaceCenteredGrid3 final : public VectorGrid3
    {
    public:
        CUBBYFLOW_GRID3_TYPE_NAME(FaceCenteredGrid3)

        class Builder;

        using ScalarDataAccessor = ArrayAccessor3<double>;

        using ConstScalarDataAccessor = ConstArrayAccessor3<double>;

        FaceCenteredGrid3();

        FaceCenteredGrid3(
            size_t resolutionX, size_t resolutionY, size_t resolutionZ,
            double gridSpacingX = 1.0, double gridSpacingY = 1.0, double gridSpacingZ = 1.0,
            double originX = 0.0, double originY = 0.0, double originZ = 0.0,
            double initialValueU = 0.0, double initialValueV = 0.0, double initialValueW = 0.0);

        FaceCenteredGrid3(
            const Size3& resolution,
            const Vector3D& gridSpacing = Vector3D(1.0, 1.0, 1.0),
            const Vector3D& origin = Vector3D(),
            const Vector3D& initialValue = Vector3D());

        FaceCenteredGrid3(const FaceCenteredGrid3& other);

        void Swap(Grid3* other) override;

        void Set(const FaceCenteredGrid3& other);

        FaceCenteredGrid3& operator=(const FaceCenteredGrid3& other);

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

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

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

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

        double& GetW(size_t i, size_t j, size_t k);

        const double& GetW(size_t i, size_t j, size_t k) const;

        Vector3D ValueAtCellCenter(size_t i, size_t j, size_t k) const;

        double DivergenceAtCellCenter(size_t i, size_t j, size_t k) const;

        Vector3D CurlAtCellCenter(size_t i, size_t j, size_t k) const;

        ScalarDataAccessor GetUAccessor();

        ConstScalarDataAccessor GetUConstAccessor() const;

        ScalarDataAccessor GetVAccessor();

        ConstScalarDataAccessor GetVConstAccessor() const;

        ScalarDataAccessor GetWAccessor();

        ConstScalarDataAccessor GetWConstAccessor() const;

        DataPositionFunc GetUPosition() const;

        DataPositionFunc GetVPosition() const;

        DataPositionFunc GetWPosition() const;

        Size3 GetUSize() const;

        Size3 GetVSize() const;

        Size3 GetWSize() const;

        Vector3D GetUOrigin() const;

        Vector3D GetVOrigin() const;

        Vector3D GetWOrigin() const;

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

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

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

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

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

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

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

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

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

        // VectorField3 implementations
        Vector3D Sample(const Vector3D& x) const override;

        double Divergence(const Vector3D& x) const override;

        Vector3D Curl(const Vector3D& x) const override;

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

        static Builder GetBuilder();

    protected:
        // VectorGrid3 implementations
        void OnResize(
            const Size3& resolution,
            const Vector3D& gridSpacing,
            const Vector3D& origin,
            const Vector3D& initialValue) final;

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

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

    private:
        Array3<double> m_dataU;
        Array3<double> m_dataV;
        Array3<double> m_dataW;
        Vector3D m_dataOriginU;
        Vector3D m_dataOriginV;
        Vector3D m_dataOriginW;
        LinearArraySampler3<double, double> m_uLinearSampler;
        LinearArraySampler3<double, double> m_vLinearSampler;
        LinearArraySampler3<double, double> m_wLinearSampler;
        std::function<Vector3D(const Vector3D&)> m_sampler;

        void ResetSampler();
    };

    using FaceCenteredGrid3Ptr = std::shared_ptr<FaceCenteredGrid3>;

    class FaceCenteredGrid3::Builder final : public VectorGridBuilder3
    {
    public:
        Builder& WithResolution(const Size3& resolution);

        Builder& WithResolution(size_t resolutionX, size_t resolutionY, size_t resolutionZ);

        Builder& WithGridSpacing(const Vector3D& gridSpacing);

        Builder& WithGridSpacing(double gridSpacingX, double gridSpacingY, double gridSpacingZ);

        Builder& WithOrigin(const Vector3D& gridOrigin);

        Builder& WithOrigin(double gridOriginX, double gridOriginY, double gridOriginZ);

        Builder& WithInitialValue(const Vector3D& initialVal);

        Builder& WithInitialValue(double initialValX, double initialValY, double initialValZ);

        FaceCenteredGrid3 Build() const;

        FaceCenteredGrid3Ptr MakeShared() const;

        VectorGrid3Ptr Build(
            const Size3& resolution,
            const Vector3D& gridSpacing,
            const Vector3D& gridOrigin,
            const Vector3D& initialVal) const override;

    private:
        Size3 m_resolution{ 1, 1, 1 };
        Vector3D m_gridSpacing{ 1, 1, 1 };
        Vector3D m_gridOrigin{ 0, 0, 0 };
        Vector3D m_initialVal{ 0, 0, 0 };
    };
}

#endif