AMReX_CoordSys.H

Go to the documentation of this file.

 
#ifndef AMREX_COORDSYS_H_
#define AMREX_COORDSYS_H_
#include <AMReX_Config.H>
 
#include <AMReX.H>
#include <AMReX_REAL.H>
#include <AMReX_Array.H>
#include <AMReX_Vector.H>
#include <AMReX_Box.H>
 
#include <limits>
 
namespace amrex {
 
class FArrayBox;
 
class CoordSys
{
public:
 
    enum CoordType { undef = -1, cartesian = 0, RZ = 1, SPHERICAL = 2 };
    friend std::ostream& operator<< (std::ostream&, const CoordSys& );
 
    friend std::istream& operator>> (std::istream&, CoordSys& );
 
    [[nodiscard]] bool Ok () const noexcept { return ok; }
 
    void SetCoord (CoordType coord) noexcept { c_sys = coord; }
 
    [[nodiscard]] CoordType Coord () const noexcept { return c_sys; }
 
    [[nodiscard]] int CoordInt () const  noexcept { return static_cast<int>(c_sys); }
 
    [[nodiscard]] bool IsSPHERICAL () const noexcept {
        BL_ASSERT(c_sys != undef); return (c_sys == SPHERICAL);
    }
 
    [[nodiscard]] bool IsRZ () const noexcept {
        BL_ASSERT(c_sys != undef); return (c_sys == RZ);
    }
 
    [[nodiscard]] bool IsCartesian () const noexcept {
        BL_ASSERT(c_sys != undef); return (c_sys == cartesian);
    }
 
    void SetOffset (const Real* x_lo) noexcept;
 
    [[nodiscard]] const Real* Offset () const noexcept { return offset; }
 
    [[nodiscard]] Real Offset (int dir) const noexcept { return offset[dir]; }
 
    [[nodiscard]] const Real* CellSize () const noexcept { BL_ASSERT(ok); return dx; }
 
    [[nodiscard]] Real CellSize (int dir) const noexcept { BL_ASSERT(ok); return dx[dir]; }
 
    [[nodiscard]] GpuArray<Real,AMREX_SPACEDIM> CellSizeArray () const noexcept {
        BL_ASSERT(ok);
        return {{ AMREX_D_DECL(dx[0],dx[1],dx[2]) }};
    }
 
    [[nodiscard]] const Real* InvCellSize () const noexcept { BL_ASSERT(ok); return inv_dx; }
 
    [[nodiscard]] Real InvCellSize (int dir) const noexcept { BL_ASSERT(ok); return inv_dx[dir]; }
 
    [[nodiscard]] GpuArray<Real,AMREX_SPACEDIM> InvCellSizeArray () const noexcept {
        BL_ASSERT(ok);
        return {{ AMREX_D_DECL(inv_dx[0],inv_dx[1],inv_dx[2]) }};
    }
 
    [[nodiscard]] Real CellCenter (int point, int dir) const noexcept
    {
        BL_ASSERT(ok); return offset[dir] + dx[dir]*((Real)0.5+ (Real)point);
    }
 
    void CellCenter (const IntVect& point, Vector<Real>& loc) const noexcept;
 
    void CellCenter (const IntVect& point, Real* loc) const noexcept;
 
    [[nodiscard]] Real LoEdge (int point, int dir) const noexcept
    {
        BL_ASSERT(ok); return offset[dir] + dx[dir]*static_cast<Real>(point);
    }
 
    [[nodiscard]] Real LoEdge (const IntVect& point, int dir) const noexcept
    {
        BL_ASSERT(ok); return offset[dir] + dx[dir]*static_cast<Real>(point[dir]);
    }
 
    [[nodiscard]] Real HiEdge (int point, int dir) const noexcept
    {
        BL_ASSERT(ok); return offset[dir] + dx[dir]*static_cast<Real>(point + 1);
    }
 
    [[nodiscard]] Real HiEdge (const IntVect& point, int dir) const noexcept
    {
        BL_ASSERT(ok); return offset[dir] + dx[dir]*static_cast<Real>(point[dir] + 1);
    }
 
    void LoFace (const IntVect& point, int dir, Vector<Real>& loc) const noexcept;
 
    void LoFace (const IntVect& point, int dir, Real* loc) const noexcept;
 
    void HiFace (const IntVect& point, int dir, Vector<Real>& loc) const noexcept;
 
    void HiFace (const IntVect& point, int dir, Real* loc) const noexcept;
 
    void LoNode (const IntVect& point, Vector<Real>& loc) const noexcept;
 
    void LoNode (const IntVect& point, Real* loc) const noexcept;
 
    void HiNode (const IntVect& point, Vector<Real>& loc) const noexcept;
 
    void HiNode (const IntVect& point, Real* loc) const noexcept;
    IntVect CellIndex (const Real* point) const noexcept;
    IntVect LowerIndex (const Real* point) const noexcept;
    IntVect UpperIndex (const Real* point) const noexcept;
    void SetVolume (FArrayBox& a_volfab, const Box& region) const;
    void GetVolume (FArrayBox& vol, const Box& region) const;
    void SetDLogA (FArrayBox& a_dlogafab, const Box& region, int dir) const;
    void GetDLogA (FArrayBox& dloga, const Box& region, int dir) const;
 
    [[nodiscard]] Real Volume (const IntVect& point) const;
 
    [[nodiscard]] Real Volume (const Real xlo[AMREX_SPACEDIM],
                               const Real xhi[AMREX_SPACEDIM]) const;
 
    void SetFaceArea (FArrayBox& a_areafab, const Box& region, int dir) const;
 
    void GetFaceArea (FArrayBox& area, const Box& region, int dir) const;
 
    [[nodiscard]] Real AreaLo (const IntVect& point, int dir) const noexcept;
 
    [[nodiscard]] Real AreaHi (const IntVect& point, int dir) const noexcept;
 
    void GetEdgeLoc (Vector<Real>& loc, const Box& region, int dir) const;
 
    void GetCellLoc (Vector<Real>& loc, const Box& region, int dir) const;
 
    void GetEdgeVolCoord (Vector<Real>& vc, const Box& region, int dir) const;
 
    void GetCellVolCoord (Vector<Real>& vc, const Box& region, int dir) const;
 
protected:
    // c_sys and offset used to be static
    CoordType c_sys = undef;
    Real      offset[AMREX_SPACEDIM];
 
    Real dx[AMREX_SPACEDIM] = {AMREX_D_DECL(0.,0.,0.)};
    Real inv_dx[AMREX_SPACEDIM]
        = {AMREX_D_DECL(std::numeric_limits<Real>::infinity(),
                        std::numeric_limits<Real>::infinity(),
                        std::numeric_limits<Real>::infinity())};
    bool ok = false;
};
 
}
 
#endif /*_COORDSYS_H_*/