dbpp_CellFace.h

Go to the documentation of this file.

#pragma once
 
#include <iostream>
 
namespace dbpp 
{
    class cellFace
    {
    public:
        enum class eFaceSide { left, right, global };
        constexpr   cellFace( eFaceSide aFaceSid = eFaceSide::left, 
            signed short aGblFaceIdx = -1,        // global index (global discretization) 
            signed short aLeftNodeIdx = -1,       // local node idx: -1(out of range),0(left),1(right)
            signed short aRightNodeIdx = 0,       // grid node index left/right on both side
            signed short aCellIdx = 0)              // cell index
        : m_faceSide{ aFaceSid },
            m_gblFaceI{ aGblFaceIdx },
            m_leftNodeI{aLeftNodeIdx},
            m_rightNodeI{ aRightNodeIdx },
            m_cellIdx{ aCellIdx }
        {}

        constexpr short        getLeftNodeI()  const noexcept { return m_leftNodeI; }
        constexpr signed short getRightNodeI() const noexcept { return m_rightNodeI; }
        constexpr signed short getGblFaceI()   const noexcept { return m_gblFaceI; }
        constexpr signed short getCellIdx()    const noexcept { return m_cellIdx; }
        constexpr bool hasLeftNeighbour()  const noexcept { return m_leftNodeI != -1; }
        constexpr bool hasRightNeighbour() const noexcept { return m_rightNodeI != -1; }
        constexpr eFaceSide cellFaceSide()   const noexcept { return m_faceSide; }
        constexpr bool isLeftFace()   const noexcept { return m_faceSide == eFaceSide::left; }
        constexpr bool isrightFace()  const noexcept { return m_faceSide == eFaceSide::right; }
        constexpr bool isGlobalFace() const noexcept { return m_faceSide == eFaceSide::global; }
        constexpr auto operator <=> (const cellFace& aOther) const
        {
            auto cmp1 = m_gblFaceI <=> aOther.m_gblFaceI;     // primary member for ordering
            if (cmp1 != 0) return cmp1;                       // return result if not equal
            auto cmp2 = m_leftNodeI <=> aOther.m_leftNodeI;   // secondary member for ordering
            if (cmp2 != 0) return cmp2;                       // return result if not equal
            auto cmp3 = m_rightNodeI <=> aOther.m_rightNodeI; // third member for ordering
            if(cmp3 != 0) return cmp3;                        // return result if not equal
            return m_cellIdx <=> aOther.m_cellIdx;            // final member for ordering
        }

        friend std::ostream& operator<< (std::ostream& os, const cellFace& aCface)
        {
            os << "Cell face Id is: " << aCface.m_gblFaceI << "\n"
             << "Left Node Id is: " << aCface.m_leftNodeI << "\n"
                 << "Right Node Id is: " << aCface.m_rightNodeI << "\n";
 
            return os;
        }
    private:
        eFaceSide m_faceSide;      
        signed short m_gblFaceI;    
        signed short m_leftNodeI;   
        signed short m_rightNodeI;  
        signed short m_cellIdx;     
    };
} // End of namespace