wallBoundaryContactSearch.cpp

Go to the documentation of this file.

#include "wallBoundaryContactSearch.hpp"
#include "streams.hpp"
 
pFlow::wallBoundaryContactSearch::wallBoundaryContactSearch
(
    real cellExtent, 
    uint32 numPoints, 
    uint32 numElements, 
    const ViewType1D<realx3, memory_space> &points, 
    const ViewType1D<uint32x3, memory_space> &vertices, 
    const ViewType1D<realx3, memory_space> &normals
)
:
    cellExtent_( max(cellExtent, 0.5 ) ),
    numElements_(numElements),
    numPoints_(numPoints),
    vertices_(vertices),
    points_(points),
    normals_(normals)
{
    allocateArrays();
}
 
bool pFlow::wallBoundaryContactSearch::build(const cells &searchBox, const realx3& transferVec)
{
    Kokkos::parallel_for(
        "pFlow::cellsWallLevel0::build",
        deviceRPolicyStatic(0,numElements_),
        CLASS_LAMBDA_HD(uint32 i)
        {
            auto v = vertices_[i];
            auto p1 = points_[v.x()]+transferVec;
            auto p2 = points_[v.y()]+transferVec;
            auto p3 = points_[v.z()]+transferVec;
            
            realx3 minP;
            realx3 maxP;
 
            searchBox.extendBox(p1, p2, p3, cellExtent_, minP, maxP);
            elementBox_[i] = iBoxType(searchBox.pointIndex(minP), searchBox.pointIndex(maxP));
            auto d = elementBox_[i].maxPoint()-elementBox_[i].minPoint();
            validBox_[i] = (d.x()*d.y()*d.z())==0? 0:1; 
        });
    Kokkos::fence();
 
    return true;
}
 
bool pFlow::wallBoundaryContactSearch::broadSearch
(
    csPairContainerType &pairs, 
    const cells &searchCells, 
    const deviceScatteredFieldAccess<realx3> &thisPoints, 
    const deviceScatteredFieldAccess<real> &thisDiams, 
    const deviceScatteredFieldAccess<realx3> &mirrorPoints, 
    const deviceScatteredFieldAccess<real> &mirroDiams, 
    const realx3 &transferVec, 
    real sizeRatio
)
{
    uint32 nNotInserted = 1;
 
    while (nNotInserted>0u)
    {
        build(searchCells,{0,0,0});
        nNotInserted = findPairsElementRangeCount(
            pairs,
            searchCells,
            thisPoints,
            thisDiams,
            {0,0,0},
            0
        );
 
        build(searchCells, transferVec);
        nNotInserted += findPairsElementRangeCount(
            pairs,
            searchCells,
            mirrorPoints,
            mirroDiams,
            transferVec,
            BASE_MIRROR_WALL_INDEX
        );
 
        if(nNotInserted>0u)
        {
            //   note that getFull now shows the number of failed insertions.
            uint32 incCap = max(nNotInserted,50u) ;
            
            auto oldCap = pairs.capacity();
            
            pairs.increaseCapacityBy(incCap);
 
            INFORMATION<< "The contact pair container capacity increased from "<<
            oldCap << " to "<<pairs.capacity()<<" in wallBoundaryContactSearch."<<END_INFO;
        }
    }
    return true;
}
 
pFlow::uint32 pFlow::wallBoundaryContactSearch::findPairsElementRangeCount
(
    csPairContainerType &pairs, 
    const cells &searchCells, 
    const deviceScatteredFieldAccess<realx3> &pPoints, 
    const deviceScatteredFieldAccess<real> &pDiams, 
    const realx3 &transferVec, 
    uint  baseTriIndex
)
{
    
    if(pPoints.empty())return 0u;
 
    uint32 nNotInserted = 0;
    uint32 nThis = pPoints.size();
    const auto& numElements = numElements_;
    const auto& elementBox = elementBox_;
    const auto& validBox = validBox_;
 
    Kokkos::parallel_reduce(
        "pFlow::wallBoundaryContactSearch::findPairsElementRangeCount",
        deviceRPolicyDynamic(0,nThis),
        LAMBDA_HD(uint32 i, uint32 &notInsertedUpdate)
        {
            auto p = pPoints[i]+transferVec;
            int32x3 ind;
            if( searchCells.pointIndexInDomain(p, ind) )
            {
                for(uint32 nTri=0; nTri<numElements; nTri++)
                {
                    if( validBox[nTri]== 0)continue;
                    if( elementBox[nTri].isInside(ind)&& 
                        pairs.insert(i,nTri+baseTriIndex) == static_cast<uint32>(-1))
                    {
                        notInsertedUpdate++;    
                    }
                }
            }
        },
        nNotInserted
    );
 
    return nNotInserted;
}