NBS.hpp

Go to the documentation of this file.

/*------------------------------- phasicFlow ---------------------------------
      O        C enter of
     O O       E ngineering and
    O   O      M ultiscale modeling of
   OOOOOOO     F luid flow       
------------------------------------------------------------------------------
  Copyright (C): www.cemf.ir
  email: hamid.r.norouzi AT gmail.com
------------------------------------------------------------------------------  
Licence:
  This file is part of phasicFlow code. It is a free software for simulating 
  granular and multiphase flows. You can redistribute it and/or modify it under
  the terms of GNU General Public License v3 or any other later versions. 
 
  phasicFlow is distributed to help others in their research in the field of 
  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
-----------------------------------------------------------------------------*/
 
 
#ifndef __NBS_hpp__
#define __NBS_hpp__
 
#include "NBSLevel0.hpp"
 
namespace pFlow
{
 
 
template<typename executionSpace>
class NBS
{
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;
 
 
protected:
 
    real        sizeRatio_ = 1.0;
 
    int32       updateFrequency_= 1;
 
    int32       currentIter_    = 0;
 
    bool        performedSearch_ = false;
 
    NBSLevel0Type NBSLevel0_;
 
private:
 
    bool performSearch()
    {
        if(currentIter_ % updateFrequency_ == 0)
        {
            currentIter_++;
            return true;
 
        }else
        {
            currentIter_++;
            return false;
        }
    }
 
public:
 
    TypeInfoNV("NBS");
 
        NBS(
            const dictionary& dict,
            const   box& domain,
            real  minSize,
            real    maxSize,
            const   ViewType1D<realx3, memory_space>& position,
            const   ViewType1D<real, memory_space>& diam)
        :
            sizeRatio_( 
                max(
                    dict.getValOrSet<real>("sizeRatio", 1.0),
                    1.0
                    )),
            updateFrequency_(
                max( 
                    dict.getValOrSet<int32>("updateFrequency", 1),
                    1
                    )),
            NBSLevel0_(
                domain, 
                maxSize*sizeRatio_,
                sizeRatio_,
                position,
                diam)
        {}
            
        INLINE_FUNCTION_HD
        NBS(const NBS&) = default;
 
        INLINE_FUNCTION_HD
        NBS& operator = (const NBS&) = default;
 
        INLINE_FUNCTION_HD
        ~NBS()=default;
 
 
    bool enterBoadSearch()const
    {
        return currentIter_%updateFrequency_==0;
    }
 
    bool performedSearch()const
    {
        return performedSearch_;
    }
 
    Vector<cellIterator> getCellIteratorLevels()
    {
        return Vector<cellIterator>("cellIterator", 1, NBSLevel0_.getCellIterator());
    }
 
    auto getCellIterator(int32 lvl)const
    {
        return NBSLevel0_.getCellIterator();
    }
 
    int32 numLevels()const
    {
        return 1;
    }
 
    Vector<Cells> getCellsLevels()const
    {
        return Vector<Cells>("Cells", 1, NBSLevel0_.getCells());
    }
 
    auto getCells()const
    {
        return NBSLevel0_.getCells();
    }
 
    bool objectSizeChanged(int32 newSize)
    {
        NBSLevel0_.checkAllocateNext(newSize);
        return true;
    }
 
    // - Perform the broad search to find pairs
    //   with force = true, perform broad search regardless of 
    //   updateFrequency_ value
    //   on all the points in the range of [0,numPoints_)
    template<typename PairsContainer>
    bool broadSearch(PairsContainer& pairs, range activeRange, bool force=false)
    {
        
        if(force) currentIter_ = 0;
        performedSearch_ = false;
 
        if( !performSearch() ) return true;
        
        
        NBSLevel0_.build(activeRange);
        
        NBSLevel0_.findPairs(pairs);
        
        performedSearch_ = true;        
        return true;
    }
 
    // - Perform the broad search to find pairs,
    //   ignore particles with incld(i) = true,
    //   with force = true, perform broad search regardless of 
    //   updateFrequency_ value
    template<typename PairsContainer, typename IncludeFunction>
    bool broadSearch(PairsContainer& pairs, range activeRange, IncludeFunction incld, bool force = false)
    {
        if(force) currentIter_ = 0;
        performedSearch_ = false;
 
        if( !performSearch() ) return true;
 
        NBSLevel0_.build(activeRange, incld);
    
        NBSLevel0_.findPairs(pairs);
        
        performedSearch_ = true;
        return true;
    }
 
};
 
}
 
#endif