NBSLevel.hpp

Go to the documentation of this file.

#ifndef __NBSLevel_hpp__
#define __NBSLevel_hpp__
 
 
#include "NBSLevel0.hpp"
 
 
namespace pFlow
{
 
INLINE_FUNCTION_HD
int32x3 mapIndexLevels(const int32x3& ind, int32 lowerLevel, int32 upperLevel);
 
template<typename executionSpace>
class
NBSLevel
:
    public NBSLevel0<executionSpace>
{
public:
 
    using NBSLevel0Type = NBSLevel0<executionSpace>;
 
    using cellIterator  = typename NBSLevel0Type::cellIterator;
 
    using IdType        = typename NBSLevel0Type::IdType;
    
    using IndexType     = typename NBSLevel0Type::IndexType;
 
    using Cells         = typename NBSLevel0Type::Cells;
 
    using CellType      = typename Cells::CellType;
 
    using execution_space   = typename NBSLevel0Type::execution_space;
 
    using memory_space      = typename NBSLevel0Type::memory_space;
 
    using mdrPolicyFindPairs = typename NBSLevel0Type::mdrPolicyFindPairs;
 
    using HeadType          = typename NBSLevel0Type::HeadType;
 
    using NextType          = typename NBSLevel0Type::NextType;
 
    template<typename exeSpace>
    friend class NBSLevels;
 
protected:
 
    int32                                   level_ = 0;
 
    
public:
    
    TypeInfoNV("NBSLevel0");
 
    INLINE_FUNCTION_HD
    NBSLevel(){}
 
    NBSLevel(
        int32   lvl,
        const   box& domain,
        real    cellSize,
        real    sizeRatio,
        const   ViewType1D<realx3, memory_space>& position,
        const   ViewType1D<real, memory_space>& diam)
    :
        NBSLevel0Type(
            domain,
            cellSize,
            sizeRatio,
            position,
            diam,
            lvl==0),
        level_(lvl)
    {}
 
    INLINE_FUNCTION_HD
    NBSLevel(const NBSLevel&) = default;
    
    INLINE_FUNCTION_HD
    NBSLevel& operator = (const NBSLevel&) = default;
 
    INLINE_FUNCTION_HD
    ~NBSLevel() = default;
 
    INLINE_FUNCTION_HD
    auto level()const
    {
        return level_;
    }
 
    template<typename PairsContainer>   
    INLINE_FUNCTION_H
    int32 findPairsCountCross(PairsContainer& pairs, NBSLevel& upperLevel)
    {
 
        mdrPolicyFindPairs
            mdrPolicy(
                {0,0,0},
                {this->nx(),this->ny(),this->nz()} );
 
        int32 notInsertedPairs;
 
        Kokkos::parallel_reduce (
            "NBSLevel::findPairsCountCross",
            mdrPolicy,
            CLASS_LAMBDA_HD(int32 i, int32 j, int32 k, int32& getFullUpdate){
                #include "NBSCrossLoop.hpp"
            }, notInsertedPairs);
            
        return notInsertedPairs;    
    }
     
    
};
 
INLINE_FUNCTION_HD
int32x3 mapIndexLevels( const int32x3& ind, int32 lowerLevel, int32 upperLevel)
{
    int32 a = pow(2, static_cast<int32>(upperLevel-lowerLevel));
    return ind/a;
}
 
 
}
 
#endif