multigrid NBS is added, not tested with particle insertion

src/Interaction/contactSearch/wallMappings/cellMapping.H

@@ -0,0 +1,150 @@
+/*------------------------------- 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 __cellMapping_H__
+#define __cellMapping_H__
+
+#include "cellsWallLevel0.H"
+#include "dictionary.H"
+
+
+namespace pFlow
+{
+
+template<
+	typename executionSpace
+	>
+class cellMapping
+{
+public:
+
+	using cellsWallLevel0Type = cellsWallLevel0<executionSpace>;
+
+	using IdType 			= typename cellsWallLevel0Type::IdType;
+
+	using IndexType 	= typename cellsWallLevel0Type::IndexType;
+
+	using Cells 			= typename cellsWallLevel0Type::Cells;
+
+	using CellType 		= typename Cells::CellType;
+
+	using execution_space = typename cellsWallLevel0Type::execution_space;
+
+	using memory_space 		= typename cellsWallLevel0Type::memory_space;
+
+	using iBoxType = iBox<IndexType>;	
+
+	
+protected:
+
+	// - update frequency 
+	int32 			updateFrequency_=1;
+
+	real 				cellExtent_;
+
+	int32 			currentIter_ = 0;
+
+	/// a broad search has been occured during last pass?
+	bool 				performedSearch_ = false;
+
+	cellsWallLevel0Type  cellsWallLevle_;
+		
+private:
+
+	bool performSearch()
+	{
+		if(currentIter_ % updateFrequency_ == 0)
+		{
+			currentIter_++;
+			return true;
+
+		}else
+		{
+			currentIter_++;
+			return false;
+		}
+	}
+
+public:
+
+	TypeNameNV("cellMapping");
+
+	cellMapping(
+		const dictionary&  		dict,
+		int32 					numLevels,
+		const Vector<Cells>& 	ppCells,
+		int32 					numPoints,
+		int32 					numElements,
+		const ViewType1D<realx3,memory_space>& 		points, 
+		const ViewType1D<int32x3,memory_space>& 	vertices
+		)
+	:
+		updateFrequency_(
+			max(
+				dict.getValOrSet<int32>(
+					"updateFrequency",
+					1),
+				1)),
+		cellExtent_(
+			max(
+				dict.getValOrSet<real>(
+					"cellExtent", 
+					0.5),
+				0.5)),
+		cellsWallLevle_(
+			ppCells[0],
+			cellExtent_,
+			numPoints,
+			numElements,
+			points,
+			vertices
+			)
+	{}
+
+
+	bool enterBoadSearch()const
+	{
+		return currentIter_%updateFrequency_==0;
+	}
+
+	bool performedSearch()const
+	{
+		return performedSearch_;
+	}
+		
+	template<typename PairsContainer, typename particleMapType>
+	bool broadSearch(PairsContainer& pairs, particleMapType& particleMap, bool force=false)
+	{
+		if(force) currentIter_ = 0;
+		performedSearch_= false;
+		if(!performSearch())return true;
+		
+		cellsWallLevle_.broadSearch(pairs, particleMap);
+
+		performedSearch_ = true;
+		return true;
+	}
+
+}; // cellMapping
+
+} // pFlow
+
+
+#endif 

src/Interaction/contactSearch/wallMappings/cellsWallLevel0.H

@@ -18,57 +18,48 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#ifndef __cellsSimple_H__
-#define __cellsSimple_H__
+#ifndef __cellsWallLevel0_H__
+#define __cellsWallLevel0_H__
 
 #include "types.H"
 #include "KokkosTypes.H"	
 #include "cells.H"
 #include "iBox.H"
-#include "dictionary.H"
+
 
 
 namespace pFlow
 {
 
 template<
-	typename executionSpace,
-	typename idType,
-	typename indexType = int32
+	typename executionSpace
 	>
-class cellsSimple
+class cellsWallLevel0
 :
-	public cells<indexType>
+	public cells<int32>
 {
 public:
 
-	using IdType 		= idType;
+	using IdType		= int32;
 
-	using IndexType 	= indexType;
+	using IndexType 	= int32;
 
 	using Cells 		= cells<IndexType>;
 
 	using CellType 		= typename Cells::CellType;
 
-	using ExecutionSpace = executionSpace;
+	using execution_space = executionSpace;
 
-	using memory_space 	= typename ExecutionSpace::memory_space;
+	using memory_space 	= typename execution_space::memory_space;
 
-	using iBoxType = iBox<IndexType>;	
+	using iBoxType 		= iBox<IndexType>;	
 
-	bool constexpr static LOOP_ELEMENT_RANGE = true;
-	
 	class TagFindCellRange2{};
+
 protected:
 
 	// - box extent
-	real 			cellExtent_ = 0.6;
-
-	// - update frequency 
-	int32 			updateFrequency_=1;
-
-
-	int32 			currentIter_ = 0;
+	real 			cellExtent_ = 0.5;
 
 	// - number of triangle elements 
 	int32			numElements_ = 0;
@@ -76,13 +67,10 @@ protected:
 	// - number of points
 	int32 			numPoints_ = 0;
 
-	/// a broad search has been occured during last pass?
-	bool 			performedSearch_ = false;
-
-	// - ref to vectices 
+	// - ref to vectices (borrowed)
 	ViewType1D<int32x3, memory_space> 	vertices_;
 
-	// - ref to points in the trisurface 
+	// - ref to points in the trisurface (borrowed)
 	ViewType1D<realx3, memory_space> 	points_;
 
 	// cell range of element/triangle bounding box
@@ -90,53 +78,40 @@ protected:
 	
 
 	using tpPWContactSearch = Kokkos::TeamPolicy<
-			ExecutionSpace,
+			execution_space,
 			Kokkos::Schedule<Kokkos::Dynamic>,
 			Kokkos::IndexType<int32>
 			>;
 
 	using rpFindCellRange2Type =
-		Kokkos::RangePolicy<TagFindCellRange2, ExecutionSpace, Kokkos::IndexType<int32>>;
+		Kokkos::RangePolicy<TagFindCellRange2, execution_space, Kokkos::IndexType<int32>>;
 
 	
 	FUNCTION_H
 	void allocateArrays()
 	{
-		Kokkos::realloc( elementBox_, numElements_);
-	}
-
-private:
-
-	bool performSearch()
-	{
-		if(currentIter_ % updateFrequency_ == 0)
-		{
-			currentIter_++;
-			return true;
-
-		}else
-		{
-			currentIter_++;
-			return false;
-		}
+		reallocNoInit( elementBox_, numElements_);
 	}
 
 public:
 
-	TypeNameNV("cellsSimple");
+	TypeNameNV("cellsWallLevel0");
+
+	INLINE_FUNCTION_HD
+	cellsWallLevel0(){}
 
 	FUNCTION_H
-	cellsSimple(
-		Cells 		ppCells,
-		real 		cellExtent,
-		int32 		numPoints,
-		int32 		numElements,
+	cellsWallLevel0(
+		const Cells& 		ppCells,
+		real 						cellExtent,
+		int32 					numPoints,
+		int32 					numElements,
 		const ViewType1D<realx3,memory_space>& 		points, 
 		const ViewType1D<int32x3,memory_space>& 	vertices
 		)
 	:
 		Cells(ppCells),
-		cellExtent_( max(cellExtent, 0.6 ) ),
+		cellExtent_( max(cellExtent, 0.5 ) ),
 		numElements_(numElements),
 		numPoints_(numPoints),
 		vertices_(vertices),
@@ -146,45 +121,11 @@ public:
 		allocateArrays();
 	}
 
-	cellsSimple(
-		dictionary  dict,
-		Cells 		ppCells,
-		int32 		numPoints,
-		int32 		numElements,
-		const ViewType1D<realx3,memory_space>& 		points, 
-		const ViewType1D<int32x3,memory_space>& 	vertices
-		)
-	:
-		Cells(ppCells),
-		numElements_(numElements),
-		numPoints_(numPoints),
-		vertices_(vertices),
-		points_(points)
-	{
-
-		updateFrequency_ = dict.getVal<int32>(
-			"updateFrequency" );
-		updateFrequency_ = max(updateFrequency_,1);
-
-		cellExtent_ = dict.getVal<real>(
-			"cellExtent");
-
-		cellExtent_ = max(cellExtent_,0.6);
-
-		allocateArrays();
-		
-	}
-
-	constexpr bool loopElementRange()const
-	{
-		return LOOP_ELEMENT_RANGE;
-	}
-
+	
 	// - host call
 	//   reset triangle elements if they have changed
-	FUNCTION_H
 	bool resetElements( 
-		int32 		numElements,
+		int32 			numElements,
 		int32       numPoints,
 		ViewType1D<realx3, memory_space>& points, 
 		ViewType1D<int32x3, memory_space>& vertices	)
@@ -212,29 +153,17 @@ public:
 		return numElements_;
 	}
 
-	bool enterBoadSearch()const
-	{
-		return currentIter_%updateFrequency_==0;
-	}
-
-	bool performedSearch()const
-	{
-		return performedSearch_;
-	}
+	
 		
 	template<typename PairsContainer, typename particleMapType>
-	bool broadSearch(PairsContainer& pairs, particleMapType& particleMap, bool force=false)
+	bool broadSearch(PairsContainer& pairs, particleMapType& particleMap)
 	{
-		if(force) currentIter_ = 0;
-		performedSearch_= false;
-		if(!performSearch())return true;
 	
 		// map walls onto the cells
 		this->build();
 		
 		this->particleWallFindPairs(pairs, particleMap);
 		
-		performedSearch_ = true;
 		return true;
 	}
 
@@ -257,7 +186,7 @@ public:
 		while (getFull)
 		{
 			
-			getFull = findPairsElementRange(pairs, particleMap);
+			getFull = findPairsElementRangeCount(pairs, particleMap.getCellIterator(0));
 			
 			if(getFull)
 			{
@@ -269,7 +198,7 @@ public:
 
 				Info<<"Contact pair container capacity increased from "<<
 						oldCap << " to " 
-						<< pairs.capacity() <<" in cellsSimple."<<endInfo;
+						<< pairs.capacity() <<" in cellsWallLevel0."<<endInfo;
 				
 				Kokkos::fence();
 			}
@@ -279,21 +208,20 @@ public:
 	}
 
 
-	template<typename PairsContainer, typename particleMapType>
-	int32 findPairsElementRange(PairsContainer& pairs, particleMapType& particleMap) 
+	template<typename PairsContainer, typename CellIteratorType>
+	int32 findPairsElementRangeCount(PairsContainer& pairs, CellIteratorType cellIter) 
 	{
 		int32 getFull =0;
 		
 		const auto pwPairs = pairs;
 		const auto elementBox = elementBox_;
-
-		auto cellIter = particleMap.getCellIterator();
 		
 		Kokkos::parallel_reduce(
 			"cellsSimple::findPairsElementRangeModified2",
 			tpPWContactSearch(numElements_, Kokkos::AUTO),
 			LAMBDA_HD(
-				const typename tpPWContactSearch::member_type & teamMember,	int32& valueToUpdate){
+				const typename tpPWContactSearch::member_type & teamMember,
+				int32& valueToUpdate){
 				
 				const int32 iTri = teamMember.league_rank();
 
@@ -349,9 +277,9 @@ public:
 
 	}
 
-};
+}; // cellsWallLevel0
 
-}
+} // pFlow
 
 
-#endif 
+#endif // __cellsWallLevel0_H__

src/Interaction/contactSearch/wallMappings/cellsWallLevels.H

@@ -0,0 +1,152 @@
+/*------------------------------- 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 __cellsWallLevels_H__
+#define __cellsWallLevels_H__
+
+#include "cellsWallLevel0.H"
+
+namespace pFlow
+{
+
+template<
+	typename executionSpace
+	>
+class cellsWallLevels
+{
+public:
+
+	using cellsWallLevel0Type = cellsWallLevel0<executionSpace>;
+
+	using IdType 			= typename cellsWallLevel0Type::IdType;
+
+	using IndexType 	= typename cellsWallLevel0Type::IndexType;
+
+	using Cells 			= typename cellsWallLevel0Type::Cells;
+
+	using CellType 		= typename Cells::CellType;
+
+	using execution_space = typename cellsWallLevel0Type::execution_space;
+
+	using memory_space 		= typename cellsWallLevel0Type::memory_space;
+
+	using iBoxType = iBox<IndexType>;
+
+protected:
+
+	int32 			numLevles_=1;
+	
+
+	Vector<cellsWallLevel0Type> 			cellsWallLevels_;	
+
+public:
+
+	TypeNameNV("cellsWallLevels");
+
+	FUNCTION_H
+	cellsWallLevels(
+		int32 					numLevels,
+		const Vector<Cells>&	cellsLevels,
+		real 					cellExtent,
+		int32 					numPoints,
+		int32 					numElements,
+		const ViewType1D<realx3,memory_space>& 		points, 
+		const ViewType1D<int32x3,memory_space>& 	vertices
+		)
+	:
+		numLevles_(numLevels),
+		cellsWallLevels_("cellsWallLevels",numLevels, numLevels, RESERVE())
+	{
+
+		
+
+		for(int32 lvl=0; lvl<numLevles_; lvl++)
+		{
+			cellsWallLevels_[lvl] = 
+				cellsWallLevel0Type(
+					cellsLevels[lvl],
+					cellExtent,
+					numPoints,
+					numElements,
+					points,
+					vertices);
+		}
+
+	}
+	
+		
+	template<typename PairsContainer, typename particleMapType>
+	bool broadSearch(PairsContainer& pairs, particleMapType& particleMap)
+	{
+	
+		// map walls onto the cells
+		for(int32 lvl=0; lvl<numLevles_; lvl++)
+		{
+			cellsWallLevels_[lvl].build();
+		}
+		
+		this->particleWallFindPairs(pairs, particleMap);
+		
+		return true;
+	}
+
+	template<typename PairsContainer, typename particleMapType>
+	bool particleWallFindPairs(PairsContainer& pairs, particleMapType& particleMap)
+	{
+
+		int32 getFull = 1;
+
+		while (getFull)
+		{
+			getFull = 0;
+			for(int32 lvl=0; lvl<numLevles_; lvl++)
+			{
+				getFull += 
+					cellsWallLevels_[lvl].findPairsElementRangeCount(
+						pairs, 
+						particleMap.getCellIterator(lvl));
+			}
+			
+			if(getFull)
+			{
+				// - resize the container
+				//   note that getFull now shows the number of failed insertions.
+				uint32 len = max(getFull, 5000);
+				auto oldCap = pairs.capacity();
+				pairs.increaseCapacityBy(len);
+
+				Info<<"Contact pair container capacity increased from "<<
+						oldCap << " to " 
+						<< pairs.capacity() <<" in cellsWallLevels."<<endInfo;
+				
+				Kokkos::fence();
+			}
+		}
+		
+		return true;
+	}
+
+
+}; // cellsWallLevels
+
+} // pFlow
+
+
+#endif // __cellsWallLevels_H__

src/Interaction/contactSearch/wallMappings/multiGridMapping.H

@@ -0,0 +1,153 @@
+/*------------------------------- 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 __multiGridMapping_H__
+#define __multiGridMapping_H__
+
+#include "cellsWallLevels.H"
+#include "dictionary.H"
+
+
+namespace pFlow
+{
+
+template<
+	typename executionSpace
+	>
+class multiGridMapping
+{
+public:
+
+	using CellsWallLevelType = cellsWallLevels<executionSpace>;
+
+	using IdType 			= typename CellsWallLevelType::IdType;
+
+	using IndexType 	= typename CellsWallLevelType::IndexType;
+
+	using Cells 			= typename CellsWallLevelType::Cells;
+
+	using CellType 		= typename Cells::CellType;
+
+	using execution_space = typename CellsWallLevelType::execution_space;
+
+	using memory_space 		= typename CellsWallLevelType::memory_space;
+
+	using iBoxType = iBox<IndexType>;	
+
+	
+protected:
+
+	// - update frequency 
+	int32 			updateFrequency_=1;
+
+	real 				cellExtent_;
+
+	int32 			currentIter_ = 0;
+
+	/// a broad search has been occured during last pass?
+	bool 				performedSearch_ = false;
+
+	CellsWallLevelType  cellsWallLevle_;
+		
+private:
+
+	bool performSearch()
+	{
+		if(currentIter_ % updateFrequency_ == 0)
+		{
+			currentIter_++;
+			return true;
+
+		}else
+		{
+			currentIter_++;
+			return false;
+		}
+	}
+
+public:
+
+	TypeNameNV("multiGridMapping");
+
+	multiGridMapping(
+		const dictionary&  			dict,
+		int32 					numLevels,
+		const Vector<Cells>& 	ppCells,
+		int32 					numPoints,
+		int32 					numElements,
+		const ViewType1D<realx3,memory_space>& 		points, 
+		const ViewType1D<int32x3,memory_space>& 	vertices
+		)
+	:
+		updateFrequency_(
+			max(
+				dict.getVal<int32>("updateFrequency"),
+				1)),
+		cellExtent_(
+			max(
+				dict.getVal<real>("cellExtent"),
+				0.5)),
+		cellsWallLevle_(
+			numLevels,
+			ppCells,
+			cellExtent_,
+			numPoints,
+			numElements,
+			points,
+			vertices
+			)
+	{
+
+		Report(3)<<"Multi-grid wall mapping with "<< 
+			yellowText(numLevels)<<" levels has been created."<<endReport;
+	}
+
+
+	bool enterBoadSearch()const
+	{
+		return currentIter_%updateFrequency_==0;
+	}
+
+	bool performedSearch()const
+	{
+		return performedSearch_;
+	}
+		
+	template<typename PairsContainer, typename particleMapType>
+	bool broadSearch(PairsContainer& pairs, particleMapType& particleMap, bool force=false)
+	{
+		if(force) currentIter_ = 0;
+		performedSearch_= false;
+		if(!performSearch())return true;
+
+
+		cellsWallLevle_.broadSearch(pairs, particleMap);
+
+
+		performedSearch_ = true;
+		return true;
+	}
+
+}; // multiGridMapping
+
+} // pFlow
+
+
+#endif