face_centered_grid2.h

Go to the documentation of this file.

// Copyright (c) 2018 Doyub Kim
//
// I am making my contributions/submissions to this project solely in my
// personal capacity and am not conveying any rights to any intellectual
// property of any third parties.
 
#ifndef INCLUDE_JET_FACE_CENTERED_GRID2_H_
#define INCLUDE_JET_FACE_CENTERED_GRID2_H_
 
#include <jet/array2.h>
#include <jet/array_samplers2.h>
#include <jet/vector_grid2.h>
#include <memory>
#include <utility>  // just make cpplint happy..
#include <vector>
 
namespace jet {
 
class FaceCenteredGrid2 final : public VectorGrid2 {
 public:
    JET_GRID2_TYPE_NAME(FaceCenteredGrid2)
 
    class Builder;
 
    typedef ArrayAccessor2<double> ScalarDataAccessor;
 
    typedef ConstArrayAccessor2<double> ConstScalarDataAccessor;
 
    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& u(size_t i, size_t j);
 
    const double& u(size_t i, size_t j) const;
 
    double& v(size_t i, size_t j);
 
    const double& v(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 uAccessor();
 
    ConstScalarDataAccessor uConstAccessor() const;
 
    ScalarDataAccessor vAccessor();
 
    ConstScalarDataAccessor vConstAccessor() const;
 
    DataPositionFunc uPosition() const;
 
    DataPositionFunc vPosition() const;
 
    Size2 uSize() const;
 
    Size2 vSize() const;
 
    Vector2D uOrigin() const;
 
    Vector2D vOrigin() const;
 
    void fill(const Vector2D& value,
              ExecutionPolicy policy = ExecutionPolicy::kParallel) override;
 
    void fill(const std::function<Vector2D(const Vector2D&)>& func,
              ExecutionPolicy policy = ExecutionPolicy::kParallel) 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 builder();
 
 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> _dataU;
    Array2<double> _dataV;
    Vector2D _dataOriginU;
    Vector2D _dataOriginV;
    LinearArraySampler2<double, double> _uLinearSampler;
    LinearArraySampler2<double, double> _vLinearSampler;
    std::function<Vector2D(const Vector2D&)> _sampler;
 
    void resetSampler();
};
 
typedef std::shared_ptr<FaceCenteredGrid2> FaceCenteredGrid2Ptr;
 
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 _resolution{1, 1};
    Vector2D _gridSpacing{1, 1};
    Vector2D _gridOrigin{0, 0};
    Vector2D _initialVal{0, 0};
};
 
}  // namespace jet
 
#endif  // INCLUDE_JET_FACE_CENTERED_GRID2_H_