global damping is activated for velocity and rVelocity in both sphere and grain solvers

merge from main

CMakeLists.txt

@@ -6,7 +6,7 @@ project(phasicFlow VERSION 1.0 )
 set(CMAKE_CXX_STANDARD 17 CACHE STRING "" FORCE)
 set(CMAKE_CXX_STANDARD_REQUIRED True)
 set(CMAKE_INSTALL_PREFIX ${phasicFlow_SOURCE_DIR} CACHE PATH "Install path of phasicFlow" FORCE)
-set(CMAKE_BUILD_TYPE Debug CACHE STRING "build type" FORCE)
+set(CMAKE_BUILD_TYPE Release CACHE STRING "build type" FORCE)
 set(BUILD_SHARED_LIBS ON CACHE BOOL "Build using shared libraries" FORCE)
 mark_as_advanced(FORCE var BUILD_SHARED_LIBS)
 

DEMSystems/grainDEMSystem/grainDEMSystem.cpp

@@ -78,9 +78,14 @@ pFlow::grainDEMSystem::grainDEMSystem(
 	REPORT(0)<< "\nCreating surface geometry for grainDEMSystem . . . "<<END_REPORT;
 	geometry_ = geometry::create(Control(), Property());
 
+	REPORT(0)<<"Reading shape dictionary ..."<<END_REPORT;
+	grains_ = makeUnique<grainShape>(
+		pFlow::shapeFile__,
+		&Control().caseSetup(),
+		Property() );	
 
 	REPORT(0)<<"\nReading grain particles . . ."<<END_REPORT;
-	particles_ = makeUnique<grainFluidParticles>(Control(), Property());
+	particles_ = makeUnique<grainFluidParticles>(Control(), grains_());
 
 
 	insertion_ = makeUnique<grainInsertion>( 

DEMSystems/grainDEMSystem/grainDEMSystem.hpp

@@ -46,6 +46,8 @@ protected:
 
 	uniquePtr<geometry> 			geometry_ = nullptr;
 
+	uniquePtr<grainShape> 			grains_   = nullptr;
+
 	uniquePtr<grainFluidParticles>  particles_ = nullptr;
 
 	uniquePtr<grainInsertion> 		insertion_ = nullptr;

DEMSystems/grainDEMSystem/grainFluidParticles.cpp

@@ -35,8 +35,8 @@ void pFlow::grainFluidParticles::checkHostMemory()
 
 pFlow::grainFluidParticles::grainFluidParticles(
     systemControl &control,
-    const property &prop)
-    : grainParticles(control, prop),
+    const grainShape& grains)
+    : grainParticles(control, grains),
       fluidForce_(
           objectFile(
               "fluidForce",
@@ -67,7 +67,7 @@ bool pFlow::grainFluidParticles::beforeIteration()
 
 bool pFlow::grainFluidParticles::iterate() 
 {
-
+	const auto ti = this->TimeInfo();
 	accelerationTimer().start();
 		pFlow::grainFluidParticlesKernels::acceleration(
 			control().g(),
@@ -78,16 +78,16 @@ bool pFlow::grainFluidParticles::iterate()
 			contactTorque().deviceViewAll(),
 			fluidTorque_.deviceViewAll(),
 			pStruct().activePointsMaskDevice(),
-			accelertion().deviceViewAll(),
+			acceleration().deviceViewAll(),
 			rAcceleration().deviceViewAll()
 			);
 	accelerationTimer().end();
 	
 	intCorrectTimer().start();
 	
-		dynPointStruct().correct(this->dt(), accelertion());
+		dynPointStruct().correct(ti.dt());
 	
-		rVelIntegration().correct(this->dt(), rVelocity(), rAcceleration());
+		rVelIntegration().correct(ti.dt(), rVelocity(), rAcceleration());
 	
 	intCorrectTimer().end();
 	

DEMSystems/grainDEMSystem/grainFluidParticles.hpp

@@ -59,7 +59,7 @@ protected:
 public:
 
 	/// construct from systemControl and property 
-	grainFluidParticles(systemControl &control, const property& prop);
+	grainFluidParticles(systemControl &control, const grainShape& grains);
 
 	~grainFluidParticles() override = default;
 	

DEMSystems/sphereDEMSystem/sphereDEMSystem.cpp

@@ -75,12 +75,18 @@ pFlow::sphereDEMSystem::sphereDEMSystem(
 		propertyFile__,
     	Control().caseSetup().path());
 		
+
 	REPORT(0)<< "\nCreating surface geometry for sphereDEMSystem . . . "<<END_REPORT;
 	geometry_ = geometry::create(Control(), Property());
 
+	REPORT(0)<<"Reading shapes dictionary..."<<END_REPORT;
+	spheres_ = makeUnique<sphereShape>(
+		pFlow::shapeFile__, 
+		&Control().caseSetup(), 
+		Property());
 
 	REPORT(0)<<"\nReading sphere particles . . ."<<END_REPORT;
-	particles_ = makeUnique<sphereFluidParticles>(Control(), Property());
+	particles_ = makeUnique<sphereFluidParticles>(Control(), spheres_());
 
 
 	insertion_ = makeUnique<sphereInsertion>( 

DEMSystems/sphereDEMSystem/sphereDEMSystem.hpp

@@ -46,6 +46,8 @@ protected:
 
 	uniquePtr<geometry> 			geometry_ = nullptr;
 
+	uniquePtr<sphereShape> 			spheres_  = nullptr;
+
 	uniquePtr<sphereFluidParticles> particles_ = nullptr;
 
 	uniquePtr<sphereInsertion> 		insertion_ = nullptr;

DEMSystems/sphereDEMSystem/sphereFluidParticles.cpp

@@ -32,8 +32,8 @@ void pFlow::sphereFluidParticles::checkHostMemory()
 
 pFlow::sphereFluidParticles::sphereFluidParticles(
     systemControl &control,
-    const property &prop)
-    : sphereParticles(control, prop),
+    const sphereShape& shpShape)
+    : sphereParticles(control, shpShape),
       fluidForce_(
           objectFile(
               "fluidForce",
@@ -65,7 +65,7 @@ bool pFlow::sphereFluidParticles::beforeIteration()
 
 bool pFlow::sphereFluidParticles::iterate() 
 {
-
+	const auto ti = this->TimeInfo();
 	accelerationTimer().start();
 		pFlow::sphereFluidParticlesKernels::acceleration(
 			control().g(),
@@ -76,16 +76,16 @@ bool pFlow::sphereFluidParticles::iterate()
 			contactTorque().deviceViewAll(),
 			fluidTorque_.deviceViewAll(),
 			pStruct().activePointsMaskDevice(),
-			accelertion().deviceViewAll(),
+			acceleration().deviceViewAll(),
 			rAcceleration().deviceViewAll()
 			);
 	accelerationTimer().end();
 	
 	intCorrectTimer().start();
 	
-		dynPointStruct().correct(this->dt(), accelertion());
+		dynPointStruct().correct(ti.dt());
 	
-		rVelIntegration().correct(this->dt(), rVelocity(), rAcceleration());
+		rVelIntegration().correct(ti.dt(), rVelocity(), rAcceleration());
 	
 	intCorrectTimer().end();
 	

DEMSystems/sphereDEMSystem/sphereFluidParticles.hpp

@@ -66,7 +66,7 @@ protected:
 public:
 
 	/// construct from systemControl and property 
-	sphereFluidParticles(systemControl &control, const property& prop);
+	sphereFluidParticles(systemControl &control, const sphereShape& shpShape);
 	
 	/// before iteration step 
 	bool beforeIteration() override;

cmake/autoComplete

@@ -1,8 +1,46 @@
 PF_cFlags="--description --help --version"
+AllTimeFolders=
+__getAllTime(){
+	files=( $(ls) )
+	deleteFiles=(settings caseSetup cleanThisCase VTK runThisCase stl postprocess postProcess) 
+	declare -A delk
+	for del in "${deleteFiles[@]}" ; do delk[$del]=1 ; done
+		# Tag items to remove, based on
+	for k in "${!files[@]}" ; do
+		[ "${delk[${files[$k]}]-}" ] && unset 'files[k]'
+	done
+		# Compaction
+	COMPREPLY=("${files[@]}")
+	AllTimeFolders="${files[@]}"
+}
+
+__getFields(){
+	__getAllTime
+	local -A unique_files=()
+
+	for dir in $AllTimeFolders; do
+	  # Check if the directory exists
+	  if [ ! -d "$dir" ]; then
+		continue  # Skip to the next directory
+	  fi
+		  
+	  files_in_dir=$(find "$dir" -maxdepth 1 -type f -printf '%f\n' | sort -u)
+	  
+	# Add filenames to the associative array (duplicates will be overwritten)
+	  while IFS= read -r filename; do
+		unique_files["$filename"]=1 # Just the key is important, value can be anything
+	  done <<< "$files_in_dir"
+	  
+	done
+	COMPREPLY=("${!unique_files[@]}")
+	AllTimeFolders=
+}
 
 _pFlowToVTK(){
-    if [ "$3" == "--time" ]; then
-      COMPREPLY=( $(ls) )
+    if [ "$3" == "--time" ]  ; then
+        __getAllTime
+    elif [ "$3" == "--fields" ]; then 
+    	__getFields
     else
         COMPREPLY=( $(compgen -W "$PF_cFlags --binary --no-geometry --no-particles --out-folder --time --separate-surfaces --fields" -- "$2") )
     fi
@@ -11,7 +49,7 @@ complete -F _pFlowToVTK pFlowToVTK
 
 _postprocessPhasicFlow(){
     if [ "$3" == "--time" ]; then
-      COMPREPLY=( $(ls) )
+      __getAllTime
     else
       COMPREPLY=( $(compgen -W "$PF_cFlags --out-folder --time --zeroFolder" -- "$2") )
     fi

solvers/grainGranFlow/createDEMComponents.hpp

@@ -17,10 +17,17 @@ Licence:
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 -----------------------------------------------------------------------------*/
+REPORT(0)<<"Reading shape dictionary ..."<<END_REPORT;
+pFlow::grainShape grains
+(
+	pFlow::shapeFile__,
+	&Control.caseSetup(),
+	proprties
+);
 
 //
 REPORT(0)<<"\nReading sphere particles . . ."<<END_REPORT;
-pFlow::grainParticles grnParticles(Control, proprties);
+pFlow::grainParticles grnParticles(Control, grains);
 
 //
 REPORT(0)<<"\nCreating particle insertion object . . ."<<END_REPORT;

solvers/iterateSphereParticles/createDEMComponents.hpp

@@ -18,8 +18,16 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
+REPORT(0)<<"Reading shape dictionary ..."<<END_REPORT;
+pFlow::sphereShape spheres
+(
+	pFlow::shapeFile__,
+	&Control.caseSetup(),
+	proprties
+);
+
 //
 REPORT(0)<<"\nReading sphere particles . . ."<<END_REPORT;
-pFlow::sphereParticles sphParticles(Control, proprties);
+pFlow::sphereParticles sphParticles(Control, spheres);
 
 WARNING<<"Particle insertion has not been set yet!"<<END_WARNING;

solvers/sphereGranFlow/createDEMComponents.hpp

@@ -17,10 +17,18 @@ Licence:
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 -----------------------------------------------------------------------------*/
-
+REPORT(0)<<"Reading shapes dictionary..."<<END_REPORT;
+pFlow::sphereShape spheres
+(
+	pFlow::shapeFile__,
+	&Control.caseSetup(),
+	proprties
+);
 //
 REPORT(0)<<"\nReading sphere particles . . ."<<END_REPORT;
-pFlow::sphereParticles sphParticles(Control, proprties);
+
+
+pFlow::sphereParticles sphParticles(Control, spheres);
 
 //
 REPORT(0)<<"\nCreating particle insertion object . . ."<<END_REPORT;

src/Integration/AdamsBashforth2/AdamsBashforth2.cpp

@@ -37,7 +37,8 @@ bool intAllActive(
 	real dt, 
 	realx3Field_D& y, 
 	realx3PointField_D& dy,
-	realx3PointField_D& dy1)
+	realx3PointField_D& dy1,
+	real damping = 1.0)
 {
 
 	auto d_dy = dy.deviceView();
@@ -49,7 +50,7 @@ bool intAllActive(
 		"AdamsBashforth2::correct",
 		rpIntegration (activeRng.start(), activeRng.end()),
 		LAMBDA_HD(uint32 i){
-			d_y[i] +=  dt*(static_cast<real>(1.5) * d_dy[i] - static_cast<real>(0.5) * d_dy1[i]);
+			d_y[i] +=  damping * dt*(static_cast<real>(1.5) * d_dy[i] - static_cast<real>(0.5) * d_dy1[i]);
 			d_dy1[i] = d_dy[i];
 		});
 	Kokkos::fence();
@@ -62,7 +63,8 @@ bool intScattered
 	real dt, 
 	realx3Field_D& y,
 	realx3PointField_D& dy,
-	realx3PointField_D& dy1
+	realx3PointField_D& dy1,
+	real damping = 1.0
 )
 {
 
@@ -78,7 +80,7 @@ bool intScattered
 		LAMBDA_HD(uint32 i){
 			if( activeP(i))
 			{
-				d_y[i] +=  dt*(static_cast<real>(1.5) * d_dy[i] - static_cast<real>(0.5) * d_dy1[i]);
+				d_y[i] +=  damping * dt*(static_cast<real>(1.5) * d_dy[i] - static_cast<real>(0.5) * d_dy1[i]);
 				d_dy1[i] = d_dy[i];
 			}
 		});
@@ -112,8 +114,11 @@ pFlow::AdamsBashforth2::AdamsBashforth2
 		zero3,
 		zero3
 	),
+	initialValField_(initialValField),
 	boundaryList_(pStruct, method, *this)
-{}
+{
+	realx3PointField_D::addEvent(message::ITEMS_INSERT);
+}
 
 void pFlow::AdamsBashforth2::updateBoundariesSlaveToMasterIfRequested()
 {
@@ -142,18 +147,19 @@ bool pFlow::AdamsBashforth2::correct
 (
 	real dt,
 	realx3PointField_D& y,
-	realx3PointField_D& dy
+	realx3PointField_D& dy,
+	real damping
 )
 {
 	auto& dy1l = dy1();
 	bool success = false;
 	if(dy1l.isAllActive())
 	{
-		success = intAllActive(dt, y.field(), dy, dy1l);
+		success = intAllActive(dt, y.field(), dy, dy1(), damping);
 	}
 	else
 	{
-		success = intScattered(dt, y.field(), dy, dy1l);
+		success = intScattered(dt, y.field(), dy, dy1(), damping);
 	}
 
 	success = success && boundaryList_.correct(dt, y, dy);
@@ -171,11 +177,11 @@ bool pFlow::AdamsBashforth2::correctPStruct(
 	bool success = false;
 	if(dy1l.isAllActive())
 	{
-		success = intAllActive(dt, pStruct.pointPosition(), vel, dy1l);
+		success = intAllActive(dt, pStruct.pointPosition(), vel,  dy1());
 	}
 	else
 	{
-		success = intScattered(dt, pStruct.pointPosition(), vel, dy1l);
+		success = intScattered(dt, pStruct.pointPosition(), vel,  dy1());
 	}
 
 	success = success && boundaryList_.correctPStruct(dt, pStruct, vel);
@@ -183,11 +189,21 @@ bool pFlow::AdamsBashforth2::correctPStruct(
 	return success;
 }
 
-
-bool pFlow::AdamsBashforth2::setInitialVals(
-	const int32IndexContainer& newIndices,
-	const realx3Vector& y)
+/*bool pFlow::AdamsBashforth2::hearChanges
+(
+	const timeInfo &ti, 
+	const message &msg, 
+	const anyList &varList
+)
 {
-	return true;
-}
+	if(msg.equivalentTo(message::ITEMS_INSERT))
+	{
 		
+		return insertValues(varList, initialValField_.deviceViewAll(), dy1());
+	}
+	else
+	{
+		return realx3PointField_D::hearChanges(ti, msg, varList);
+	}
+    
+}*/

src/Integration/AdamsBashforth2/AdamsBashforth2.hpp

@@ -41,10 +41,14 @@ class AdamsBashforth2
 {
 private:
 
+	const realx3Field_D& initialValField_;
+
 	boundaryIntegrationList boundaryList_;
 
 	friend class processorAB2BoundaryIntegration;
 
+protected:
+	
 	const auto& dy1()const
 	{
 		return static_cast<const realx3PointField_D&>(*this);
@@ -55,6 +59,16 @@ private:
 		return static_cast<realx3PointField_D&>(*this);
 	}
 
+	auto& initialValField()
+	{
+		return initialValField_;
+	}
+
+	boundaryIntegrationList& boundaryList()
+	{
+		return boundaryList_;
+	}
+	
 public:
 
 	/// Class info
@@ -70,7 +84,7 @@ public:
 			const realx3Field_D& initialValField);
 
 		/// Destructor 
-		~AdamsBashforth2()final = default;
+		~AdamsBashforth2()override = default;
 
 		/// Add this to the virtual constructor table 
 		add_vCtor(
@@ -102,32 +116,21 @@ public:
 		bool correct(
 			real dt, 
 			realx3PointField_D& y, 
-			realx3PointField_D& dy) final;
+			realx3PointField_D& dy,
+			real damping = 1.0) override;
 
 		bool correctPStruct(
 			real dt, 
 			pointStructure& pStruct, 
-			realx3PointField_D& vel) final;
-			
+			realx3PointField_D& vel) override;
 		
 		/*bool hearChanges
 		(
-			real t,
-			real dt,
-			uint32 iter,
+			const timeInfo& ti,
 			const message& msg, 
 			const anyList& varList
 		) override;*/
 
-		bool setInitialVals(
-			const int32IndexContainer& newIndices,
-			const realx3Vector& y) final;
-
-		bool needSetInitialVals()const final
-		{
-			return false;
-		}
-
 };
 
 

src/Integration/AdamsBashforth3/AdamsBashforth3.cpp

@@ -20,90 +20,184 @@ Licence:
 
 #include "AdamsBashforth3.hpp"
 
-//const real AB3_coef[] = { 23.0 / 12.0, 16.0 / 12.0, 5.0 / 12.0 };
-
-pFlow::AdamsBashforth3::AdamsBashforth3
-(
-	const word& baseName,
-	repository& owner,
-	const pointStructure& pStruct,
-	const word& method
-)
-:
-	integration(baseName, owner, pStruct, method),
-	history_(
-		owner.emplaceObject<pointField<VectorSingle,AB3History>>(
-			objectFile(
-				groupNames(baseName,"AB3History"),
-				"",
-				objectFile::READ_IF_PRESENT,
-				objectFile::WRITE_ALWAYS),
-			pStruct,
-			AB3History({zero3,zero3})))
-
+namespace pFlow
 {
 
-}
+/// Range policy for integration kernel (alias)
+using rpIntegration = Kokkos::RangePolicy<
+		DefaultExecutionSpace,
+		Kokkos::Schedule<Kokkos::Static>,
+		Kokkos::IndexType<uint32>
+		>;
 
-bool pFlow::AdamsBashforth3::predict
-(
-	real UNUSED(dt),
-	realx3Vector_D& UNUSED(y),
-	realx3Vector_D& UNUSED(dy)
-)
-{
-
-	return true;
-}
-
-bool pFlow::AdamsBashforth3::correct
-(
+bool intAllActive(
 	real dt, 
-	realx3Vector_D& y,
-	realx3Vector_D& dy
-)
+	realx3Field_D& y, 
+	realx3PointField_D& dy,
+	realx3PointField_D& dy1,
+	realx3PointField_D& dy2,
+	real damping = 1.0)
 {
 
-	if(this->pStruct().allActive())
-	{
-		return intAll(dt, y, dy, this->pStruct().activeRange());
-	}
-	else
-	{
-		return intRange(dt, y, dy, this->pStruct().activePointsMaskD());
-	}
-
-	return true;
-}
-
-bool pFlow::AdamsBashforth3::setInitialVals(
-	const int32IndexContainer& newIndices,
-	const realx3Vector& y)
-{
-	return true;
-}
-
-bool pFlow::AdamsBashforth3::intAll(
-	real dt, 
-	realx3Vector_D& y, 
-	realx3Vector_D& dy, 
-	range activeRng)
-{
-	auto d_dy = dy.deviceViewAll();
-	auto d_y  = y.deviceViewAll();
-	auto d_history = history_.deviceViewAll();
+	auto d_dy = dy.deviceView();
+	auto d_y  = y.deviceView();
+	auto d_dy1= dy1.deviceView();
+	auto d_dy2= dy2.deviceView();
+	auto activeRng = dy1.activeRange();
 
 	Kokkos::parallel_for(
 		"AdamsBashforth3::correct",
-		rpIntegration (activeRng.first, activeRng.second),
-		LAMBDA_HD(int32 i){
-			auto ldy = d_dy[i];
-			d_y[i] += dt*( static_cast<real>(23.0 / 12.0) * ldy 
-				- static_cast<real>(16.0 / 12.0) * d_history[i].dy1_ 
-				+ static_cast<real>(5.0 / 12.0) * d_history[i].dy2_);
-			d_history[i] = {ldy ,d_history[i].dy1_};
+		rpIntegration (activeRng.start(), activeRng.end()),
+		LAMBDA_HD(uint32 i){
+			d_y[i] += damping* dt*( static_cast<real>(23.0 / 12.0) * d_dy[i] 
+						- static_cast<real>(16.0 / 12.0) * d_dy1[i] 
+						+ static_cast<real>(5.0 / 12.0) * d_dy2[i]) ;
+			
+			d_dy2[i] = d_dy1[i];
+			d_dy1[i] = d_dy[i];
+
 		});
 	Kokkos::fence();
 
 	return true;	
 }
+
+bool intScattered
+(
+	real dt, 
+	realx3Field_D& y,
+	realx3PointField_D& dy,
+	realx3PointField_D& dy1,
+	realx3PointField_D& dy2,
+	real damping = 1.0
+)
+{
+
+	auto d_dy 		= dy.deviceView();
+	auto d_y  		= y.deviceView();
+	auto d_dy1		= dy1.deviceView();
+	auto d_dy2		= dy2.deviceView();
+	auto activeRng 	= dy1.activeRange();
+	const auto& activeP = dy1.activePointsMaskDevice();
+
+	Kokkos::parallel_for(
+		"AdamsBashforth3::correct",
+		rpIntegration (activeRng.start(), activeRng.end()),
+		LAMBDA_HD(uint32 i){
+			if( activeP(i))
+			{
+				d_y[i] += damping * dt*( static_cast<real>(23.0 / 12.0) * d_dy[i] 
+						- static_cast<real>(16.0 / 12.0) * d_dy1[i] 
+						+ static_cast<real>(5.0 / 12.0) * d_dy2[i]);
+			
+				d_dy2[i] = d_dy1[i];
+				d_dy1[i] = d_dy[i];
+			}
+		});
+	Kokkos::fence();
+
+
+	return true;
+}
+
+}
+
+//const real AB3_coef[] = { 23.0 / 12.0, 16.0 / 12.0, 5.0 / 12.0 };
+
+pFlow::AdamsBashforth3::AdamsBashforth3
+(
+	const word& baseName,
+	pointStructure& pStruct,
+	const word& method,
+	const realx3Field_D& initialValField
+)
+:
+	AdamsBashforth2(baseName, pStruct, method, initialValField),
+	dy2_
+	(
+		objectFile
+		(
+			groupNames(baseName,"dy2"),
+			pStruct.time().integrationFolder(),
+			objectFile::READ_IF_PRESENT,
+			objectFile::WRITE_ALWAYS
+		),
+		pStruct,
+		zero3,
+		zero3
+	)
+
+{
+	
+}
+
+void pFlow::AdamsBashforth3::updateBoundariesSlaveToMasterIfRequested()
+{
+	AdamsBashforth2::updateBoundariesSlaveToMasterIfRequested();
+	dy2_.updateBoundariesSlaveToMasterIfRequested();
+}
+
+
+
+bool pFlow::AdamsBashforth3::correct
+(
+	real dt, 
+	realx3PointField_D& y, 
+	realx3PointField_D& dy,
+	real damping
+)
+{
+	
+	bool success = false;
+	if(y.isAllActive())
+	{
+		success = intAllActive(dt, y.field(), dy, dy1(), dy2(), damping);
+	}
+	else
+	{
+		success = intScattered(dt, y.field(), dy, dy1(), dy2(), damping);
+	}
+
+	success = success && boundaryList().correct(dt, y, dy);
+
+	return success;
+}
+
+bool pFlow::AdamsBashforth3::correctPStruct(
+	real dt, 
+	pointStructure &pStruct, 
+	realx3PointField_D &vel)
+{
+	
+	bool success = false;
+	if(dy2().isAllActive())
+	{
+		success = intAllActive(dt, pStruct.pointPosition(), vel, dy1(), dy2());
+	}
+	else
+	{
+		success = intScattered(dt, pStruct.pointPosition(), vel, dy1(), dy2());
+	}
+
+	success = success && boundaryList().correctPStruct(dt, pStruct, vel);
+
+	return success;
+}
+
+/*bool pFlow::AdamsBashforth3::hearChanges
+(
+	const timeInfo &ti, 
+	const message &msg, 
+	const anyList &varList
+)
+{
+	if(msg.equivalentTo(message::ITEMS_INSERT))
+	{
+		return insertValues(varList, initialValField().deviceViewAll(), dy1()) &&
+		insertValues(varList, initialValField().deviceViewAll(), dy2());
+	}
+	else
+	{
+		return realx3PointField_D::hearChanges(ti, msg, varList);
+	}
+}*/

src/Integration/AdamsBashforth3/AdamsBashforth3.hpp

@@ -22,48 +22,14 @@ Licence:
 #define __AdamsBashforth3_hpp__
 
 
-#include "integration.hpp"
+#include "AdamsBashforth2.hpp"
 #include "pointFields.hpp"
+#include "boundaryIntegrationList.hpp"
+
 
 namespace pFlow
 {
 
-struct AB3History
-{
-	TypeInfoNV("AB3History");
-
-	realx3 dy1_={0,0,0};
-	realx3 dy2_={0,0,0};
-};
-
-
-INLINE_FUNCTION
-iIstream& operator>>(iIstream& str, AB3History& ab3)
-{
-	str.readBegin("AB3History");
-
-    str >> ab3.dy1_;
-    str >> ab3.dy2_;
-    
-    str.readEnd("AB3History");
-
-    str.check(FUNCTION_NAME);
-
-	return str;
-	
-}
-
-INLINE_FUNCTION
-iOstream& operator<<(iOstream& str, const AB3History& ab3)
-{
-	str << token::BEGIN_LIST << ab3.dy1_
-	    << token::SPACE << ab3.dy2_
-		<< token::END_LIST;	    
-
-	str.check(FUNCTION_NAME);
-
-	return str;
-}
 
 /**
  * Third order Adams-Bashforth integration method for solving ODE
@@ -72,19 +38,26 @@ iOstream& operator<<(iOstream& str, const AB3History& ab3)
  */
 class AdamsBashforth3
 :
-	public integration
+	public AdamsBashforth2
 {
+private:
+	
+	friend class processorAB3BoundaryIntegration;
+
+	realx3PointField_D 		dy2_;
+
 protected:
 
-	/// Integration history
-	pointField<VectorSingle,AB3History>& history_;
+	const auto& dy2()const
+	{
+		return dy2_;
+	}
+
+	auto& dy2()
+	{
+		return dy2_;
+	}
 	
-	/// Range policy for integration kernel
-	using rpIntegration = Kokkos::RangePolicy<
-			DefaultExecutionSpace,
-			Kokkos::Schedule<Kokkos::Static>,
-			Kokkos::IndexType<int32>
-			>;
 
 public:
 
@@ -96,17 +69,13 @@ public:
 		/// Construct from components
 		AdamsBashforth3(
 			const word& baseName,
-			repository& owner,
-			const pointStructure& pStruct,
-			const word& method);
+			pointStructure& pStruct,
+			const word& method,
+			const realx3Field_D& initialValField);
 		
-		uniquePtr<integration> clone()const override
-		{
-			return makeUnique<AdamsBashforth3>(*this);
-		}
 
 		/// Destructor 
-		virtual ~AdamsBashforth3()=default;
+		~AdamsBashforth3() override =default;
 
 		/// Add this to the virtual constructor table 
 		add_vCtor(
@@ -117,43 +86,39 @@ public:
 
 	// - Methods
 
-		bool predict(
-			real UNUSED(dt),
-			realx3Vector_D & UNUSED(y),
-			realx3Vector_D& UNUSED(dy)) override;
+		void updateBoundariesSlaveToMasterIfRequested()override;
 
-		bool correct(real dt, 
-			realx3Vector_D & y,
-			realx3Vector_D& dy) override;
-
-		bool setInitialVals(
-			const int32IndexContainer& newIndices,
-			const realx3Vector& y) override;
-
-		bool needSetInitialVals()const override
+		/// return integration method 
+		word method()const override
 		{
-			return false;
+			return "AdamsBashforth3";
 		}
 
-		/// Integrate on all points in the active range 
-		bool intAll(
-			real dt, 
-			realx3Vector_D& y, 
-			realx3Vector_D& dy, 
-			range activeRng);
 		
-		/// Integrate on active points in the active range 
-		template<typename activeFunctor>
-		bool intRange(
+
+		bool correct(
 			real dt, 
-			realx3Vector_D& y,
-			realx3Vector_D& dy,
-			activeFunctor activeP );
+			realx3PointField_D& y, 
+			realx3PointField_D& dy,
+			real damping = 1.0) override;
+
+		bool correctPStruct(
+			real dt, 
+			pointStructure& pStruct, 
+			realx3PointField_D& vel) override;
+			
+		
+		/*bool hearChanges
+		(
+			const timeInfo& ti,
+			const message& msg, 
+			const anyList& varList
+		) override;*/
 
 };
 
 
-template<typename activeFunctor>
+/*template<typename activeFunctor>
 bool pFlow::AdamsBashforth3::intRange(
 	real dt, 
 	realx3Vector_D& y,
@@ -181,7 +146,7 @@ bool pFlow::AdamsBashforth3::intRange(
 	Kokkos::fence();
 
 	return true;
-}
+}*/
 
 } // pFlow
 

src/Integration/AdamsBashforth4/AdamsBashforth4.cpp

@@ -20,96 +20,186 @@ Licence:
 
 #include "AdamsBashforth4.hpp"
 
-
-
-pFlow::AdamsBashforth4::AdamsBashforth4
-(
-	const word& baseName,
-	repository& owner,
-	const pointStructure& pStruct,
-	const word& method
-)
-:
-	integration(baseName, owner, pStruct, method),
-	history_(
-		owner.emplaceObject<pointField<VectorSingle,AB4History>>(
-			objectFile(
-				groupNames(baseName,"AB4History"),
-				"",
-				objectFile::READ_IF_PRESENT,
-				objectFile::WRITE_ALWAYS),
-			pStruct,
-			AB4History({zero3,zero3, zero3})))
-
+namespace pFlow
 {
 
-}
+/// Range policy for integration kernel (alias)
+using rpIntegration = Kokkos::RangePolicy<
+		DefaultExecutionSpace,
+		Kokkos::Schedule<Kokkos::Static>,
+		Kokkos::IndexType<uint32>
+		>;
 
-bool pFlow::AdamsBashforth4::predict
-(
-	real UNUSED(dt),
-	realx3Vector_D& UNUSED(y),
-	realx3Vector_D& UNUSED(dy)
-)
-{
-
-	return true;
-}
-
-bool pFlow::AdamsBashforth4::correct
-(
+bool intAllActive(
 	real dt, 
-	realx3Vector_D& y,
-	realx3Vector_D& dy
-)
+	realx3Field_D& y, 
+	realx3PointField_D& dy,
+	realx3PointField_D& dy1,
+	realx3PointField_D& dy2,
+	realx3PointField_D& dy3,
+	real damping = 1.0)
 {
 
-	if(this->pStruct().allActive())
-	{
-		return intAll(dt, y, dy, this->pStruct().activeRange());
-	}
-	else
-	{
-		return intRange(dt, y, dy, this->pStruct().activePointsMaskD());
-	}
-
-	return true;
-}
-
-bool pFlow::AdamsBashforth4::setInitialVals(
-	const int32IndexContainer& newIndices,
-	const realx3Vector& y)
-{
-	return true;
-}
-
-bool pFlow::AdamsBashforth4::intAll(
-	real dt, 
-	realx3Vector_D& y, 
-	realx3Vector_D& dy, 
-	range activeRng)
-{
-	auto d_dy = dy.deviceViewAll();
-	auto d_y  = y.deviceViewAll();
-	auto d_history = history_.deviceViewAll();
+	auto d_dy = dy.deviceView();
+	auto d_y  = y.deviceView();
+	auto d_dy1= dy1.deviceView();
+	auto d_dy2= dy2.deviceView();
+	auto d_dy3= dy3.deviceView();
+	auto activeRng = dy1.activeRange();
 
 	Kokkos::parallel_for(
 		"AdamsBashforth4::correct",
-		rpIntegration (activeRng.first, activeRng.second),
-		LAMBDA_HD(int32 i){				
-			d_y[i] += dt*( 
+		rpIntegration (activeRng.start(), activeRng.end()),
+		LAMBDA_HD(uint32 i){
+			d_y[i] += damping * dt*( 
 				  static_cast<real>(55.0 / 24.0) * d_dy[i]
-					- static_cast<real>(59.0 / 24.0) * d_history[i].dy1_ 
-					+ static_cast<real>(37.0 / 24.0) * d_history[i].dy2_
-					- static_cast<real>( 9.0 / 24.0) * d_history[i].dy3_
-					);
-			d_history[i].dy3_ = d_history[i].dy2_;
-			d_history[i].dy2_ = d_history[i].dy1_;
-			d_history[i].dy1_ = d_dy[i];
-			
+				- static_cast<real>(59.0 / 24.0) * d_dy1[i] 
+				+ static_cast<real>(37.0 / 24.0) * d_dy2[i]
+				- static_cast<real>( 9.0 / 24.0) * d_dy3[i]);
 
+			d_dy3[i] = d_dy2[i];
+			d_dy2[i] = d_dy1[i];
+			d_dy1[i] = d_dy[i];
 		});
 	Kokkos::fence();
 
 	return true;	
 }
+
+bool intScattered
+(
+	real dt, 
+	realx3Field_D& y,
+	realx3PointField_D& dy,
+	realx3PointField_D& dy1,
+	realx3PointField_D& dy2,
+	realx3PointField_D& dy3,
+	real damping = 1.0
+)
+{
+
+	auto d_dy 		= dy.deviceView();
+	auto d_y  		= y.deviceView();
+	auto d_dy1		= dy1.deviceView();
+	auto d_dy2		= dy2.deviceView();
+	auto d_dy3		= dy3.deviceView();
+	auto activeRng 	= dy1.activeRange();
+	const auto& activeP = dy1.activePointsMaskDevice();
+
+	Kokkos::parallel_for(
+		"AdamsBashforth4::correct",
+		rpIntegration (activeRng.start(), activeRng.end()),
+		LAMBDA_HD(uint32 i){
+			if( activeP(i))
+			{
+				d_y[i] += damping*  dt*( 
+				  static_cast<real>(55.0 / 24.0) * d_dy[i]
+				- static_cast<real>(59.0 / 24.0) * d_dy1[i] 
+				+ static_cast<real>(37.0 / 24.0) * d_dy2[i]
+				- static_cast<real>( 9.0 / 24.0) * d_dy3[i] );
+				d_dy3[i] = d_dy2[i];
+				d_dy2[i] = d_dy1[i];
+				d_dy1[i] = d_dy[i];
+			}
+		});
+	Kokkos::fence();
+
+
+	return true;
+}
+
+}
+
+pFlow::AdamsBashforth4::AdamsBashforth4
+(
+	const word& baseName,
+	pointStructure& pStruct,
+	const word& method,
+	const realx3Field_D& initialValField
+)
+:
+	AdamsBashforth3(baseName, pStruct, method, initialValField),
+	dy3_
+	(
+		objectFile
+		(
+			groupNames(baseName,"dy3"),
+			pStruct.time().integrationFolder(),
+			objectFile::READ_IF_PRESENT,
+			objectFile::WRITE_ALWAYS
+		),
+		pStruct,
+		zero3,
+		zero3
+	)
+{}
+
+void pFlow::AdamsBashforth4::updateBoundariesSlaveToMasterIfRequested()
+{
+	AdamsBashforth3::updateBoundariesSlaveToMasterIfRequested();
+	dy3_.updateBoundariesSlaveToMasterIfRequested();
+}
+
+bool pFlow::AdamsBashforth4::correct
+(
+	real dt, 
+	realx3PointField_D& y, 
+	realx3PointField_D& dy,
+	real damping
+)
+{
+	
+	bool success = false;
+	if(y.isAllActive())
+	{
+		success = intAllActive(dt, y.field(), dy, dy1(), dy2(), dy3(), damping);
+	}
+	else
+	{
+		success = intScattered(dt, y.field(), dy, dy1(), dy2(), dy3(), damping);
+	}
+
+	success = success && boundaryList().correct(dt, y, dy);
+
+	return success;
+}
+
+bool pFlow::AdamsBashforth4::correctPStruct(
+	real dt, 
+	pointStructure &pStruct, 
+	realx3PointField_D &vel)
+{
+	
+	bool success = false;
+	if(dy2().isAllActive())
+	{
+		success = intAllActive(dt, pStruct.pointPosition(), vel, dy1(), dy2(), dy3());
+	}
+	else
+	{
+		success = intScattered(dt, pStruct.pointPosition(), vel, dy1(), dy2(), dy3());
+	}
+
+	success = success && boundaryList().correctPStruct(dt, pStruct, vel);
+
+	return success;
+}
+
+/*bool pFlow::AdamsBashforth4::hearChanges
+(
+	const timeInfo &ti, 
+	const message &msg, 
+	const anyList &varList
+)
+{
+	if(msg.equivalentTo(message::ITEMS_INSERT))
+	{
+		return insertValues(varList, initialValField().deviceViewAll(), dy1()) &&
+		insertValues(varList, initialValField().deviceViewAll(), dy2()) && 
+		insertValues(varList, initialValField().deviceViewAll(), dy3());
+	}
+	else
+	{
+		return realx3PointField_D::hearChanges(ti, msg, varList);
+	}
+}*/

src/Integration/AdamsBashforth4/AdamsBashforth4.hpp

@@ -22,53 +22,14 @@ Licence:
 #define __AdamsBashforth4_hpp__
 
 
-#include "integration.hpp"
+#include "AdamsBashforth3.hpp"
 #include "pointFields.hpp"
+#include "boundaryIntegrationList.hpp"
+
 
 namespace pFlow
 {
 
-struct AB4History
-{
-	TypeInfoNV("AB4History");
-
-	realx3 dy1_={0,0,0};
-	realx3 dy2_={0,0,0};
-	realx3 dy3_={0,0,0};
-	
-};
-
-
-INLINE_FUNCTION
-iIstream& operator>>(iIstream& str, AB4History& ab4)
-{
-	str.readBegin("AB4History");
-
-    str >> ab4.dy1_;
-    str >> ab4.dy2_;
-    str >> ab4.dy3_;
-    
-    str.readEnd("AB4History");
-
-    str.check(FUNCTION_NAME);
-
-	return str;
-	
-}
-
-INLINE_FUNCTION
-iOstream& operator<<(iOstream& str, const AB4History& ab4)
-{
-	str << token::BEGIN_LIST << ab4.dy1_
-	    << token::SPACE << ab4.dy2_
-	    << token::SPACE << ab4.dy3_
-		<< token::END_LIST;	    
-
-	str.check(FUNCTION_NAME);
-
-	return str;
-}
-
 /**
  * Fourth order Adams-Bashforth integration method for solving ODE
  * 
@@ -76,19 +37,25 @@ iOstream& operator<<(iOstream& str, const AB4History& ab4)
  */
 class AdamsBashforth4
 :
-	public integration
+	public AdamsBashforth3
 {
+private:
+
+	friend class processorAB4BoundaryIntegration;
+
+	realx3PointField_D 		dy3_;
+
 protected:
 
-	/// Integration history
-	pointField<VectorSingle,AB4History>& history_;
+	const auto& dy3()const
+	{
+		return dy3_;
+	}
 
-	/// Range policy for integration kernel
-	using rpIntegration = Kokkos::RangePolicy<
-			DefaultExecutionSpace,
-			Kokkos::Schedule<Kokkos::Static>,
-			Kokkos::IndexType<int32>
-			>;
+	auto& dy3()
+	{
+		return dy3_;
+	}
 
 public:
 
@@ -100,17 +67,14 @@ public:
 		/// Construct from components
 		AdamsBashforth4(
 			const word& baseName,
-			repository& owner,
-			const pointStructure& pStruct,
-			const word& method);
+			pointStructure& pStruct,
+			const word& method,
+			const realx3Field_D& initialValField);
+		
 		
-		uniquePtr<integration> clone()const override
-		{
-			return makeUnique<AdamsBashforth4>(*this);
-		}
 
 		/// Destructor
-		virtual ~AdamsBashforth4()=default;
+		~AdamsBashforth4() override =default;
 
 		/// Add a this to the virtual constructor table 
 		add_vCtor(
@@ -121,77 +85,36 @@ public:
 
 	// - Methods
 		
-		bool predict(
-			real UNUSED(dt),
-			realx3Vector_D & UNUSED(y),
-			realx3Vector_D& UNUSED(dy)) override;
+		void updateBoundariesSlaveToMasterIfRequested()override;
+
+		/// return integration method 
+		word method()const override
+		{
+			return "AdamsBashforth4";
+		}
 
 		bool correct(
 			real dt, 
-			realx3Vector_D & y,
-			realx3Vector_D& dy) override;
+			realx3PointField_D& y, 
+			realx3PointField_D& dy,
+			real damping = 1.0) override;
 
-		bool setInitialVals(
-			const int32IndexContainer& newIndices,
-			const realx3Vector& y) override;
-
-		bool needSetInitialVals()const override
-		{
-			return false;
-		}
-
-		/// Integrate on all points in the active range 
-		bool intAll(
+		bool correctPStruct(
 			real dt, 
-			realx3Vector_D& y, 
-			realx3Vector_D& dy, 
-			range activeRng);
+			pointStructure& pStruct, 
+			realx3PointField_D& vel) override;
 		
-		/// Integrate on active points in the active range 
-		template<typename activeFunctor>
-		bool intRange(
-			real dt,
-			realx3Vector_D& y,
-			realx3Vector_D& dy,
-			activeFunctor activeP );
+		/*bool hearChanges
+		(
+			const timeInfo& ti,
+			const message& msg, 
+			const anyList& varList
+		) override;*/
 
 };
 
 
-template<typename activeFunctor>
-bool pFlow::AdamsBashforth4::intRange(
-	real dt, 
-	realx3Vector_D& y,
-	realx3Vector_D& dy,
-	activeFunctor activeP )
-{
-	auto d_dy = dy.deviceViewAll();
-	auto d_y  = y.deviceViewAll();
-	auto d_history = history_.deviceViewAll();
-	auto activeRng = activeP.activeRange();
 
-	Kokkos::parallel_for(
-		"AdamsBashforth4::correct",
-		rpIntegration (activeRng.first, activeRng.second),
-		LAMBDA_HD(int32 i){
-			if( activeP(i))
-			{
-				
-				d_y[i] += dt*( 
-							static_cast<real>(55.0 / 24.0) * d_dy[i]
-						- static_cast<real>(59.0 / 24.0) * d_history[i].dy1_ 
-						+ static_cast<real>(37.0 / 24.0) * d_history[i].dy2_
-						- static_cast<real>( 9.0 / 24.0) * d_history[i].dy3_
-						);
-				d_history[i].dy3_ = d_history[i].dy2_;
-				d_history[i].dy2_ = d_history[i].dy1_;
-				d_history[i].dy1_ = d_dy[i];
-			}
-		});
-	Kokkos::fence();
-
-	return true;
-}
 
 } // pFlow
 

src/Integration/AdamsBashforth5/AdamsBashforth5.cpp

@@ -20,93 +20,178 @@ Licence:
 
 #include "AdamsBashforth5.hpp"
 
-
-
-pFlow::AdamsBashforth5::AdamsBashforth5
-(
-	const word& baseName,
-	repository& owner,
-	const pointStructure& pStruct,
-	const word& method
-)
-:
-	integration(baseName, owner, pStruct, method),
-	history_(
-		owner.emplaceObject<pointField<VectorSingle,AB5History>>(
-			objectFile(
-				groupNames(baseName,"AB5History"),
-				"",
-				objectFile::READ_IF_PRESENT,
-				objectFile::WRITE_ALWAYS),
-			pStruct,
-			AB5History({zero3,zero3, zero3})))
-
+namespace pFlow
 {
 
-}
+/// Range policy for integration kernel (alias)
+using rpIntegration = Kokkos::RangePolicy<
+		DefaultExecutionSpace,
+		Kokkos::Schedule<Kokkos::Static>,
+		Kokkos::IndexType<uint32>
+		>;
 
-bool pFlow::AdamsBashforth5::predict
-(
-	real UNUSED(dt),
-	realx3Vector_D& UNUSED(y),
-	realx3Vector_D& UNUSED(dy)
-)
-{
-
-	return true;
-}
-
-bool pFlow::AdamsBashforth5::correct
-(
+bool intAllActive(
 	real dt, 
-	realx3Vector_D& y,
-	realx3Vector_D& dy
-)
+	realx3Field_D& y, 
+	realx3PointField_D& dy,
+	realx3PointField_D& dy1,
+	realx3PointField_D& dy2,
+	realx3PointField_D& dy3,
+	realx3PointField_D& dy4,
+	real damping = 1.0)
 {
 
-	if(this->pStruct().allActive())
-	{
-		return intAll(dt, y, dy, this->pStruct().activeRange());
-	}
-	else
-	{
-		return intRange(dt, y, dy, this->pStruct().activePointsMaskD());
-	}
-
-	return true;
-}
-
-bool pFlow::AdamsBashforth5::setInitialVals(
-	const int32IndexContainer& newIndices,
-	const realx3Vector& y)
-{
-	return true;
-}
-
-bool pFlow::AdamsBashforth5::intAll(
-	real dt, 
-	realx3Vector_D& y, 
-	realx3Vector_D& dy, 
-	range activeRng)
-{
-	auto d_dy = dy.deviceViewAll();
-	auto d_y  = y.deviceViewAll();
-	auto d_history = history_.deviceViewAll();
+	auto d_dy = dy.deviceView();
+	auto d_y  = y.deviceView();
+	auto d_dy1= dy1.deviceView();
+	auto d_dy2= dy2.deviceView();
+	auto d_dy3= dy3.deviceView();
+	auto d_dy4= dy4.deviceView();
+	auto activeRng = dy1.activeRange();
 
 	Kokkos::parallel_for(
 		"AdamsBashforth5::correct",
-		rpIntegration (activeRng.first, activeRng.second),
-		LAMBDA_HD(int32 i){				
-			d_y[i] += dt*( 
+		rpIntegration (activeRng.start(), activeRng.end()),
+		LAMBDA_HD(uint32 i){
+			d_y[i] += damping*  dt*( 
 				  static_cast<real>(1901.0 / 720.0) * d_dy[i]
-				- static_cast<real>(2774.0 / 720.0) * d_history[i].dy1_ 
-				+ static_cast<real>(2616.0 / 720.0) * d_history[i].dy2_
-				- static_cast<real>(1274.0 / 720.0) * d_history[i].dy3_
-				+ static_cast<real>( 251.0 / 720.0) * d_history[i].dy4_
-				);
-			d_history[i] = {d_dy[i] ,d_history[i].dy1_, d_history[i].dy2_, d_history[i].dy3_};
+				- static_cast<real>(2774.0 / 720.0) * d_dy1[i]
+				+ static_cast<real>(2616.0 / 720.0) * d_dy2[i]
+				- static_cast<real>(1274.0 / 720.0) * d_dy3[i]
+				+ static_cast<real>( 251.0 / 720.0) * d_dy4[i]);
+				
+			d_dy4[i] = d_dy3[i];
+			d_dy3[i] = d_dy2[i];
+			d_dy2[i] = d_dy1[i];
+			d_dy1[i] = d_dy[i];
 		});
 	Kokkos::fence();
 
 	return true;	
 }
+
+bool intScattered
+(
+	real dt, 
+	realx3Field_D& y,
+	realx3PointField_D& dy,
+	realx3PointField_D& dy1,
+	realx3PointField_D& dy2,
+	realx3PointField_D& dy3,
+	realx3PointField_D& dy4,
+	real damping = 1.0
+)
+{
+
+	auto d_dy 		= dy.deviceView();
+	auto d_y  		= y.deviceView();
+	auto d_dy1		= dy1.deviceView();
+	auto d_dy2		= dy2.deviceView();
+	auto d_dy3		= dy3.deviceView();
+	auto d_dy4		= dy4.deviceView();
+	auto activeRng 	= dy1.activeRange();
+	const auto& activeP = dy1.activePointsMaskDevice();
+
+	Kokkos::parallel_for(
+		"AdamsBashforth5::correct",
+		rpIntegration (activeRng.start(), activeRng.end()),
+		LAMBDA_HD(uint32 i){
+			if( activeP(i))
+			{
+				d_y[i] += damping*  dt*( 
+				  static_cast<real>(1901.0 / 720.0) * d_dy[i]
+				- static_cast<real>(2774.0 / 720.0) * d_dy1[i]
+				+ static_cast<real>(2616.0 / 720.0) * d_dy2[i]
+				- static_cast<real>(1274.0 / 720.0) * d_dy3[i]
+				+ static_cast<real>( 251.0 / 720.0) * d_dy4[i]);
+
+				d_dy4[i] = d_dy3[i];
+				d_dy3[i] = d_dy2[i];
+				d_dy2[i] = d_dy1[i];
+				d_dy1[i] = d_dy[i];
+			}
+		});
+	Kokkos::fence();
+
+	return true;
+}
+
+}
+
+pFlow::AdamsBashforth5::AdamsBashforth5
+(
+	const word &baseName, 
+	pointStructure &pStruct, 
+	const word &method, 
+	const realx3Field_D &initialValField
+)
+:
+	AdamsBashforth4(baseName, pStruct, method, initialValField),
+	dy4_
+	(
+		objectFile
+		(
+			groupNames(baseName,"dy4"),
+			pStruct.time().integrationFolder(),
+			objectFile::READ_IF_PRESENT,
+			objectFile::WRITE_ALWAYS
+		),
+		pStruct,
+		zero3,
+		zero3
+	)
+{}
+
+void pFlow::AdamsBashforth5::updateBoundariesSlaveToMasterIfRequested()
+{
+	AdamsBashforth4::updateBoundariesSlaveToMasterIfRequested();
+	dy4_.updateBoundariesSlaveToMasterIfRequested();
+}
+
+bool pFlow::AdamsBashforth5::correct
+(
+	real dt, 
+	realx3PointField_D &y, 
+	realx3PointField_D &dy, 
+	real damping
+)
+{
+	
+	bool success = false;
+	if(y.isAllActive())
+	{
+		success = intAllActive(dt, y.field(), dy, dy1(), dy2(), dy3(), dy4(), damping);
+	}
+	else
+	{
+		success = intScattered(dt, y.field(), dy, dy1(), dy2(), dy3(), dy4(), damping);
+	}
+
+	success = success && boundaryList().correct(dt, y, dy);
+
+	return success;
+}
+
+bool pFlow::AdamsBashforth5::correctPStruct
+(
+	real dt, 
+	pointStructure &pStruct, 
+	realx3PointField_D &vel
+)
+{
+bool success = false;
+	if(dy2().isAllActive())
+	{
+		success = intAllActive(dt, pStruct.pointPosition(), vel, dy1(), dy2(), dy3(), dy4());
+	}
+	else
+	{
+		success = intScattered(dt, pStruct.pointPosition(), vel, dy1(), dy2(), dy3(), dy4());
+	}
+
+	success = success && boundaryList().correctPStruct(dt, pStruct, vel);
+
+	return success;
+}
+
+

src/Integration/AdamsBashforth5/AdamsBashforth5.hpp

@@ -22,54 +22,12 @@ Licence:
 #define __AdamsBashforth5_hpp__
 
 
-#include "integration.hpp"
+#include "AdamsBashforth4.hpp"
 #include "pointFields.hpp"
 
 namespace pFlow
 {
 
-struct AB5History
-{
-	TypeInfoNV("AB5History");
-
-	realx3 dy1_={0,0,0};
-	realx3 dy2_={0,0,0};
-	realx3 dy3_={0,0,0};
-	realx3 dy4_={0,0,0};
-};
-
-
-INLINE_FUNCTION
-iIstream& operator>>(iIstream& str, AB5History& ab5)
-{
-	str.readBegin("AB5History");
-
-    str >> ab5.dy1_;
-    str >> ab5.dy2_;
-    str >> ab5.dy3_;
-    str >> ab5.dy4_;
-    
-    str.readEnd("AB5History");
-
-    str.check(FUNCTION_NAME);
-
-	return str;
-	
-}
-
-INLINE_FUNCTION
-iOstream& operator<<(iOstream& str, const AB5History& ab5)
-{
-	str << token::BEGIN_LIST << ab5.dy1_
-	    << token::SPACE << ab5.dy2_
-	    << token::SPACE << ab5.dy3_
-	    << token::SPACE << ab5.dy4_
-		<< token::END_LIST;	    
-
-	str.check(FUNCTION_NAME);
-
-	return str;
-}
 
 /**
  * Fifth order Adams-Bashforth integration method for solving ODE
@@ -78,19 +36,25 @@ iOstream& operator<<(iOstream& str, const AB5History& ab5)
  */
 class AdamsBashforth5
 :
-	public integration
+	public AdamsBashforth4
 {
+private:
+
+	friend class processorAB4BoundaryIntegration;
+
+	realx3PointField_D 		dy4_;
+
 protected:
 
-	/// Integration history
-	pointField<VectorSingle,AB5History>& history_;
+	const auto& dy4()const
+	{
+		return dy4_;
+	}
 
-	/// Range policy for integration kernel
-	using rpIntegration = Kokkos::RangePolicy<
-			DefaultExecutionSpace,
-			Kokkos::Schedule<Kokkos::Static>,
-			Kokkos::IndexType<int32>
-			>;
+	auto& dy4()
+	{
+		return dy4_;
+	}
 
 public:
 
@@ -99,20 +63,19 @@ public:
 
 	// - Constructors
 		
+		/// Construct from components
 		AdamsBashforth5(
 			const word& baseName,
-			repository& owner,
-			const pointStructure& pStruct,
-			const word& method);
+			pointStructure& pStruct,
+			const word& method,
+			const realx3Field_D& initialValField);
 		
-		uniquePtr<integration> clone()const override
-		{
-			return makeUnique<AdamsBashforth5>(*this);
-		}
 		
-		virtual ~AdamsBashforth5()=default;
 
-		/// Add this to the virtual constructor table 
+		/// Destructor
+		~AdamsBashforth5() override =default;
+
+		/// Add a this to the virtual constructor table 
 		add_vCtor(
 			integration,
 			AdamsBashforth5,
@@ -121,44 +84,29 @@ public:
 
 	// - Methods
 		
-		bool predict(
-			real UNUSED(dt),
-			realx3Vector_D & UNUSED(y),
-			realx3Vector_D& UNUSED(dy)) override;
+		void updateBoundariesSlaveToMasterIfRequested()override;
+
+		/// return integration method 
+		word method()const override
+		{
+			return "AdamsBashforth5";
+		}
 
 		bool correct(
 			real dt, 
-			realx3Vector_D & y,
-			realx3Vector_D& dy) override;
+			realx3PointField_D& y, 
+			realx3PointField_D& dy,
+			real damping = 1.0) override;
 
-		bool setInitialVals(
-			const int32IndexContainer& newIndices,
-			const realx3Vector& y) override;
-
-		bool needSetInitialVals()const override
-		{
-			return false;
-		}
-
-		/// Integrate on all points in the active range 
-		bool intAll(
+		bool correctPStruct(
 			real dt, 
-			realx3Vector_D& y, 
-			realx3Vector_D& dy, 
-			range activeRng);
-
-		/// Integrate on active points in the active range 
-		template<typename activeFunctor>
-		bool intRange(
-			real dt,
-			realx3Vector_D& y,
-			realx3Vector_D& dy,
-			activeFunctor activeP );
+			pointStructure& pStruct, 
+			realx3PointField_D& vel) override;
 
 };
 
 
-template<typename activeFunctor>
+/*template<typename activeFunctor>
 bool pFlow::AdamsBashforth5::intRange(
 	real dt, 
 	realx3Vector_D& y,
@@ -190,7 +138,7 @@ bool pFlow::AdamsBashforth5::intRange(
 	Kokkos::fence();
 
 	return true;
-}
+}*/
 
 } // pFlow
 

src/Integration/CMakeLists.txt

@@ -4,9 +4,10 @@ integration/integration.cpp
 boundaries/boundaryIntegration.cpp
 boundaries/boundaryIntegrationList.cpp 
 AdamsBashforth2/AdamsBashforth2.cpp
-#AdamsBashforth5/AdamsBashforth5.cpp
-#AdamsBashforth4/AdamsBashforth4.cpp
-#AdamsBashforth3/AdamsBashforth3.cpp
+AdamsBashforth3/AdamsBashforth3.cpp
+AdamsBashforth4/AdamsBashforth4.cpp
+AdamsBashforth5/AdamsBashforth5.cpp
+
 #AdamsMoulton3/AdamsMoulton3.cpp
 #AdamsMoulton4/AdamsMoulton4.cpp
 #AdamsMoulton5/AdamsMoulton5.cpp

src/Integration/boundaries/boundaryIntegration.hpp

@@ -51,9 +51,7 @@ public:
     );
 
     bool hearChanges(
-        real t,
-        real dt,
-        uint32 iter,
+        const timeInfo& ti,
         const message &msg,
         const anyList &varList) override
     {
@@ -77,6 +75,11 @@ public:
         return true;
     }
 
+    bool isActive()const override
+    {
+        return false;
+    }
+    
     static
     uniquePtr<boundaryIntegration> create(
         const boundaryBase& boundary,

src/Integration/boundaries/boundaryIntegrationList.cpp

@@ -7,11 +7,11 @@ pFlow::boundaryIntegrationList::boundaryIntegrationList(
     integration &intgrtn
 )
 :
-    ListPtr<boundaryIntegration>(6),
+    boundaryListPtr<boundaryIntegration>(),
 	boundaries_(pStruct.boundaries())
 {
 	
-    for(uint32 i=0; i<6; i++)
+	ForAllBoundariesPtr(i, this)
 	{
 		this->set(
 			i,
@@ -23,20 +23,18 @@ pFlow::boundaryIntegrationList::boundaryIntegrationList(
 			)
 		);
 	}	
-
 }
 
 bool pFlow::boundaryIntegrationList::correct(real dt, realx3PointField_D &y, realx3PointField_D &dy)
 {
-	for(auto& bndry:*this)
+	ForAllActiveBoundariesPtr(i,this)
 	{
-		if(!bndry->correct(dt, y, dy))
+		if(!boundaryPtr(i)->correct(dt, y, dy))
 		{
 			fatalErrorInFunction<<"Error in correcting boundary "<<
-			bndry->boundaryName()<<endl;
+			boundaryPtr(i)->boundaryName()<<endl;
 			return false;
 		}
-		
 	}
     return true;
 }
@@ -46,14 +44,15 @@ bool pFlow::boundaryIntegrationList::correctPStruct(
 	pointStructure &pStruct, 
 	const realx3PointField_D &vel)
 {
-	for(auto& bndry:*this)
+	ForAllActiveBoundariesPtr(i,this)
 	{
-		if(!bndry->correctPStruct(dt, vel))
+		if(!boundaryPtr(i)->correctPStruct(dt, vel))
 		{
 			fatalErrorInFunction<<"Error in correcting boundary "<<
-			bndry->boundaryName()<<" in pointStructure."<<endl;
+			boundaryPtr(i)->boundaryName()<<" in pointStructure."<<endl;
 			return false;
 		}
 	}
+	
     return true;
 }

src/Integration/boundaries/boundaryIntegrationList.hpp

@@ -4,7 +4,7 @@
 
 
 #include "boundaryList.hpp"
-#include "ListPtr.hpp"
+#include "boundaryListPtr.hpp"
 #include "boundaryIntegration.hpp"
 
 
@@ -15,7 +15,7 @@ class integration;
 
 class boundaryIntegrationList
 :
-    public ListPtr<boundaryIntegration>
+    public boundaryListPtr<boundaryIntegration>
 {
 private:
 

src/Integration/integration/integration.cpp

@@ -22,15 +22,37 @@ Licence:
 #include "pointStructure.hpp"
 #include "repository.hpp"
 
-pFlow::integration::integration
+bool pFlow::integration::insertValues
 (
-	const word& baseName,
-	pointStructure& pStruct,
-	const word&,
-	const realx3Field_D&
+	const anyList& varList, 
+	const deviceViewType1D<realx3>& srcVals,
+	realx3PointField_D& dstFeild
 )
-:
-	owner_(*pStruct.owner()),
+{
+	const word eventName = message::eventName(message::ITEMS_INSERT);
+
+	if(!varList.checkObjectType<uint32IndexContainer>(eventName))
+	{
+		fatalErrorInFunction<<"Insertion failed in integration for "<< baseName_<<
+		", variable "<< eventName <<
+		" does not exist or the type is incorrect"<<endl;
+		return false;
+	}
+
+	const auto& indices = varList.getObject<uint32IndexContainer>(
+		eventName);
+	
+	dstFeild.field().insertSetElement(indices, srcVals);
+
+    return true;
+}
+
+pFlow::integration::integration(
+    const word &baseName,
+    pointStructure &pStruct,
+    const word &,
+    const realx3Field_D &)
+    : owner_(*pStruct.owner()),
       pStruct_(pStruct),
       baseName_(baseName)
 {}

src/Integration/integration/integration.hpp

@@ -63,6 +63,13 @@ private:
 		/// The base name for integration 
 		const word baseName_;
 
+protected:
+
+	bool insertValues(
+		const anyList& varList, 
+		const deviceViewType1D<realx3>& srcVals,
+		realx3PointField_D& dstFeild);
+
 public:
 
 	/// Type info
@@ -146,22 +153,11 @@ public:
 
 		/// Correction/main integration step
 		virtual 
-		bool correct(real dt, realx3PointField_D& y, realx3PointField_D& dy) = 0;
+		bool correct(real dt, realx3PointField_D& y, realx3PointField_D& dy, real damping = 1.0) = 0;
 
 		virtual 
 		bool correctPStruct(real dt, pointStructure& pStruct, realx3PointField_D& vel) = 0;
 
-		/// Set the initial values for new indices 
-		virtual 
-		bool setInitialVals(
-				const int32IndexContainer& newIndices,
-				const realx3Vector& y) = 0;
-
-		/// Check if the method requires any set initial vals
-		virtual 
-		bool needSetInitialVals()const = 0;
-
-
 	/// Create the polymorphic object based on inputs
 	static
 		uniquePtr<integration> create(

src/Interaction/Models/contactForce/cGAbsoluteLinearCF.hpp

@@ -25,12 +25,6 @@ Licence:
 #include "symArrays.hpp"
 
 
-
-
-
-
-
-
 namespace pFlow::cfModels
 {
 
@@ -159,7 +153,7 @@ protected:
 		{
 
 			etha_t[i] = -2.0*log( et[i])*sqrt(kt[i]*2/7) /
-					sqrt(log(pow(et[i],2.0))+ pow(Pi,2.0));
+					sqrt(log(pow(et[i],2))+ pow(Pi,2));
 		}
 
 		Vector<linearProperties> prop("prop", nElem);
@@ -285,8 +279,8 @@ public:
 
 		history.overlap_t_ += Vt*dt;
 
-		real mi = 3*Pi/4*pow(Ri,3.0)*rho_[propId_i];
-		real mj = 3*Pi/4*pow(Rj,3.0)*rho_[propId_j];
+		real mi = 3*Pi/4*pow(Ri,3)*rho_[propId_i];
+		real mj = 3*Pi/4*pow(Rj,3)*rho_[propId_j];
 
 		real sqrt_meff = sqrt((mi*mj)/(mi+mj));
 
@@ -299,29 +293,24 @@ public:
 		else if (addDissipationModel_==3)
 		{
 			auto pie =3.14;
-			prop.en_ = exp((pow(f_,1.5)*log(prop.en_)*sqrt( (1-((pow(log(prop.en_),2))/(pow(log(prop.en_),2)+pow(pie,2))))/(1-(pow(f_,3)*(pow(log(prop.en_),2))/(pow(log(prop.en_),2)+pow(pie,2)))) ) ));
+			prop.en_ = exp((pow(f_,static_cast<real>(1.5))*log(prop.en_)*sqrt( (1-((pow(log(prop.en_),2))/(pow(log(prop.en_),2)+pow(pie,2))))/(1-(pow(f_,3)*(pow(log(prop.en_),2))/(pow(log(prop.en_),2)+pow(pie,2)))) ) ));
 		}
 
-
-
-
 		real ethan_  = -2.0*log(prop.en_)*sqrt(prop.kn_)/
-					sqrt(pow(log(prop.en_),2.0)+ pow(Pi,2.0));
+					sqrt(pow(log(prop.en_),2)+ pow(Pi,2));
 
 			//REPORT(0)<<"\n en n is  :  "<<END_REPORT;
 			//REPORT(0)<< prop.en_ <<END_REPORT;
 
-		FCn = (  -pow(f_,3.0)*prop.kn_ * ovrlp_n - sqrt_meff * pow(f_,1.5) * ethan_ * vrn)*Nij;
-		FCt = ( -pow(f_,3.0)*prop.kt_ * history.overlap_t_ - sqrt_meff * pow(f_,1.5) *  prop.ethat_*Vt);
-		
-
+		FCn = (  -pow(f_,3)*prop.kn_ * ovrlp_n - sqrt_meff * pow(f_,static_cast<real>(1.5)) * ethan_ * vrn)*Nij;
+		FCt = ( -pow(f_,3)*prop.kt_ * history.overlap_t_ - sqrt_meff * pow(f_,static_cast<real>(1.5)) *  prop.ethat_*Vt);
 				
 		real ft = length(FCt);
 		real ft_fric = prop.mu_ * length(FCn);
 		
 		if(ft > ft_fric)
 		{
-			if( length(history.overlap_t_) >static_cast<real>(0.0))
+			if( length(history.overlap_t_) >zero)
 			{
 				if constexpr (limited)
 				{

src/Interaction/Models/contactForce/cGNonLinearCF.hpp

@@ -0,0 +1,307 @@
+/*------------------------------- 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 __cGNonLinearCF_hpp__
+#define __cGNonLinearCF_hpp__
+
+#include "types.hpp"
+
+namespace pFlow::cfModels
+{
+
+template<bool limited=true>
+class cGNonLinear
+{
+public:
+
+	struct contactForceStorage
+	{
+		realx3 overlap_t_ = 0.0;
+	};
+
+	struct cGNonLinearProperties
+	{		
+		real 	Yeff_	= 1000000.0;
+		real 	Geff_	= 8000000.0;
+		real 	en_ 	= 1.0;
+		real  	mu_ 	= 0.00001;
+
+		INLINE_FUNCTION_HD
+		cGNonLinearProperties(){}
+
+		INLINE_FUNCTION_HD
+		cGNonLinearProperties(real Yeff, real Geff, real en, real mu ):
+			Yeff_(Yeff), Geff_(Geff), en_(en), mu_(mu)
+		{}		
+
+		INLINE_FUNCTION_HD
+		cGNonLinearProperties(const cGNonLinearProperties&)=default;
+
+		INLINE_FUNCTION_HD
+		cGNonLinearProperties& operator=(const cGNonLinearProperties&)=default;
+
+		INLINE_FUNCTION_HD
+		~cGNonLinearProperties() = default;
+	};
+
+protected:
+
+	using cGNonLinearArrayType = 	symArray<cGNonLinearProperties>;
+
+	int32 						numMaterial_ = 0;
+
+	ViewType1D<real>  		 	rho_;
+
+	int32 						addDissipationModel_;
+
+	cGNonLinearArrayType  		nonlinearProperties_;
+
+	bool readNonLinearDictionary(const dictionary& dict)
+	{
+		auto Yeff = dict.getVal<realVector>("Yeff");
+		auto Geff = dict.getVal<realVector>("Geff");
+		auto nu = dict.getVal<realVector>("nu");
+		auto en = dict.getVal<realVector>("en");
+		auto mu = dict.getVal<realVector>("mu");
+
+		auto nElem = Yeff.size();
+
+		if(nElem != nu.size())
+		{
+			fatalErrorInFunction<<
+			"sizes of Yeff("<<nElem<<") and nu("<<nu.size()<<") do not match.\n";
+			return false;
+		}
+
+		if(nElem != en.size())
+		{
+			fatalErrorInFunction<<
+			"sizes of Yeff("<<nElem<<") and en("<<en.size()<<") do not match.\n";
+			return false;
+		}
+
+
+		if(nElem != mu.size())
+		{
+			fatalErrorInFunction<<
+			"sizes of Yeff("<<nElem<<") and mu("<<mu.size()<<") do not match.\n";
+			return false;
+		}
+
+		
+		// check if size of vector matchs a symetric array
+		uint32 nMat;
+		if( !cGNonLinearArrayType::getN(nElem, nMat) )
+		{
+			fatalErrorInFunction<<
+			"sizes of properties do not match a symetric array with size ("<<
+			numMaterial_<<"x"<<numMaterial_<<").\n";
+			return false;
+		}
+		else if( numMaterial_ != nMat)
+		{
+			fatalErrorInFunction<<
+			"size mismatch for porperties. \n";
+			return false;
+		}
+
+		Vector<cGNonLinearProperties> prop("prop",nElem);
+		ForAll(i,Yeff)
+		{
+			prop[i] = {Yeff[i], Geff[i], en[i], mu[i]};
+		}
+
+		nonlinearProperties_.assign(prop);
+
+		auto adm = dict.getVal<word>("additionalDissipationModel");
+		if(adm == "none")
+		{
+			addDissipationModel_ = 1;
+		}
+		else if(adm == "LU")
+		{
+			addDissipationModel_ = 2;
+		}
+		else if (adm == "GB")
+		{
+			addDissipationModel_ = 3;
+		}
+		else
+		{
+			addDissipationModel_ = 1;
+		}
+
+		return true;
+
+	}
+
+	static const char* modelName()
+	{
+		if constexpr (limited)
+		{
+			return "cGNonLinearLimited";
+		}
+		else
+		{
+			return "cGNonLinearNonLimited";
+		}
+		return "";
+	}
+
+public:
+
+	TypeInfoNV(modelName());
+
+	INLINE_FUNCTION_HD
+	cGNonLinear(){}
+
+	cGNonLinear(
+		int32 nMaterial,
+		const ViewType1D<real>& rho,
+		const dictionary& dict)
+	:
+		numMaterial_(nMaterial),
+		rho_("rho",nMaterial),
+		nonlinearProperties_("cGNonLinearProperties",nMaterial)
+	{
+
+		Kokkos::deep_copy(rho_,rho);
+		if(!readNonLinearDictionary(dict))
+		{
+			fatalExit;
+		}
+	}
+	
+	INLINE_FUNCTION_HD
+	cGNonLinear(const cGNonLinear&) = default;
+
+	INLINE_FUNCTION_HD
+	cGNonLinear(cGNonLinear&&) = default;
+
+	INLINE_FUNCTION_HD
+	cGNonLinear& operator=(const cGNonLinear&) = default;
+
+	INLINE_FUNCTION_HD
+	cGNonLinear& operator=(cGNonLinear&&) = default;
+
+
+	INLINE_FUNCTION_HD
+	~cGNonLinear()=default;
+
+	INLINE_FUNCTION_HD
+	int32 numMaterial()const
+	{
+		return numMaterial_;
+	}
+
+	//// - Methods
+
+	INLINE_FUNCTION_HD
+	void contactForce
+	(
+		const real dt,
+		const uint32 i,
+		const uint32 j,
+		const uint32 propId_i,
+		const uint32 propId_j,
+		const real Ri,
+		const real Rj,
+		const real cGFi,
+		const real cGFj,
+		const real ovrlp_n,
+		const realx3& Vr,
+		const realx3& Nij,
+		contactForceStorage& history,
+		realx3& FCn,
+		realx3& FCt
+	)const
+	{
+
+		const auto prop = nonlinearProperties_(propId_i,propId_j);
+
+		const real f = 2/( 1/cGFi + 1/cGFj );
+
+		real vrn = dot(Vr, Nij);	
+		realx3 Vt = Vr - vrn*Nij;
+
+		history.overlap_t_ += Vt*dt;
+
+		real mi = 3*Pi/4*pow(Ri,static_cast<real>(3))*rho_[propId_i];
+		real mj = 3*Pi/4*pow(Rj,static_cast<real>(3))*rho_[propId_j];
+		real Reff = 1/(1/Ri + 1/Rj);
+
+		real K_hertz = 4.0/3.0*prop.Yeff_*sqrt(Reff);
+		real sqrt_meff_K_hertz = sqrt((mi*mj)/(mi+mj) * K_hertz);
+
+		real en = prop.en_;
+		if (addDissipationModel_==2)
+		{
+			en = sqrt(1+((pow(prop.en_,2)-1)*f));
+		}
+		else if (addDissipationModel_==3)
+		{
+			
+			en = exp((pow(f,static_cast<real>(1.5))*log(prop.en_)*sqrt( (1-((pow(log(prop.en_),2))/(pow(log(prop.en_),2)+pow(Pi,2))))/(1-(pow(f,3)*(pow(log(prop.en_),2))/(pow(log(prop.en_),2)+pow(Pi,2)))) ) ));
+		}
+		
+		real Kn = static_cast<real>(4.0/3.0) * prop.Yeff_ * sqrt(Reff*ovrlp_n);
+
+		real ethan_  = -2.0*log(en)*sqrt(Kn)/
+			sqrt(pow(log(en),2)+ pow(Pi,2));
+
+		FCn = ( - Kn*ovrlp_n - 
+			   sqrt_meff_K_hertz*ethan_*pow(ovrlp_n,static_cast<real>(0.25))*vrn)*Nij;
+
+		FCt = (f*f)*(- static_cast<real>(8.0) * prop.Geff_ * sqrt(Reff*ovrlp_n) ) * history.overlap_t_;
+
+		real ft = length(FCt);
+		real ft_fric = prop.mu_ * length(FCn);
+
+		// apply friction 
+		if(ft > ft_fric)
+		{
+			if( length(history.overlap_t_) >0.0)
+			{
+				if constexpr (limited)
+				{
+					real kt = static_cast<real>(8.0) * prop.Geff_ * sqrt(Reff*ovrlp_n);
+					FCt *= (ft_fric/ft);
+                	history.overlap_t_ = - FCt/(f*f*kt);
+				}
+				else
+				{
+					FCt = (FCt/ft)*ft_fric;	
+				}
+				
+			}
+			else
+			{
+				FCt = 0.0;
+			}
+		}
+
+	}
+   
+
+};
+
+} //pFlow::CFModels
+
+#endif

src/Interaction/Models/contactForce/cGRelativeLinearCF.hpp

@@ -26,11 +26,6 @@ Licence:
 
 
 
-
-
-
-
-
 namespace pFlow::cfModels
 {
 
@@ -49,16 +44,15 @@ public:
 	{		
 		real 	kn_ 	= 1000.0;
 		real 	kt_	= 800.0;
-		real 	en_ 	= 0.0;
-		real 	ethat_ 	= 0.0;
+		real 	en_ 	= 1.0;
 		real  mu_ 	= 0.00001;
 
 		INLINE_FUNCTION_HD
 		linearProperties(){}
 
 		INLINE_FUNCTION_HD
-		linearProperties(real kn, real kt, real en, real etha_t, real mu  ):
-			kn_(kn), kt_(kt), en_(en),ethat_(etha_t), mu_(mu)
+		linearProperties(real kn, real kt, real en, real mu  ):
+			kn_(kn), kt_(kt), en_(en), mu_(mu)
 		{}		
 
 		INLINE_FUNCTION_HD
@@ -93,7 +87,6 @@ protected:
 		auto kn = dict.getVal<realVector>("kn");
 		auto kt = dict.getVal<realVector>("kt");
 		auto en = dict.getVal<realVector>("en");
-		auto et = dict.getVal<realVector>("et");
 		auto mu = dict.getVal<realVector>("mu");
 		
 
@@ -114,12 +107,6 @@ protected:
 			return false;
 		}
 
-		if(nElem != et.size())
-		{
-			fatalErrorInFunction<<
-			"sizes of kn("<<nElem<<") and et("<<et.size()<<") do not match.\n";
-			return false;
-		}
 
 		if(nElem != mu.size())
 		{
@@ -148,30 +135,16 @@ protected:
 		}
 
 
-		realVector etha_t("etha_t", nElem);
-
-
-		ForAll(i , kn)
-		{
-
-
-			etha_t[i] = -2.0*log( et[i])*sqrt(kt[i]*2/7) /
-					sqrt(log(pow(et[i],2.0))+ pow(Pi,2.0));
-					
-					
-		}
-
 		Vector<linearProperties> prop("prop", nElem);
 		ForAll(i,kn)
 		{
-			prop[i] = {kn[i], kt[i], en[i], etha_t[i], mu[i]  };
+			prop[i] = {kn[i], kt[i], en[i], mu[i]  };
 		}
 
 		linearProperties_.assign(prop);
 		
+
 		auto adm = dict.getVal<word>("additionalDissipationModel");
-
-		
 		if(adm == "none")
 		{
 			addDissipationModel_ = 1;
@@ -282,27 +255,40 @@ public:
 
 		history.overlap_t_ += Vt*dt;
 
-		real mi = 3*Pi/4*pow(Ri,3.0)*rho_[propId_i];
-		real mj = 3*Pi/4*pow(Rj,3.0)*rho_[propId_j];
+		real mi = 3*Pi/4*pow(Ri,3)*rho_[propId_i];
+		real mj = 3*Pi/4*pow(Rj,3)*rho_[propId_j];
 
 		real sqrt_meff = sqrt((mi*mj)/(mi+mj));
 		
-		
+		real en = prop.en_;
 		if (addDissipationModel_==2)
 		{
-			prop.en_ = sqrt(1+((pow(prop.en_,2)-1)*f_));
+			en = sqrt(1+((pow(prop.en_,2)-1)*f_));
 		}
 		else if (addDissipationModel_==3)
 		{
-			auto pie =3.14;
-			prop.en_ = exp((pow(f_,1.5)*log(prop.en_)*sqrt( (1-((pow(log(prop.en_),2))/(pow(log(prop.en_),2)+pow(pie,2))))/(1-(pow(f_,3)*(pow(log(prop.en_),2))/(pow(log(prop.en_),2)+pow(pie,2)))) ) ));
+			
+			en = exp(
+				(
+					pow(f_,static_cast<real>(1.5))*
+					log(prop.en_)*
+					sqrt( 
+						(1-((pow(log(prop.en_),static_cast<real>(2.0))
+						)/
+						(
+							pow(log(prop.en_),static_cast<real>(2.0))+
+							pow(Pi,static_cast<real>(2.0)))))/
+							(1-(pow(f_,3)*(pow(log(prop.en_),2))/
+							(pow(log(prop.en_),static_cast<real>(2.0))+
+							pow(Pi,static_cast<real>(2.0))))) ) ));
 		}
-		real ethan_  = -2.0*log(prop.en_)*sqrt(prop.kn_)/
-			sqrt(pow(log(prop.en_),2.0)+ pow(Pi,2.0));
+
+		real ethan_  = -2.0*log(en)*sqrt(prop.kn_)/
+			sqrt(pow(log(en),2)+ pow(Pi,2));
 		
 
-		FCn = (  -pow(f_,1.0)*prop.kn_ * ovrlp_n - sqrt_meff * pow(f_,0.5) * ethan_ * vrn)*Nij;
-		FCt = ( -pow(f_,1.0)*prop.kt_ * history.overlap_t_ - sqrt_meff * pow(f_,0.5) *  prop.ethat_*Vt);
+		FCn = ( -f_*prop.kn_ * ovrlp_n - sqrt_meff * pow(f_,half) * ethan_ * vrn)*Nij;
+		FCt = ( -f_*prop.kt_ * history.overlap_t_);
 		
 
 		

src/Interaction/Models/contactForce/linearCF.hpp

@@ -139,10 +139,10 @@ protected:
 		ForAll(i , kn)
 		{
 			etha_n[i] = -2.0*log(en[i])*sqrt(kn[i])/
-					sqrt(pow(log(en[i]),2.0)+ pow(Pi,2.0));
+					sqrt(pow(log(en[i]),static_cast<real>(2.0))+ pow(Pi,static_cast<real>(2.0)));
 
 			etha_t[i] = -2.0*log( et[i]*sqrt(kt[i]) )/
-					sqrt(pow(log(et[i]),2.0)+ pow(Pi,2.0));
+					sqrt(pow(log(et[i]),static_cast<real>(2.0))+ pow(Pi,static_cast<real>(2.0)));
 		}
 
 		Vector<linearProperties> prop("prop", nElem);
@@ -243,8 +243,8 @@ public:
 
 		history.overlap_t_ += Vt*dt;
 
-		real mi = 3*Pi/4*pow(Ri,3.0)*rho_[propId_i];
-		real mj = 3*Pi/4*pow(Rj,3.0)*rho_[propId_j];
+		real mi = 3*Pi/4*pow(Ri,static_cast<real>(3.0))*rho_[propId_i];
+		real mj = 3*Pi/4*pow(Rj,static_cast<real>(3.0))*rho_[propId_j];
 
 		real sqrt_meff = sqrt((mi*mj)/(mi+mj));
 

src/Interaction/Models/contactForce/nonLinearCF.hpp

@@ -131,7 +131,7 @@ protected:
 			// we take out sqrt(meff*K_hertz) here and then consider this term 
 			// when calculating damping part. 
 			etha_n[i] = -2.2664*log(en[i])/
-					sqrt(pow(log(en[i]),2.0)+ pow(Pi,2.0));
+					sqrt(pow(log(en[i]),static_cast<real>(2.0))+ pow(Pi,static_cast<real>(2.0)));
 
 			// no damping for tangential part 
 
@@ -255,7 +255,7 @@ public:
 		// apply friction 
 		if(ft > ft_fric)
 		{
-			if( length(history.overlap_t_) >0.0)
+			if( length(history.overlap_t_) >zero)
 			{
 				if constexpr (limited)
 				{

src/Interaction/Models/grainContactForceModels.hpp

@@ -23,6 +23,7 @@ Licence:
 
 #include "cGAbsoluteLinearCF.hpp"
 #include "cGRelativeLinearCF.hpp"
+#include "cGNonLinearCF.hpp"
 
 #include "grainRolling.hpp"
 
@@ -38,6 +39,10 @@ using nonLimitedCGAbsoluteLinearGrainRolling = grainRolling<cGAbsoluteLinear<fal
 using limitedCGRelativeLinearGrainRolling   = grainRolling<cGRelativeLinear<true>>;
 using nonLimitedCGRelativeLinearGrainRolling = grainRolling<cGRelativeLinear<false>>;
 
+using limitedCGNonLinearGrainRolling   = grainRolling<cGNonLinear<true>>;
+using nonLimitedCGNonLinearGrainRolling = grainRolling<cGNonLinear<false>>;
+
+
 }
 
 

src/Interaction/Models/rolling/grainRolling.hpp

@@ -96,10 +96,10 @@ public:
 		realx3 w_hat = wi-wj;
 		real w_hat_mag = length(w_hat);
 
-		if( !equal(w_hat_mag,0.0) )
+		if( !equal(w_hat_mag,static_cast<real>(0.0)) )
 			w_hat /= w_hat_mag;
 		else
-			w_hat = 0.0;
+			w_hat = static_cast<real>(0.0);
 
 		auto Reff = (Ri*Rj)/(Ri+Rj);
 

src/Interaction/Models/rolling/normalRolling.hpp

@@ -94,10 +94,10 @@ public:
 		realx3 w_hat = wi-wj;
 		real w_hat_mag = length(w_hat);
 
-		if( !equal(w_hat_mag,0.0) )
+		if( !equal(w_hat_mag,static_cast<real>(0.0)) )
 			w_hat /= w_hat_mag;
 		else
-			w_hat = 0.0;
+			w_hat = static_cast<real>(0.0);
 
 		auto Reff = (Ri*Rj)/(Ri+Rj);
 

src/Interaction/contactSearch/ContactSearch/ContactSearch.hpp

@@ -60,9 +60,9 @@ private:
 		bool force = false) override
 	{
 		
-		const auto& position = Particles().pointPosition().deviceViewAll();
-		const auto& flags = Particles().dynPointStruct().activePointsMaskDevice();
-		const auto& diam = Particles().boundingSphere().deviceViewAll();
+		auto position = Particles().pointPosition().deviceViewAll();
+		auto flags = Particles().dynPointStruct().activePointsMaskDevice();
+		auto diam = Particles().boundingSphere().deviceViewAll();
 
 		return ppwContactSearch_().broadSearch(
 			ti.iter(),
@@ -134,7 +134,7 @@ public:
 		ppwContactSearch_ = 
 			makeUnique<SearchMethodType>
 			(
-				dict(),
+				csDict,
 				this->extendedDomainBox(),
 				minD,
 				maxD,
@@ -154,10 +154,8 @@ public:
 		ContactSearch,
 		dictionary);
 
-	bool enterBroadSearchBoundary(const timeInfo& ti, bool force=false)const override
-	{
-		return enterBroadSearch(ti, force) || csBoundaries_.boundariesUpdated();
-	}
+	bool enterBroadSearchBoundary(const timeInfo& ti, bool force=false)const override;
+	
 
 	real sizeRatio()const override
 	{
@@ -171,7 +169,12 @@ public:
 	
 };
 
+template <class searchMethod>
+inline bool ContactSearch<searchMethod>::enterBroadSearchBoundary(const timeInfo &ti, bool force) const
+{
+	return performSearch(ti.iter(),force) || csBoundaries_.boundariesUpdated();
 }
 
+}
 
 #endif //__ContactSearch_hpp__

src/Interaction/contactSearch/boundaries/boundaryContactSearch/boundaryContactSearch.hpp

@@ -73,9 +73,7 @@ public:
     }
 
     bool hearChanges(
-        real t,
-        real dt,
-        uint32 iter,
+        const timeInfo& ti,
         const message &msg,
         const anyList &varList) override
     {
@@ -83,9 +81,11 @@ public:
         if (msg.equivalentTo(message::BNDR_RESET))
         {
             // do nothing
-        }
             return true;
         }
+        fatalErrorInFunction;
+        return false;
+    }
 
     virtual bool broadSearch(
         uint32 iter,
@@ -98,6 +98,11 @@ public:
         return true;
     }
 
+    bool isActive()const override
+    {
+        return false;
+    }
+
     static uniquePtr<boundaryContactSearch> create(
         const dictionary &dict,
         const boundaryBase &boundary,

src/Interaction/contactSearch/boundaries/boundaryContactSearchList.cpp

@@ -1,3 +1,23 @@
+/*------------------------------- 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.
+
+-----------------------------------------------------------------------------*/
+
 #include "boundaryContactSearchList.hpp"
 #include "boundaryList.hpp"
 
@@ -5,7 +25,7 @@ void pFlow::boundaryContactSearchList::setList(
     const dictionary &dict, 
     const contactSearch &cSearch)
 {
-    for(auto i=0; i<boundaries_.size(); i++)
+    ForAllBoundariesPtr(i, this)
     {
         this->set
         (
@@ -20,7 +40,7 @@ pFlow::boundaryContactSearchList::boundaryContactSearchList(
     const boundaryList& bndrs,
     const contactSearch &cSearch)
     :
-    ListPtr(bndrs.size()), 
+    boundaryListPtr(), 
     boundaries_(bndrs)
 {
     setList(dict, cSearch);

src/Interaction/contactSearch/boundaries/boundaryContactSearchList.hpp

@@ -1,4 +1,24 @@
-#include "ListPtr.hpp"
+/*------------------------------- 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.
+
+-----------------------------------------------------------------------------*/
+
+#include "boundaryListPtr.hpp"
 #include "boundaryContactSearch.hpp"
 
 namespace pFlow
@@ -9,7 +29,7 @@ class contactSearch;
 
 class boundaryContactSearchList
 :
-    public ListPtr<boundaryContactSearch>
+    public boundaryListPtr<boundaryContactSearch>
 {
 private:
 

src/Interaction/contactSearch/boundaries/periodicBoundaryContactSearch/periodicBoundaryContactSearch.hpp

@@ -74,6 +74,11 @@ public:
 		csPairContainerType &ppPairs,
 		csPairContainerType &pwPairs,
 		bool force = false) override;
+	
+	bool isActive()const override
+	{
+		return true;
+	}
 };
 
 }

src/Interaction/contactSearch/boundaries/periodicBoundaryContactSearch/wallBoundaryContactSearch.cpp

@@ -11,7 +11,7 @@ pFlow::wallBoundaryContactSearch::wallBoundaryContactSearch
     const ViewType1D<realx3, memory_space> &normals
 )
 :
-    cellExtent_( max(cellExtent, 0.5 ) ),
+    cellExtent_( max(cellExtent, half ) ),
     numElements_(numElements),
     numPoints_(numPoints),
     vertices_(vertices),

src/Interaction/contactSearch/contactSearch/contactSearch.cpp

@@ -31,11 +31,11 @@ pFlow::contactSearch::contactSearch(
  	Timers& timers)
 :
 	extendedDomainBox_(extDomain),
+	updateInterval_(dict.getValMax<uint32>("updateInterval", 1u)),
 	particles_(prtcl),
 	geometry_(geom),
 	bTimer_("Boundary particles contact search", &timers),
-	ppTimer_("Internal particles contact search", &timers),
-	dict_(dict)
+	ppTimer_("Internal particles contact search", &timers)
 {
 
 }
@@ -69,6 +69,7 @@ bool pFlow::contactSearch::broadSearch
 		}
 		ppTimer_.end();
 		performedSearch_ = true;
+		lastUpdated_ = ti.currentIter();
 	}
 	else
 	{
@@ -92,6 +93,7 @@ bool pFlow::contactSearch::boundaryBroadSearch
 		bTimer_.start();
 		for(uint32 i=0u; i<6u; i++)
 		{
+			//output<<" boundarySearch "<< i <<" for iter "<< ti.iter()<<endl;
 			if(!BoundaryBroadSearch(
 				i,
 				ti,

src/Interaction/contactSearch/contactSearch/contactSearch.hpp

@@ -67,8 +67,6 @@ private:
 
 	Timer 		ppTimer_;
 
-	dictionary 	dict_;
-
 	virtual
 	bool BroadSearch(
 		const timeInfo& ti,
@@ -150,12 +148,6 @@ public:
 		return updateInterval_;
 	}
 
-	inline
-	const dictionary& dict()const
-	{
-		return dict_;
-	}
-
 	inline
 	const box& extendedDomainBox()const
 	{

src/Interaction/contactSearch/methods/cellBased/NBS/NBS.cpp

@@ -44,9 +44,9 @@ pFlow::NBS::NBS
         position,
         flags,
         diam),
-    sizeRatio_(max(dict.getVal<real>("sizeRatio"), 1.0)),
-    cellExtent_(max(dict.getVal<real>("cellExtent"), 0.5)),
-    adjustableBox_(dict.getVal<Logical>("adjustableBox")),
+    sizeRatio_(max(dict.getVal<real>("sizeRatio"), one)),
+    cellExtent_(max(dict.getVal<real>("cellExtent"), half)),
+    adjustableBox_(false),//adjustableBox_(dict.getVal<Logical>("adjustableBox")),
     NBSLevel0_
 	(
         this->domainBox_,

src/Interaction/contactSearch/methods/cellBased/NBS/cellsWallLevel0.cpp

@@ -31,7 +31,7 @@ pFlow::cellsWallLevel0::cellsWallLevel0
 	const ViewType1D<realx3, memory_space>& normals
 )
 :
-    cellExtent_( max(cellExtent, 0.5 ) ),
+    cellExtent_( max(cellExtent, half ) ),
     numElements_(numElements),
     numPoints_(numPoints),
     vertices_(vertices),

src/Interaction/contactSearch/methods/cellBased/NBS/mapperNBS.cpp

@@ -23,7 +23,7 @@ Licence:
 #include "streams.hpp"
 
 pFlow::uint32 pFlow::mapperNBS::checkInterval_ = 1000;
-pFlow::real pFlow::mapperNBS::enlargementFactor_ = 1.1;
+pFlow::real pFlow::mapperNBS::enlargementFactor_ = 1.5;
 
 bool pFlow::mapperNBS::setSearchBox
 (

src/Interaction/contactSearch/methods/cellBased/NBS/mapperNBSKernels.cpp

@@ -22,7 +22,6 @@ Licence:
 
 #include "mapperNBSKernels.hpp"
 
-
 void pFlow::mapperNBSKernels::findPointExtends
 (
     const deviceViewType1D<realx3>& points,
@@ -154,6 +153,7 @@ bool pFlow::mapperNBSKernels::buildLists
 )
 {
     auto aRange = flags.activeRange();
+    auto pp = points;
     if(flags.isAllActive() )
     { 
         Kokkos::parallel_for
@@ -162,7 +162,7 @@ bool pFlow::mapperNBSKernels::buildLists
             deviceRPolicyStatic(aRange.start(), aRange.end()),
             LAMBDA_HD(uint32 i)
             {               
-                auto ind = searchCell.pointIndex(points[i]);	
+                auto ind = searchCell.pointIndex(pp[i]);	
                 uint32 old = Kokkos::atomic_exchange(&head(ind.x(), ind.y(), ind.z()), i);
                 next[i] = old;
             }

src/Interaction/grainInteraction/boundaries/boundaryGrainInteraction/boundaryGrainInteraction.hpp

@@ -152,23 +152,25 @@ public:
 		return false;
 	}
 
-
-
 	bool hearChanges
 	(
-		real t,
-		real dt,
-		uint32 iter,
+		const timeInfo& ti,
 		const message& msg, 
     	const anyList& varList
 	) override
     {
-		
-		pOutput<<"Function (hearChanges in boundarySphereInteractions)is not implmented Message "<<
-		 msg <<endl<<" name "<< this->boundaryName() <<" type "<< this->type()<<endl;;
-		//notImplementedFunction;
+		if(msg.equivalentTo(message::BNDR_RESET))
+		{
 			return true;
 		}
+		fatalErrorInFunction<<"Event "<< msg.eventNames() << " is not handled !"<<endl;
+		return false;
+	}
+
+	bool isActive()const override
+	{
+		return false;
+	}
 
 	static
 	uniquePtr<BoundaryGrainInteractionType> create(

src/Interaction/grainInteraction/boundaries/boundaryGrainInteractionList.cpp

@@ -7,11 +7,11 @@ pFlow::boundaryGrainInteractionList<CFModel, gMModel>::boundaryGrainInteractionL
     const gMModel &geomMotion
 )
 :
-	ListPtr<boundaryGrainInteraction<CFModel,gMModel>>(6),
+	boundaryListPtr<boundaryGrainInteraction<CFModel,gMModel>>(),
 	boundaries_(grnPrtcls.pStruct().boundaries())
 {
 	//gSettings::sleepMiliSeconds(1000*pFlowProcessors().localRank());
-	for(uint32 i=0; i<6; i++)
+	ForAllBoundariesPtr(i, this)
 	{
 		this->set(
 			i,

src/Interaction/grainInteraction/boundaries/boundaryGrainInteractionList.hpp

@@ -3,7 +3,7 @@
 
 
 #include "boundaryList.hpp"
-#include "ListPtr.hpp"
+#include "boundaryListPtr.hpp"
 #include "boundaryGrainInteraction.hpp"
 
 
@@ -14,7 +14,7 @@ namespace pFlow
 template<typename contactForceModel,typename geometryMotionModel>
 class boundaryGrainInteractionList
 :
-    public ListPtr<boundaryGrainInteraction<contactForceModel,geometryMotionModel>>
+    public boundaryListPtr<boundaryGrainInteraction<contactForceModel,geometryMotionModel>>
 {
 private:
 

src/Interaction/grainInteraction/boundaries/periodicBoundaryGrainInteraction/periodicBoundaryGrainInteraction.hpp

@@ -78,14 +78,16 @@ public:
     
     ~periodicBoundaryGrainInteraction()override = default;
 
-
-    
-
     bool grainGrainInteraction(
         real dt,
 		const ContactForceModel& cfModel,
         uint32 step)override;
     
+    bool isActive()const override
+	{
+		return true;
+	}
+	
 };
 
 }

src/Interaction/grainInteraction/grainInteraction/grainInteraction.cpp

@@ -344,16 +344,12 @@ bool pFlow::grainInteraction<cFM,gMM, cLT>::afterIteration()
 template<typename cFM,typename gMM,template <class, class, class> class cLT>
 bool pFlow::grainInteraction<cFM,gMM, cLT>::hearChanges
 (
-	real t,
-	real dt,
-	uint32 iter,
+	const timeInfo& ti,
 	const message& msg, 
 	const anyList& varList
 )
 {
-	if(msg.equivalentTo(message::ITEM_REARRANGE))
-	{
-		notImplementedFunction;
-	}
-	return true;
+	fatalErrorInFunction<<"Event "<< msg.eventNames()<<
+	" is not handled in grainInteraction"<<endl;
+	return false;
 }

src/Interaction/grainInteraction/grainInteraction/grainInteraction.hpp

@@ -152,9 +152,7 @@ public:
 
 	/// Check for changes in the point structures. (overriden from observer)
 	bool hearChanges(
-		real t,
-		real dt,
-		uint32 iter,
+		const timeInfo& ti,
 		const message& msg, 
 		const anyList& varList)override;
 	

src/Interaction/grainInteraction/grainInteractionsNonLinearModels.cpp

@@ -41,3 +41,9 @@ Licence:
 	createBoundaryGrainInteraction(ForceModel, GeomModel)
 
 
+createInteraction(pFlow::cfModels::limitedCGNonLinearGrainRolling, pFlow::rotationAxisMotionGeometry);
+
+createInteraction(pFlow::cfModels::nonLimitedCGNonLinearGrainRolling, pFlow::rotationAxisMotionGeometry);
+
+createInteraction(pFlow::cfModels::limitedCGNonLinearGrainRolling, pFlow::stationaryGeometry);
+createInteraction(pFlow::cfModels::nonLimitedCGNonLinearGrainRolling, pFlow::stationaryGeometry);

src/Interaction/interaction/interaction.hpp

@@ -51,7 +51,7 @@ private:
 	const geometry& 	geometry_;
 
 	static inline
-	const message msg_ = message::ITEM_REARRANGE;
+	const message msg_ = message::ITEMS_REARRANGE;
 
 public:
 

src/Interaction/sphereInteraction/boundaries/boundarySphereInteraction/boundarySphereInteraction.hpp

@@ -148,7 +148,7 @@ public:
 		const ContactForceModel& cfModel,
 		uint32 step)
 	{
-		// for default boundary, no thing to be done 
+		// for default boundary, nothing to be done 
 		return false;
 	}
 
@@ -156,19 +156,25 @@ public:
 
 	bool hearChanges
 	(
-		real t,
-		real dt,
-		uint32 iter,
+		const timeInfo& ti,
 		const message& msg, 
     	const anyList& varList
 	) override
     {
-		
-		pOutput<<"Function (hearChanges in boundarySphereInteractions)is not implmented Message "<<
-		 msg <<endl<<" name "<< this->boundaryName() <<" type "<< this->type()<<endl;;
-		//notImplementedFunction;
+		if(msg.equivalentTo(message::BNDR_RESET))
+		{
+			// do nothing 
 			return true;
 		}
+		pOutput<<"Function (hearChanges in boundarySphereInteractions)is not implmented Message "<<
+		 msg <<endl<<" name "<< this->boundaryName() <<" type "<< this->type()<<endl;
+		return true;
+	}
+
+	bool isActive()const override
+	{
+		return false;
+	}
 
 	static
 	uniquePtr<BoundarySphereInteractionType> create(

src/Interaction/sphereInteraction/boundaries/boundarySphereInteractionList.cpp

@@ -7,11 +7,11 @@ pFlow::boundarySphereInteractionList<CFModel, gMModel>::boundarySphereInteractio
     const gMModel &geomMotion
 )
 :
-	ListPtr<boundarySphereInteraction<CFModel,gMModel>>(6),
+	boundaryListPtr<boundarySphereInteraction<CFModel,gMModel>>(),
 	boundaries_(sphPrtcls.pStruct().boundaries())
 {
-	//gSettings::sleepMiliSeconds(1000*pFlowProcessors().localRank());
-	for(uint32 i=0; i<6; i++)
+	output<<boundaries_.size()<<endl;
+	ForAllBoundariesPtr(i, this)
 	{
 		this->set(
 			i,

src/Interaction/sphereInteraction/boundaries/boundarySphereInteractionList.hpp

@@ -3,7 +3,7 @@
 
 
 #include "boundaryList.hpp"
-#include "ListPtr.hpp"
+#include "boundaryListPtr.hpp"
 #include "boundarySphereInteraction.hpp"
 
 
@@ -14,7 +14,7 @@ namespace pFlow
 template<typename contactForceModel,typename geometryMotionModel>
 class boundarySphereInteractionList
 :
-    public ListPtr<boundarySphereInteraction<contactForceModel,geometryMotionModel>>
+    public boundaryListPtr<boundarySphereInteraction<contactForceModel,geometryMotionModel>>
 {
 private:
 

src/Interaction/sphereInteraction/boundaries/periodicBoundarySphereInteraction/periodicBoundarySphereInteraction.hpp

@@ -78,14 +78,16 @@ public:
     
     ~periodicBoundarySphereInteraction()override = default;  
 
-
-    
-
     bool sphereSphereInteraction(
         real dt,
 		const ContactForceModel& cfModel,
         uint32 step)override;
     
+    bool isActive()const override
+	{
+		return true;
+	}
+	
 };
 
 }

src/Interaction/sphereInteraction/sphereInteraction/sphereInteraction.cpp

@@ -193,7 +193,9 @@ bool pFlow::sphereInteraction<cFM,gMM, cLT>::iterate()
 	{
 		contactListMangementBoundaryTimer_.start();
 		ComputationTimer().start();
-		for(uint32 i=0; i<6u; i++)
+
+		ForAllActiveBoundaries(i, boundaryInteraction_)
+		//for(size_t i=0; i<6; i++)
 		{
 			if(activeBoundaries_[i])
 			{
@@ -202,6 +204,7 @@ bool pFlow::sphereInteraction<cFM,gMM, cLT>::iterate()
 				BI.pwPairs().beforeBroadSearch();
 			}
 		}
+
 		ComputationTimer().end();
 		contactListMangementBoundaryTimer_.pause();	
 	}
@@ -219,7 +222,8 @@ bool pFlow::sphereInteraction<cFM,gMM, cLT>::iterate()
 		fatalExit;
 	}
 	
-	for(uint32 i=0; i<6u; i++)
+	ForAllActiveBoundaries(i, boundaryInteraction_)
+	//for(size_t i=0; i<6; i++)
 	{
 		if(activeBoundaries_[i])
 		{
@@ -253,7 +257,9 @@ bool pFlow::sphereInteraction<cFM,gMM, cLT>::iterate()
 	{
 		contactListMangementBoundaryTimer_.resume();
 		ComputationTimer().start();
-		for(uint32 i=0; i<6u; i++)
+		
+		ForAllActiveBoundaries(i, boundaryInteraction_)
+		//for(size_t i=0; i<6; i++)
 		{
 			if(activeBoundaries_[i])
 			{
@@ -262,6 +268,7 @@ bool pFlow::sphereInteraction<cFM,gMM, cLT>::iterate()
 				BI.pwPairs().afterBroadSearch();
 			}
 		}
+
 		ComputationTimer().end();
 		contactListMangementBoundaryTimer_.end();
 	}
@@ -274,7 +281,8 @@ bool pFlow::sphereInteraction<cFM,gMM, cLT>::iterate()
 	ComputationTimer().start();
 	while(requireStep.anyElement(true) && step <= 10)
 	{
-		for(uint32 i=0; i<6u; i++)
+		ForAllBoundaries(i, boundaryInteraction_)
+		//for(size_t i=0; i<6; i++)
 		{
 			if(requireStep[i] )
 			{
@@ -313,7 +321,8 @@ bool pFlow::sphereInteraction<cFM,gMM, cLT>::iterate()
 	const auto& cfModel = this->forceModel_();
 	while( requireStep.anyElement(true) && step < 20 )
 	{
-		for(uint32 i=0; i<6u; i++)
+		ForAllBoundaries(i, boundaryInteraction_)
+		//for(size_t i=0; i<6; i++)
 		{
 			if(requireStep[i])
 			{
@@ -342,16 +351,18 @@ bool pFlow::sphereInteraction<cFM,gMM, cLT>::afterIteration()
 template<typename cFM,typename gMM,template <class, class, class> class cLT>
 bool pFlow::sphereInteraction<cFM,gMM, cLT>::hearChanges
 (
-	real t,
-	real dt,
-	uint32 iter,
+	const timeInfo& ti,
 	const message& msg, 
 	const anyList& varList
 )
 {
-	if(msg.equivalentTo(message::ITEM_REARRANGE))
+	if(msg.equivalentTo(message::ITEMS_REARRANGE))
 	{
 		notImplementedFunction;
+		return false;
 	}
-	return true;
+	
+	fatalErrorInFunction<<"Event "<< msg.eventNames()<<
+	" is not handled in sphereInteraction"<<endl;
+	return false;
 }

src/Interaction/sphereInteraction/sphereInteraction/sphereInteraction.hpp

@@ -152,9 +152,7 @@ public:
 
 	/// Check for changes in the point structures. (overriden from observer)
 	bool hearChanges(
-		real t,
-		real dt,
-		uint32 iter,
+		const timeInfo& ti,
 		const message& msg, 
 		const anyList& varList)override;
 	

src/MotionModel/entities/rotatingAxis/rotatingAxis.cpp

@@ -47,7 +47,7 @@ pFlow::rotatingAxis::rotatingAxis
 	timeInterval(),
 	line(p1, p2),
 	omega_(omega),
-	rotating_(!equal(omega,0.0))
+	rotating_(!equal(omega,static_cast<real>(0.0)))
 {
 
 }
@@ -58,7 +58,7 @@ pFlow::real pFlow::rotatingAxis::setOmega(real omega)
 {
 	auto tmp = omega_;
 	omega_ = omega;
-	rotating_ = !equal(omega, 0.0);
+	rotating_ = !equal(omega, static_cast<real>(0.0));
 	return tmp;
 }
 
@@ -72,7 +72,7 @@ bool pFlow::rotatingAxis::read
 	if(!timeInterval::read(dict))return false;
 	if(!line::read(dict)) return false;
 		
-	real omega = dict.getValOrSet("omega", 0.0);
+	real omega = dict.getValOrSet("omega", static_cast<real>(0.0));
 	
 	setOmega(omega);
 	return true;

src/Particles/CMakeLists.txt

@@ -6,6 +6,9 @@ particles/shape/shape.cpp
 particles/particles.cpp
 particles/particleIdHandler/particleIdHandler.cpp
 particles/regularParticleIdHandler/regularParticleIdHandler.cpp
+
+globalDamping/globalDamping.cpp
+
 SphereParticles/sphereShape/sphereShape.cpp
 SphereParticles/sphereParticles/sphereParticles.cpp
 SphereParticles/sphereParticles/sphereParticlesKernels.cpp

src/Particles/GrainParticles/boundaryGrainParticles.hpp

@@ -50,9 +50,7 @@ public:
     const grainParticles& Particles()const;
 
     bool hearChanges(
-        real t,
-        real dt,
-        uint32 iter,
+        const timeInfo& ti,
         const message &msg,
         const anyList &varList) override
     {
@@ -65,6 +63,11 @@ public:
         return true;
     }
 
+    bool isActive()const override
+    {
+        return false;
+    }
+    
     static
     uniquePtr<boundaryGrainParticles> create(
         const boundaryBase &boundary,

src/Particles/GrainParticles/boundaryGrainParticlesList.cpp

@@ -5,10 +5,10 @@ pFlow::boundaryGrainParticlesList::boundaryGrainParticlesList(
     grainParticles &prtcls
 )
 :
-    ListPtr(bndrs.size()), 
+    boundaryListPtr(), 
     boundaries_(bndrs)
 {
-    for(auto i=0; i<boundaries_.size(); i++)
+    ForAllBoundariesPtr(i, this)
     {
         this->set
         (
@@ -16,4 +16,5 @@ pFlow::boundaryGrainParticlesList::boundaryGrainParticlesList(
             boundaryGrainParticles::create(boundaries_[i], prtcls)
         );
     }
+    
 }

src/Particles/GrainParticles/boundaryGrainParticlesList.hpp

@@ -3,7 +3,7 @@
 #ifndef __boundaryGrainParticlesList_hpp__
 #define __boundaryGrainParticlesList_hpp__
 
-#include "ListPtr.hpp"
+#include "boundaryListPtr.hpp"
 #include "boundaryList.hpp"
 #include "boundaryGrainParticles.hpp"
 
@@ -12,7 +12,7 @@ namespace pFlow
 
 class boundaryGrainParticlesList
 :
-    public ListPtr<boundaryGrainParticles>
+    public boundaryListPtr<boundaryGrainParticles>
 {
 private:
 

src/Particles/GrainParticles/grainParticles/grainParticles.cpp

@@ -142,16 +142,11 @@ pFlow::grainParticles::getParticlesInfoFromShape(
 
 pFlow::grainParticles::grainParticles(
 	systemControl &control,
-	const property& prop
+	const grainShape& gShape
 )
 :
-	particles(control),
-	grains_
-	(
-		shapeFile__,
-		&control.caseSetup(),
-		prop
-	),
+	particles(control, gShape),
+	grains_(gShape),
 	propertyId_
 	(
 		objectFile
@@ -253,7 +248,7 @@ pFlow::grainParticles::grainParticles(
 			"rVelocity",
 			dynPointStruct(),
 			intMethod,
-			rVelocity_.field()
+			rAcceleration_.field()
 		);
 
 	if( !rVelIntegration_ )
@@ -280,7 +275,7 @@ bool pFlow::grainParticles::beforeIteration()
 	particles::beforeIteration();
 	intPredictTimer_.start();
 		auto dt = this->dt();
-		dynPointStruct().predict(dt, accelertion());
+		dynPointStruct().predict(dt);
 		rVelIntegration_().predict(dt,rVelocity_, rAcceleration_);
 	intPredictTimer_.end();
 
@@ -301,8 +296,8 @@ bool pFlow::grainParticles::beforeIteration()
 bool pFlow::grainParticles::iterate() 
 {
 
-	timeInfo ti = TimeInfo();
-	realx3 g = control().g();
+	const timeInfo ti = TimeInfo();
+	const realx3 g = control().g();
 
 	particles::iterate();
 	accelerationTimer_.start();
@@ -313,25 +308,28 @@ bool pFlow::grainParticles::iterate()
 			I().deviceViewAll(),
 			contactTorque().deviceViewAll(),
 			dynPointStruct().activePointsMaskDevice(),
-			accelertion().deviceViewAll(),
+			acceleration().deviceViewAll(),
 			rAcceleration().deviceViewAll()
 			);
-		for(auto& bndry:boundaryGrainParticles_)
+		
+		ForAllActiveBoundaries(i,boundaryGrainParticles_)
 		{
-			bndry->acceleration(ti, g);
+			boundaryGrainParticles_[i].acceleration(ti, g);
 		}
 	accelerationTimer_.end();
 	
 	intCorrectTimer_.start();
 	
-		if(!dynPointStruct().correct(dt(), accelertion()))
+		if(!dynPointStruct().correct(ti.dt()))
 		{
 			return false;
 		}
+		real damping = dynPointStruct().dampingFactor(ti);
 		if(!rVelIntegration_().correct(
-			dt(), 
+			ti.dt(), 
 			rVelocity_, 
-			rAcceleration_))
+			rAcceleration_,
+			damping))
 		{
 			return false;
 		}

src/Particles/GrainParticles/grainParticles/grainParticles.hpp

@@ -48,7 +48,7 @@ public:
 private:
 
 	/// reference to shapes
-	ShapeType              grains_;
+	const ShapeType&       grains_;
 
 	/// property id on device
 	uint32PointField_D     propertyId_;
@@ -121,7 +121,7 @@ protected:
 public:
 
 	/// construct from systemControl and property
-	grainParticles(systemControl& control, const property& prop);
+	grainParticles(systemControl& control, const grainShape& gShape);
 
 	~grainParticles() override = default;
 
@@ -172,9 +172,7 @@ public:
 	}
 
 	bool hearChanges(
-	  real           t,
-	  real           dt,
-	  uint32         iter,
+	  const timeInfo& ti,
 	  const message& msg,
 	  const anyList& varList
 	) override

src/Particles/Insertion/insertion/insertion.cpp

@@ -81,7 +81,7 @@ pFlow::insertion::readInsertionDict()
 
 	if (active_)
 	{
-    	checkForCollision_ = getVal<Logical>("checkForCollision");
+    	//checkForCollision_ = getVal<Logical>("checkForCollision");
 
 		REPORT(1) << "Particle insertion mechanism is " << Yellow_Text("active")
 		          << " in the simulation." << END_REPORT;

src/Particles/Insertion/insertion/insertion.hpp

@@ -42,7 +42,7 @@ private:
 	Logical    active_ = "No";
 
 	/// Check for collision? It is not active now
-	Logical    checkForCollision_ = "No";
+	Logical    checkForCollision_ = "Yes";
 
 	/// if increase velocity in case particles are failed
 	/// to be inserted due to collision

src/Particles/Insertion/insertionRegion/insertionRegion.cpp

@@ -24,6 +24,7 @@ Licence:
 #include "particles.hpp"
 #include "twoPartEntry.hpp"
 #include "types.hpp"
+#include "shape.hpp"
 
 namespace pFlow
 {

src/Particles/Insertion/insertionRegion/insertionRegion.hpp

@@ -173,7 +173,7 @@ public:
 
 	inline bool insertionTime(uint32 iter, real t, real dt) const
 	{
-		return tControl_.timeEvent(iter, t, dt);
+		return tControl_.eventTime(iter, t, dt);
 	}
 
 	uint32        numberToBeInserted(uint32 iter, real t, real dt);

src/Particles/SphereParticles/boundarySphereParticles.hpp

@@ -50,9 +50,7 @@ public:
     const sphereParticles& Particles()const;
 
     bool hearChanges(
-        real t,
-        real dt,
-        uint32 iter,
+        const timeInfo& ti,
         const message &msg,
         const anyList &varList) override
     {
@@ -65,6 +63,11 @@ public:
         return true;
     }
 
+    bool isActive()const override
+    {
+        return false;
+    }
+
     static
     uniquePtr<boundarySphereParticles> create(
         const boundaryBase &boundary,

src/Particles/SphereParticles/boundarySphereParticlesList.cpp

@@ -5,10 +5,10 @@ pFlow::boundarySphereParticlesList::boundarySphereParticlesList(
     sphereParticles &prtcls
 )
 :
-    ListPtr(bndrs.size()), 
+    boundaryListPtr(), 
     boundaries_(bndrs)
 {
-    for(auto i=0; i<boundaries_.size(); i++)
+    ForAllBoundariesPtr(i, this)
     {
         this->set
         (

src/Particles/SphereParticles/boundarySphereParticlesList.hpp

@@ -3,7 +3,7 @@
 #ifndef __boundarySphereParticlesList_hpp__
 #define __boundarySphereParticlesList_hpp__
 
-#include "ListPtr.hpp"
+#include "boundaryListPtr.hpp"
 #include "boundaryList.hpp"
 #include "boundarySphereParticles.hpp"
 
@@ -12,7 +12,7 @@ namespace pFlow
 
 class boundarySphereParticlesList
 :
-    public ListPtr<boundarySphereParticles>
+    public boundaryListPtr<boundarySphereParticles>
 {
 private:
 

src/Particles/SphereParticles/sphereParticles/sphereParticles.cpp

@@ -24,180 +24,6 @@ Licence:
 #include "sphereParticlesKernels.hpp"
 
 
-//#include "setFieldList.hpp"
-/*pFlow::uniquePtr<pFlow::List<pFlow::eventObserver*>> 
-pFlow::sphereParticles::getFieldObjectList()const
-{
-	auto objListPtr = particles::getFieldObjectList();
-
-	objListPtr().push_back(
-		static_cast<eventObserver*>(&I_) );
-
-	return objListPtr;
-}
-
-bool pFlow::sphereParticles::diameterMassInertiaPropId
-(
-	const word& shName,
-	real& diam,
-	real& mass,
-	real& I,
-	int8& propIdx
-)
-{
-	uint32 idx;
-	if( !shapes_.nameToIndex(shName, idx) )
-	{
-		printKeys(fatalErrorInFunction<<
-		"  wrong shape name in the input: "<< shName<<endl<<
-		"  available shape names are: ", shapes_.names())<<endl;
-		return false;
-	}
-
-	diam = shapes_.diameter(idx);
-	word materialName = shapes_.material(idx);
-	uint32 pIdx;
-	if( !property_.nameToIndex(materialName, pIdx) )
-	{
-		fatalErrorInFunction << 
-		"  wrong material name "<< materialName <<" specified for shape "<< shName<<
-		"  in the sphereShape dictionary.\n"<<
-		"  available materials are "<< property_.materials()<<endl;
-		return false;
-	}
-	real rho = property_.density(pIdx);
-
-	mass = Pi/6.0*pow(diam,3.0)*rho;
-	I = 0.4 * mass * pow(diam/2.0,2.0);
-	propIdx= static_cast<int8>(pIdx);
-	return true;
-}
-
-bool pFlow::sphereParticles::initializeParticles()
-{
-	
-	int32IndexContainer indices(
-		0, 
-		static_cast<int32>(shapeName_.size()));
-	
-	return insertSphereParticles(shapeName_, indices, false);
-}*/
-
-
-/*bool pFlow::sphereParticles::beforeIteration() 
-{
-	particles::beforeIteration();
-	
-	intPredictTimer_.start();
-	
-	//INFO<<"before dyn predict"<<endINFO;
-		dynPointStruct_.predict(this->dt(), accelertion_);
-	//INFO<<"after dyn predict"<<endINFO;
-
-	//INFO<<"before revel predict"<<endINFO;
-		rVelIntegration_().predict(this->dt(),rVelocity_, rAcceleration_);
-	//INFO<<"after rvel predict"<<endINFO;
-
-	intPredictTimer_.end();
-
-	return true;
-}*/
-
-
-
-
-
-/*bool pFlow::sphereParticles::afterIteration() 
-{
-	return true;
-}*/
-
-
-/*bool pFlow::sphereParticles::insertSphereParticles(
-	const wordVector& names,
-	const int32IndexContainer& indices,
-	bool setId
-	)
-{
-
-	if(names.size()!= indices.size())
-	{
-		fatalErrorInFunction <<
-		"sizes of names ("<<names.size()<<") and indices ("
-			<< indices.size()<<") do not match \n";
-		return false;
-	}
-
-	auto len = names.size();
-		
-	realVector  diamVec(len, RESERVE());
-	realVector  massVec(len, RESERVE());
-	realVector  IVec(len, RESERVE());
-	int8Vector  pIdVec(len, RESERVE());
-	int32Vector IdVec(len, RESERVE());
-
-	real d, m, I;
-	int8 pId;
-
-	ForAll(i, names )
-	{
-		
-		if (diameterMassInertiaPropId(names[i], d, m, I, pId))
-		{
-			diamVec.push_back(d);
-			massVec.push_back(m);
-			IVec.push_back(I);
-			pIdVec.push_back(pId);
-			if(setId) IdVec.push_back(idHandler_.getNextId());
-			//output<<" we are in sphereParticles nextId "<< idHandler_.nextId()<<endl;
-		}
-		else
-		{
-			fatalErrorInFunction<< "failed to calculate properties of shape " <<
-			 names[i]<<endl;
-			return false;
-		}
-		
-	}
-
-	if(!diameter_.insertSetElement(indices, diamVec))
-	{
-		fatalErrorInFunction<< " failed to insert diameters to the diameter field. \n";
-		return false;
-	}
-
-	if(!mass_.insertSetElement(indices, massVec))
-	{
-		fatalErrorInFunction<< " failed to insert mass to the mass field. \n";
-		return false;
-	}
-
-	if(!I_.insertSetElement(indices, IVec))
-	{
-		fatalErrorInFunction<< " failed to insert I to the I field. \n";
-		return false;
-	}
-
-	if(!propertyId_.insertSetElement(indices, pIdVec))
-	{
-		fatalErrorInFunction<< " failed to insert propertyId to the propertyId field. \n";
-		return false;
-	}
-
-	if(setId)
-	{
-		if( !id_.insertSetElement(indices, IdVec))
-		{
-			fatalErrorInFunction<< " failed to insert id to the id field. \n";
-			return false;
-		}	
-	}
-	
-
-	return true;
-
-}*/
-
 bool pFlow::sphereParticles::initializeParticles()
 {
 	
@@ -307,16 +133,11 @@ pFlow::sphereParticles::getParticlesInfoFromShape(
 
 pFlow::sphereParticles::sphereParticles(
 	systemControl &control,
-	const property& prop
+	const sphereShape& shpShape
 )
 :
-	particles(control),
-	spheres_
-	(
-		shapeFile__,
-		&control.caseSetup(),
-		prop
-	),
+	particles(control, shpShape),
+	spheres_(shpShape),
 	propertyId_
 	(
 		objectFile
@@ -408,7 +229,7 @@ pFlow::sphereParticles::sphereParticles(
 			"rVelocity",
 			dynPointStruct(),
 			intMethod,
-			rVelocity_.field()
+			rAcceleration_.field()
 		);
 
 	if( !rVelIntegration_ )
@@ -418,8 +239,6 @@ pFlow::sphereParticles::sphereParticles(
 		fatalExit;
 	}
 
-	WARNING<<"setFields for rVelIntegration_"<<END_WARNING;
-	
 	if(!initializeParticles())
 	{
 		fatalErrorInFunction;
@@ -428,96 +247,12 @@ pFlow::sphereParticles::sphereParticles(
 	
 } 
 
-/*bool pFlow::sphereParticles::update(const eventMessage& msg) 
-{
-	
-	if(rVelIntegration_->needSetInitialVals())
-	{
-		
-		
-		auto indexHD = pStruct().insertedPointIndex();
-	
-		auto n = indexHD.size();
-		auto index = indexHD.indicesHost();
-
-		realx3Vector rvel(n,RESERVE());
-		const auto hrVel = rVelocity_.hostView();
-
-		for(auto i=0; i<n; i++)
-		{
-			rvel.push_back( hrVel[index(i)]);
-		}
-		
-		rVelIntegration_->setInitialVals(indexHD, rvel);
-
-	}	
-
-	return true;
-}*/
-
-/*bool pFlow::sphereParticles::insertParticles
-(
-	const realx3Vector& position,
- 	const wordVector&  shapes,
- 	const setFieldList& setField
- )
-{
-	
-	if( position.size() != shapes.size() )
-	{
-		fatalErrorInFunction<< 
-		"  size of vectors position ("<<position.size()<<
-		") and shapes ("<<shapes.size()<<") are not the same. \n";
-		return false;
-	}
-
-
-
-	auto exclusionListAllPtr = getFieldObjectList(); 
-	
-	auto newInsertedPtr = pStruct().insertPoints( position, setField, time(), exclusionListAllPtr());
-	
-
-	if(!newInsertedPtr)
-	{
-		fatalErrorInFunction<<
-		"  error in inserting points into pStruct. \n";
-		return false;
-	}
-
-	auto& newInserted = newInsertedPtr();
-	
-	if(!shapeName_.insertSetElement(newInserted, shapes))
-	{
-		fatalErrorInFunction<<
-		"  error in inserting shapes into sphereParticles system.\n";
-		return false;
-	}	
-
-	if( !insertSphereParticles(shapes, newInserted) )
-	{
-		fatalErrorInFunction<< 
-		"error in inserting shapes into the sphereParticles. \n";
-		return false;
-	}
-	
-
-	auto activeR = this->activeRange();
-
-	REPORT(1)<< "Active range is "<<yellowText("["<<activeR.first<<", "<<activeR.second<<")")<<
-	" and number of active points is "<< cyanText(this->numActive())<<
-	" and pointStructure capacity is "<<cyanText(this->capacity())<<endREPORT;
-
-	return true;
-		
-}*/
-
 bool pFlow::sphereParticles::beforeIteration()
 {
 	particles::beforeIteration();
 	intPredictTimer_.start();
 		auto dt = this->dt();
-		dynPointStruct().predict(dt, accelertion());
+		dynPointStruct().predict(dt);
 		rVelIntegration_().predict(dt,rVelocity_, rAcceleration_);
 	intPredictTimer_.end();
 
@@ -537,8 +272,8 @@ bool pFlow::sphereParticles::beforeIteration()
 bool pFlow::sphereParticles::iterate() 
 {
 
-	timeInfo ti = TimeInfo();
-	realx3 g = control().g();
+	const timeInfo ti = TimeInfo();
+	const realx3 g = control().g();
 
 	particles::iterate();
 	accelerationTimer_.start();
@@ -549,25 +284,28 @@ bool pFlow::sphereParticles::iterate()
 			I().deviceViewAll(),
 			contactTorque().deviceViewAll(),
 			dynPointStruct().activePointsMaskDevice(),
-			accelertion().deviceViewAll(),
+			acceleration().deviceViewAll(),
 			rAcceleration().deviceViewAll()
 			);
-		for(auto& bndry:boundarySphereParticles_)
+		ForAllActiveBoundaries(i,boundarySphereParticles_)
 		{
-			bndry->acceleration(ti, g);
+			boundarySphereParticles_[i].acceleration(ti, g);
 		}
+
 	accelerationTimer_.end();
 	
 	intCorrectTimer_.start();
 	
-		if(!dynPointStruct().correct(dt(), accelertion()))
+		if(!dynPointStruct().correct(ti.dt()))
 		{
 			return false;
 		}
+		real damping = dynPointStruct().dampingFactor(ti);
 		if(!rVelIntegration_().correct(
-			dt(), 
+			ti.dt(), 
 			rVelocity_, 
-			rAcceleration_))
+			rAcceleration_,
+			damping))
 		{
 			return false;
 		}

src/Particles/SphereParticles/sphereParticles/sphereParticles.hpp

@@ -48,7 +48,7 @@ public:
 private:
 
 	/// reference to shapes
-	ShapeType              spheres_;
+	const ShapeType&              spheres_;
 
 	/// property id on device
 	uint32PointField_D     propertyId_;
@@ -124,7 +124,7 @@ protected:
 public:
 
 	/// construct from systemControl and property
-	sphereParticles(systemControl& control, const property& prop);
+	sphereParticles(systemControl& control, const sphereShape& shpShape);
 
 	~sphereParticles() override = default;
 
@@ -175,9 +175,7 @@ public:
 	}
 
 	bool hearChanges(
-	  real           t,
-	  real           dt,
-	  uint32         iter,
+	  const timeInfo& ti,
 	  const message& msg,
 	  const anyList& varList
 	) override

src/Particles/dynamicPointStructure/dynamicPointStructure.cpp

@@ -21,12 +21,14 @@ Licence:
 #include "dynamicPointStructure.hpp"
 #include "systemControl.hpp"
 
+
 pFlow::dynamicPointStructure::dynamicPointStructure
 (
-	systemControl& control
+	systemControl& control,
+	real maxBSphere
 )
 :
-	pointStructure(control),
+	pointStructure(control, maxBSphere),
 	velocity_
 	(
 		objectFile(
@@ -37,6 +39,16 @@ pFlow::dynamicPointStructure::dynamicPointStructure
 			),
 		*this,
 		zero3
+	),
+	acceleration_(
+      objectFile(
+        "acceleration",
+        "",
+        objectFile::READ_IF_PRESENT,
+        objectFile::WRITE_ALWAYS
+      ),
+      *this,
+      zero3
     ),
 	velocityUpdateTimer_("velocity boundary update", &timers()),
 	integrationMethod_
@@ -52,7 +64,7 @@ pFlow::dynamicPointStructure::dynamicPointStructure
 		"pStructPosition",
 		*this,
 		integrationMethod_,
-		pointPosition()
+		velocity_.field()
 	);
 
 	if( !integrationPos_ )
@@ -67,7 +79,7 @@ pFlow::dynamicPointStructure::dynamicPointStructure
 		"pStructVelocity",
 		*this,
 		integrationMethod_,
-		velocity_.field()
+		acceleration_.field()
 	);
 
 	if( !integrationVel_ )
@@ -77,6 +89,11 @@ pFlow::dynamicPointStructure::dynamicPointStructure
 		fatalExit;
 	}
 
+	if(control.settingsDict().containsDictionay("globalDamping"))
+	{
+		REPORT(1)<<"Reading globalDamping dictionary ..."<<END_REPORT;
+		velDamping_ = makeUnique<globalDamping>(control);
+	}
 }
 
 
@@ -85,6 +102,7 @@ bool pFlow::dynamicPointStructure::beforeIteration()
 	if(!pointStructure::beforeIteration())return false;
 	velocityUpdateTimer_.start();
 	velocity_.updateBoundariesSlaveToMasterIfRequested();
+	acceleration_.updateBoundariesSlaveToMasterIfRequested();
 	integrationPos_->updateBoundariesSlaveToMasterIfRequested();
 	integrationVel_->updateBoundariesSlaveToMasterIfRequested();
 	velocityUpdateTimer_.end();
@@ -95,34 +113,32 @@ bool pFlow::dynamicPointStructure::iterate()
 {
 	return pointStructure::iterate();
 	
-	/*real dt = this->dt();
-
-    auto& acc = time().lookupObject<realx3PointField_D>("acceleration");
-    return correct(dt, acc);*/
 }
 
-bool pFlow::dynamicPointStructure::predict(
-    real dt,
-    realx3PointField_D &acceleration)
+bool pFlow::dynamicPointStructure::afterIteration()
+{
+		//const auto ti = TimeInfo();
+		
+		auto succs = pointStructure::afterIteration();
+
+		return succs;
+}
+
+bool pFlow::dynamicPointStructure::predict(real dt)
 {
 
 	if(!integrationPos_().predict(dt, pointPosition(), velocity_ ))return false;
-	if(!integrationVel_().predict(dt, velocity_, acceleration))return false;
+	if(!integrationVel_().predict(dt, velocity_, acceleration_))return false;
 
 	return true;
 }
 
-bool pFlow::dynamicPointStructure::correct
-(
-	real dt,
-	realx3PointField_D& acceleration
-)
+bool pFlow::dynamicPointStructure::correct(real dt)
 {
-	//auto& pos = pStruct().pointPosition();
+	const auto& ti = TimeInfo();
 	
 	if(!integrationPos_().correctPStruct(dt, *this, velocity_) )return false;
-	
-	if(!integrationVel_().correct(dt, velocity_, acceleration))return false;
+	if(!integrationVel_().correct(dt, velocity_, acceleration_, dampingFactor(ti)))return false;
 
 	return true;	
 }

src/Particles/dynamicPointStructure/dynamicPointStructure.hpp

@@ -26,11 +26,13 @@ Licence:
 #include "pointFields.hpp"
 #include "integration.hpp"
 #include "uniquePtr.hpp"
+#include "globalDamping.hpp"
 
 namespace pFlow
 {
 
 class systemControl;
+//class globalDamping;
 
 class dynamicPointStructure
 :
@@ -40,10 +42,15 @@ private:
 
 	realx3PointField_D  	velocity_;
 
+	/// acceleration on device
+	realx3PointField_D      acceleration_;
+
 	uniquePtr<integration>  integrationPos_ = nullptr;
 
 	uniquePtr<integration>  integrationVel_ = nullptr;
 
+	uniquePtr<globalDamping> velDamping_ = nullptr;
+
 	Timer 					velocityUpdateTimer_;
 
 	/// @brief integration method for velocity and position
@@ -53,7 +60,7 @@ public:
 
 	TypeInfo("dynamicPointStructure");
 
-	explicit dynamicPointStructure(systemControl& control);
+	explicit dynamicPointStructure(systemControl& control, real maxBSphere);
 
 	dynamicPointStructure(const dynamicPointStructure& ps) = delete;
 		
@@ -82,6 +89,28 @@ public:
 		return velocity_;
 	}
 
+	inline 
+	const realx3PointField_D& acceleration()const
+	{
+		return acceleration_;
+	}
+
+	inline 
+	realx3PointField_D& acceleration()
+	{
+		return acceleration_;
+	}
+
+	inline
+	real dampingFactor(const timeInfo& ti)const
+	{
+		if(velDamping_)
+		{
+			return velDamping_().dampingFactor(ti);
+		}
+		return 1.0;
+	}
+
 	/// In the time loop before iterate
 	bool beforeIteration() override;
 
@@ -89,11 +118,13 @@ public:
 	/// when the component should evolve along time.
 	bool iterate() override;
 
+	bool afterIteration()override;
+	
 	/// prediction step (if any), is called in beforeIteration	
-	bool predict(real dt, realx3PointField_D& acceleration);
+	bool predict(real dt);
 
 	/// correction step, is called in iterate 
-	bool correct(real dt, realx3PointField_D& acceleration);
+	bool correct(real dt);
 
 };
 

src/Particles/globalDamping/globalDamping.cpp

@@ -0,0 +1,50 @@
+/*------------------------------- 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.
+
+-----------------------------------------------------------------------------*/
+
+
+#include "globalDamping.hpp"
+
+
+pFlow::globalDamping::globalDamping(const systemControl& control)
+:
+    timeControl_(control.settingsDict().subDict("globalDamping"), control.time().dt(), "damping")
+{
+    const dictionary& dict = control.settingsDict().subDict("globalDamping");
+
+    dampingFactor_ = dict.getValMin<real>("dampingFactor", static_cast<real>(1.0));
+
+    dampingFactor_ = max( dampingFactor_ , static_cast<real>(0.01));
+
+    performDamping_ = !equal(dampingFactor_, static_cast<real>(1.0));
+
+    if( performDamping_ )
+		REPORT(2)<<"Global damping "<<Yellow_Text("is active")<<
+		" and damping factor is "<<dampingFactor_<<END_REPORT;
+	else
+		REPORT(2)<<"Global damping "<<Yellow_Text("is not active")<<"."<<END_REPORT;
+
+}
+
+pFlow::real pFlow::globalDamping::dampingFactor(const timeInfo& ti)const
+{
+	if(!performDamping_) return 1.0;
+	if(!timeControl_.eventTime(ti ))return 1.0;
+	return dampingFactor_;
+}

src/Particles/globalDamping/globalDamping.hpp

@@ -0,0 +1,62 @@
+/*------------------------------- 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 __globalDamping_hpp__
+#define __globalDamping_hpp__
+
+#include "systemControl.hpp"
+#include "pointFields.hpp"
+#include "baseTimeControl.hpp"
+
+namespace pFlow
+{
+
+
+class globalDamping
+{
+private:
+
+    bool            performDamping_ = false;
+
+    real            dampingFactor_;
+
+    baseTimeControl timeControl_;
+
+public:
+
+
+    globalDamping(const systemControl& control);
+
+    ~globalDamping()=default;
+
+    bool dampingActive()const
+    {
+        return performDamping_;
+    }
+
+    real dampingFactor(const timeInfo& ti)const;
+    
+};
+
+
+}
+
+
+#endif 

src/Particles/particles/particleIdHandler/particleIdHandler.cpp

@@ -41,16 +41,14 @@ pFlow::particleIdHandler::particleIdHandler(pointStructure& pStruct)
 
 bool
 pFlow::particleIdHandler::hearChanges(
-  real           t,
-  real           dt,
-  uint32         iter,
+  const timeInfo& ti,
   const message& msg,
   const anyList& varList
 )
 {
-	if(msg.equivalentTo(message::ITEM_INSERT))
+	if(msg.equivalentTo(message::ITEMS_INSERT))
 	{
-		const word eventName = message::eventName(message::ITEM_INSERT);
+		const word eventName = message::eventName(message::ITEMS_INSERT);
 
 		const auto& indices = varList.getObject<uint32IndexContainer>(
 			eventName);
@@ -66,7 +64,7 @@ pFlow::particleIdHandler::hearChanges(
 	}
 	else
 	{
-		return uint32PointField_D::hearChanges(t,dt,iter, msg,varList);
+		return uint32PointField_D::hearChanges(ti, msg, varList);
 	}
 }
 

src/Particles/particles/particleIdHandler/particleIdHandler.hpp

@@ -60,15 +60,11 @@ public:
 	virtual 
 	uint32 maxId()const = 0;
 
-	
-
 	// heat change for possible insertion of particles
 	// overrdie from internalField
 	bool hearChanges
 	(
-		real t,
-		real dt,
-		uint32 iter,
+		const timeInfo& ti,
 		const message& msg, 
 		const anyList& varList
 	) override;

src/Particles/particles/particles.cpp

@@ -18,22 +18,12 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 #include "particles.hpp"
+#include "shape.hpp"
 
-pFlow::particles::particles(systemControl& control)
+pFlow::particles::particles(systemControl& control, const shape& shapes)
   : observer(defaultMessage_),
     demComponent("particles", control),
-    dynPointStruct_(control),
-    /*id_(
-      objectFile(
-        "id",
-        "",
-        objectFile::READ_IF_PRESENT,
-        objectFile::WRITE_ALWAYS
-      ),
-      dynPointStruct_,
-      static_cast<uint32>(-1),
-      static_cast<uint32>(-1)
-    ),*/
+    dynPointStruct_(control, shapes.maxBoundingSphere()),
     shapeIndex_(
       objectFile(
         "shapeIndex",
@@ -44,16 +34,6 @@ pFlow::particles::particles(systemControl& control)
       dynPointStruct_,
       0
     ),
-    accelertion_(
-      objectFile(
-        "accelertion",
-        "",
-        objectFile::READ_IF_PRESENT,
-        objectFile::WRITE_ALWAYS
-      ),
-      dynPointStruct_,
-      zero3
-    ),
     contactForce_(
       objectFile(
         "contactForce",
@@ -94,7 +74,6 @@ pFlow::particles::beforeIteration()
 	zeroTorque();
   baseFieldBoundaryUpdateTimer_.start();
   shapeIndex_.updateBoundariesSlaveToMasterIfRequested();
-  accelertion_.updateBoundariesSlaveToMasterIfRequested();
   idHandler_().updateBoundariesSlaveToMasterIfRequested();
   baseFieldBoundaryUpdateTimer_.end();
   return true;

src/Particles/particles/particles.hpp

@@ -25,11 +25,14 @@ PARTICULAR PURPOSE.
 #include "demComponent.hpp"
 #include "dynamicPointStructure.hpp"
 #include "particleIdHandler.hpp"
-#include "shape.hpp"
+//#include "shape.hpp"
 
 namespace pFlow
 {
 
+
+class shape;
+
 class particles
   : public observer
   , public demComponent
@@ -42,9 +45,6 @@ private:
 	/// shape index of each particle 
 	uint32PointField_D           shapeIndex_;
 
-	/// acceleration on device
-	realx3PointField_D           accelertion_;
-
 	/// contact force field
 	realx3PointField_D           contactForce_;
 
@@ -57,7 +57,7 @@ private:
 	Timer 						 baseFieldBoundaryUpdateTimer_;
 
 	/// messages for this objects
-	static inline const message  defaultMessage_{ message::DEFAULT };
+	static inline const message  defaultMessage_= message::Empty();
 
 protected:
 
@@ -96,7 +96,7 @@ public:
 	// type info
 	TypeInfo("particles");
 
-	explicit particles(systemControl& control);
+	explicit particles(systemControl& control, const shape& shapes);
 
 	inline const auto& dynPointStruct() const
 	{
@@ -153,14 +153,14 @@ public:
 		return dynPointStruct_.velocity();
 	}
 
-	inline const auto& accelertion() const
+	inline const auto& acceleration() const
 	{
-		return accelertion_;
+		return dynPointStruct_.acceleration();
 	}
 
-	inline auto& accelertion()
+	inline auto& acceleration()
 	{
-		return accelertion_;
+		return dynPointStruct_.acceleration();
 	}
 
 	inline auto& contactForce()

src/phasicFlow/CMakeLists-old.txt

@@ -1,87 +0,0 @@
-
-list(APPEND SourceFiles 
-types/basicTypes/bTypesFunctions.cpp
-types/basicTypes/Logical.cpp
-types/types.cpp
-
-globals/error.cpp
-
-streams/token/tokenIO.cpp
-streams/token/token.cpp
-streams/iStream/IOstream.cpp
-streams/iStream/iIstream.cpp
-streams/iStream/iOstream.cpp
-streams/Stream/Istream.cpp
-streams/Stream/Ostream.cpp
-streams/Fstream/iFstream.cpp
-streams/Fstream/oFstream.cpp
-streams/Fstream/fileStream.cpp 
-streams/TStream/iTstream.cpp
-streams/TStream/oTstream.cpp
-streams/streams.cpp 
-
-dictionary/dictionary.cpp
-dictionary/entry/iEntry.cpp
-dictionary/entry/dataEntry.cpp 
-dictionary/twoPartEntry/twoPartEntry.cpp
-
-fileSystem/fileSystem.cpp
-
-commandLine/commandLine.cpp
-
-random/randomReal/randomReal.cpp
-random/randomReal/randomReals.cpp
-
-Timer/Timer.cpp
-Timer/Timers.cpp
-
-repository/Time/Time.cpp
-repository/Time/timeControl.cpp
-repository/systemControl/systemControl.cpp
-repository/systemControl/dynamicLinkLibs.cpp
-repository/repository/repository.cpp
-repository/IOobject/objectFile.cpp
-repository/IOobject/IOobject.cpp
-repository/IOobject/IOfileHeader.cpp
-
-structuredData/box/box.cpp
-structuredData/cells/cells.cpp
-structuredData/cylinder/cylinder.cpp
-structuredData/sphere/sphere.cpp
-structuredData/iBox/iBoxs.cpp
-structuredData/line/line.cpp
-structuredData/zAxis/zAxis.cpp
-structuredData/pointStructure/pointStructure.cpp
-structuredData/pointStructure/mortonIndexing.cpp
-structuredData/pointStructure/selectors/pStructSelector/pStructSelector.cpp
-structuredData/pointStructure/selectors/selectBox/selectBox.cpp
-structuredData/pointStructure/selectors/selectRange/selectRange.cpp 
-structuredData/pointStructure/selectors/selectRandom/selectRandom.cpp
-structuredData/trisurfaceStructure/triSurface.cpp
-structuredData/trisurfaceStructure/multiTriSurface.cpp
-structuredData/trisurfaceStructure/stlFile.cpp
-structuredData/peakableRegion/sphereRegion/sphereRegion.cpp
-structuredData/peakableRegion/cylinderRegion/cylinderRegion.cpp
-structuredData/peakableRegion/boxRegion/boxRegion.cpp
-structuredData/peakableRegion/peakableRegion/peakableRegion.cpp
-structuredData/peakableRegion/peakableRegions.cpp
-
-containers/Vector/Vectors.cpp
-containers/Field/Fields.cpp
-containers/symArrayHD/symArrays.cpp
-containers/triSurfaceField/triSurfaceFields.cpp
-containers/bitsetHD/bitsetHDs.cpp
-containers/indexContainer/indexContainer.cpp
-
-setFieldList/setFieldList.cpp
-setFieldList/setFieldEntry.cpp
-
-eventSubscriber/eventSubscriber.cpp
-eventSubscriber/eventObserver.cpp)
-
-set(link_libs Kokkos::kokkos tbb)
-
-pFlow_add_library_install(phasicFlow SourceFiles link_libs)
-
-target_include_directories(phasicFlow PUBLIC ./Kokkos ./algorithms ./globals)
-

src/phasicFlow/containers/List/anyList/anyList.hpp

@@ -162,12 +162,36 @@ public:
 			{
 				fatalErrorInFunction<<
 				"variable name "<< name << " does not exist in the anyList."<<endl<<
-				"list of variables is "<<names_<<endl;
+				"list of variables is \n"<<names_<<endl;
 				fatalExit;
 			}
 			return getObject<T>(static_cast<size_t>(i));
 		}
 
+		template<typename T>
+		bool checkObjectType(const word& name)const
+		{
+			int32 i = names_.findi(name);
+			if(i == -1 )
+			{
+				fatalErrorInFunction<<
+				"variable name "<< name << " does not exist in the anyList."<<endl<<
+				"list of variables is \n"<<names_<<endl;
+				return false;
+			}
+			return getTypeName<T>() == types_[i];
+		}
+
+		word getObjectTypeName(const word& name)const
+		{
+			int32 i = names_.findi(name);
+			if(i == -1 )
+			{
+				return "NAME_NOT_FOUND";
+			}
+			return types_[i];
+		}
+
 		/// Get the const reference to variable by name 
 		template<typename T>
 		const T& getObject(const word& name)const

src/phasicFlow/containers/pointField/boundaryField/boundaryField/boundaryField.cpp

@@ -34,15 +34,14 @@ pFlow::boundaryField<T, MemorySpace>::boundaryField
 		memory_space::name()
 	),
 	internal_(internal)
-{}
+{
+}
 
 template<class T, class MemorySpace>
 typename pFlow::boundaryField<T, MemorySpace>::ProcVectorType& 
 pFlow::boundaryField<T, MemorySpace>::neighborProcField()
 {
 	static ProcVectorType dummyVector{"dummyVector"};
-	//notImplementedFunction;
-	//fatalExit;
 	return dummyVector;
 }
 
@@ -51,8 +50,6 @@ const typename pFlow::boundaryField<T, MemorySpace>::ProcVectorType&
 pFlow::boundaryField<T, MemorySpace>::neighborProcField() const
 {
 	static ProcVectorType dummyVector{"dummyVector"};
-	//notImplementedFunction;
-	//fatalExit;
 	return dummyVector;
 }
 

src/phasicFlow/containers/pointField/boundaryField/boundaryField/boundaryField.hpp

@@ -102,25 +102,23 @@ public:
 
 	bool hearChanges
 	(
-		real t,
-		real dt,
-		uint32 iter,
+		const timeInfo& ti,
 		const message& msg, 
     	const anyList& varList
 	) override
     {
 
-		if(msg.equivalentTo(message::BNDR_REARRANGE))
-		{
-			// do nothing
-		}
 		if(msg.equivalentTo(message::BNDR_RESET))
 		{
 			//do nothing
-		}
 			return true;
 		}
 
+		fatalErrorInFunction<<"Event"<< msg.eventNames()<<"with code "<< msg <<
+		" is not handled in boundaryField."<<endl;
+		return false;
+	}
+
 	inline
 	InternalFieldType& internal()
 	{
@@ -184,6 +182,12 @@ public:
 		return;
 	}
 
+
+	bool isActive()const override
+	{
+		return false;
+	}
+
 	static
 	uniquePtr<boundaryField> create(
 		const boundaryBase& boundary, 

src/phasicFlow/containers/pointField/boundaryField/boundaryFieldList.hpp

@@ -22,7 +22,7 @@ Licence:
 
 #include "boundaryField.hpp"
 #include "boundaryList.hpp"
-#include "ListPtr.hpp"
+#include "boundaryListPtr.hpp"
 
 
 namespace pFlow
@@ -31,7 +31,7 @@ namespace pFlow
 template< class T, class MemorySpace = void >
 class boundaryFieldList
 :
-    public ListPtr< boundaryField<T, MemorySpace> >
+    public boundaryListPtr< boundaryField<T, MemorySpace> >
 {
 public:
 
@@ -50,10 +50,10 @@ public:
 
     boundaryFieldList(const boundaryList& boundaries, InternalFieldType& internal)
     :
-        ListPtr<BoundaryFieldType>(boundaries.size()),
+        boundaryListPtr<BoundaryFieldType>(),
         boundaries_(boundaries)
     {
-        for(auto i=0; i<boundaries.size(); i++)
+        ForAllBoundariesPtr(i, this)
         {
             this->set
             (
@@ -68,24 +68,16 @@ public:
         if( direction == DataDirection::SlaveToMaster 
             && slaveToMasterUpdateIter_ == iter) return;
         
-        
-        
         // first step
-        uint32 i=0;
-        for(auto b:*this)
+        ForAllBoundariesPtr(i,this)
         {
-            if(i==0 ) 
-            {
-                //pOutput<<"request for update boundaries for field "<< b->name()<<endl;
-                i++;
-            }
-            b->updateBoundary(1, direction);
+            this->boundaryPtr(i)->updateBoundary(1, direction);        
         }
 
         // second step
-        for(auto b:*this)
+        ForAllBoundariesPtr(i,this)
         {
-            b->updateBoundary(2, direction);
+            this->boundaryPtr(i)->updateBoundary(1, direction);
         }
         
         if(direction == DataDirection::SlaveToMaster)
@@ -96,9 +88,9 @@ public:
 
     void fill(const T& val)
     {
-        for(auto& bf: *this)
+        ForAllBoundariesPtr(i, this)
         {
-            bf->fill(val);
+            this->boundaryPtr(i)->fill(val);
         }
     }
 

src/phasicFlow/containers/pointField/boundaryField/exitBoundaryField/exitBoundaryField.cpp

@@ -27,6 +27,4 @@ template<class T, class MemorySpace>
 )
 :
 	BoundaryFieldType(boundary, pStruct, internal)
-{
-	this->addEvent(message::BNDR_DELETE);
-}
+{}

src/phasicFlow/containers/pointField/boundaryField/exitBoundaryField/exitBoundaryField.hpp

@@ -61,24 +61,9 @@ public:
 		boundaryBase
 	);
 
-
-	bool hearChanges
-	(
-		real t,
-		real dt,
-		uint32 iter,
-		const message& msg, 
-    	const anyList& varList
-	) override
+	bool isActive()const override
 	{
-		BoundaryFieldType::hearChanges(t,dt,iter, msg,varList);
-		
-		if(msg.equivalentTo(message::BNDR_DELETE))
-		{
-			// do nothing;
-		}
-		
-		return true;
+		return false;
 	}
 
 };

src/phasicFlow/containers/pointField/boundaryField/generalBoundary/generalBoundary.hpp

@@ -148,6 +148,9 @@ public:
 
     const Time& time()const;
 
+    virtual
+    bool isActive()const = 0;
+	
 };
 
 } // pFlow

src/phasicFlow/containers/pointField/boundaryField/periodicBoundaryField/periodicBoundaryField.cpp

@@ -26,7 +26,4 @@ template<class T, class MemorySpace>
 )
 :
 	BoundaryFieldType(boundary, pStruct, internal)
-{
-	this->addEvent(message::BNDR_APPEND)
-		 .addEvent(message::BNDR_TRANSFER);
-}
+{}

src/phasicFlow/containers/pointField/boundaryField/periodicBoundaryField/periodicBoundaryField.hpp

@@ -61,29 +61,6 @@ public:
 		boundaryBase
 	);
 
-
-	bool hearChanges
-	(
-		real t,
-		real dt,
-		uint32 iter,
-		const message& msg, 
-    	const anyList& varList
-	) override
-    {
-		BoundaryFieldType::hearChanges(t,dt,iter, msg,varList);
-		
-		if(msg.equivalentTo(message::BNDR_APPEND))
-		{
-			// do nothing;
-		}
-		if(msg.equivalentTo(message::BNDR_TRANSFER))
-		{
-			//do nothing 
-		}
-		return true;
-	}
-
 };
 
 }

src/phasicFlow/containers/pointField/boundaryField/reflectiveBoundaryField/reflectiveBoundaryField.cpp

@@ -26,6 +26,4 @@ template<class T, class MemorySpace>
 )
 :
 	BoundaryFieldType(boundary, pStruct, internal)
-{
-	//this->addEvent(message::BNDR_DELETE);
-}
+{}

src/phasicFlow/containers/pointField/boundaryField/reflectiveBoundaryField/reflectiveBoundaryField.hpp

@@ -61,26 +61,10 @@ public:
 		boundaryBase
 	);
 
-
-	bool hearChanges
-	(
-		real t,
-		real dt,
-		uint32 iter,
-		const message& msg, 
-    	const anyList& varList
-	) override
+	bool isActive()const override
 	{
-		BoundaryFieldType::hearChanges(t,dt,iter, msg,varList);
-		
-		if(msg.equivalentTo(message::BNDR_DELETE))
-		{
-			// do nothing;
+		return false;
 	}
-		
-		return true;
-	}
-
 };
 
 }

src/phasicFlow/containers/pointField/internalField/internalField.cpp

@@ -21,7 +21,15 @@ Licence:
 template<class T, class MemorySpace>
 bool pFlow::internalField<T, MemorySpace>::insert(const anyList& varList)
 {
-	const word eventName = message::eventName(message::ITEM_INSERT);
+	
+	const word eventName = message::eventName(message::ITEMS_INSERT);
+
+	if(!varList.checkObjectType<uint32IndexContainer>(eventName))
+	{
+		fatalErrorInFunction<<"Insertion failed in internalField, "<< eventName <<
+		" does not exist or the type is incorrect"<<endl;
+		return false;
+	}
 
 	const auto& indices = varList.getObject<uint32IndexContainer>(
 		eventName);
@@ -30,14 +38,24 @@ bool pFlow::internalField<T, MemorySpace>::insert(const anyList& varList)
 	if(varList.contains(name()))
 	{
 		// a single value is assigned
+		if(!varList.checkObjectType<T>(name()))
+		{
+			fatalErrorInFunction<<"wrong type for variable "<< name()<<endl;
+			return false;
+		}
 		T val = varList.getObject<T>(name());
 		success = field_.insertSetElement(indices, val);
 		
 	}
-	else if(varList.contains(name()+"Vector"))
+	else if(word fn = name()+"Vector"; varList.contains(fn))
 	{
 		// a vector of values is going to be assigned
-		const auto& valVec = varList.getObject<Vector<T>>(name()+"Vector");
+		if(!varList.checkObjectType<Vector<T>>(fn))
+		{
+			fatalErrorInFunction<<"wrong type for variable "<< fn<<endl;
+			return false;
+		}
+		const auto& valVec = varList.getObject<Vector<T>>(fn);
 		success = field_.insertSetElement(indices,valVec);
 	}
 	else
@@ -57,8 +75,13 @@ bool pFlow::internalField<T, MemorySpace>::insert(const anyList& varList)
 template<class T, class MemorySpace>
 bool pFlow::internalField<T, MemorySpace>::rearrange(const anyList& varList)
 {
-	const word eventName = message::eventName(message::ITEM_REARRANGE);
+	const word eventName = message::eventName(message::ITEMS_REARRANGE);
 
+	if(!varList.checkObjectType<uint32IndexContainer>(eventName))
+	{
+		fatalErrorInFunction<<"Wrong type for variable "<< eventName<<endl;
+		return false;
+	}
 	const auto& indices = varList.getObject<uint32IndexContainer>(
 		eventName);
 	
@@ -162,40 +185,49 @@ typename pFlow::internalField<T, MemorySpace>::FieldTypeHost
 template <class T, class MemorySpace>
 bool pFlow::internalField<T, MemorySpace>:: hearChanges
 (
-	real t,
-	real dt,
-	uint32 iter,
+	const timeInfo& ti,
 	const message& msg, 
 	const anyList& varList
 )
 {
-	if(msg.equivalentTo(message::CAP_CHANGED))
+	if(msg.equivalentTo(message::RANGE_CHANGED))
 	{
-		auto newCap = varList.getObject<uint32>(
-			message::eventName(message::CAP_CHANGED));
+		auto varName = message::eventName(message::RANGE_CHANGED);
+		if( !varList.checkObjectType<rangeU32>(varName) )
+		{
+			fatalErrorInFunction<<"Wrong type for variable "<< varName<<endl<<
+			"You requested "<< getTypeName<rangeU32>()<<" but the type is"<<
+			varList.getObjectTypeName(varName)<<endl;
+			return false;
+		}
 
-		field_.reserve(newCap);
+		auto newRange = varList.getObject<rangeU32>(varName);
+
+		if(newRange.end() > size()) 
+			field_.resize(newRange.end());
+		return true;
 	}
-	if(msg.equivalentTo(message::SIZE_CHANGED))
-	{
-		auto newSize = varList.getObject<uint32>(
-			message::eventName(message::SIZE_CHANGED));
-		field_.resize(newSize);
-	}
-	if(msg.equivalentTo(message::ITEM_DELETE))
+	else if(msg.equivalentTo(message::ITEMS_DELETE))
 	{
 		// do nothing
+		return true;
 	}
-	if(msg.equivalentTo(message::ITEM_INSERT))
+	else if(msg.equivalentTo(message::ITEMS_INSERT))
 	{
 		return insert(varList);
 	}
-	if(msg.equivalentTo(message::ITEM_REARRANGE))
+	else if(msg.equivalentTo(message::ITEMS_REARRANGE))
 	{
 		return rearrange(varList);
-
 	}
-	return true;
+	else
+	{
+		fatalErrorInFunction<<"hear changes in internal field is not processing "<< 
+		message::eventName(message::RANGE_CHANGED)<<
+		" event with message code "<< msg<<endl;
+		return false;
+	}
+	
 }
 
 template<class T, class MemorySpace>

src/phasicFlow/containers/pointField/internalField/internalField.hpp

@@ -64,11 +64,10 @@ protected:
 	static inline
 	const message defaultMessage_ = 
 	(
-		message::CAP_CHANGED+
-		message::SIZE_CHANGED+
-		message::ITEM_INSERT+
-		message::ITEM_REARRANGE+
-		message::ITEM_DELETE
+		message::RANGE_CHANGED   +
+		message::ITEMS_INSERT    +
+		message::ITEMS_REARRANGE +
+		message::ITEMS_DELETE
 	);
 	
 	bool insert(const anyList& varList);
@@ -188,11 +187,15 @@ public:
 		return internalPoints_.time();
 	}
 
+	inline 
+	const internalPoints& InternalPoints()const
+	{
+		return internalPoints_;
+	}
+
 	bool hearChanges
 	(
-		real t,
-		real dt,
-		uint32 iter,
+		const timeInfo& ti,
 		const message& msg, 
 		const anyList& varList
 	) override;

src/phasicFlow/containers/span/span.hpp

@@ -26,11 +26,15 @@ Licence:
 
 namespace pFlow {
 
-
+/// 
+/// @class span
+/// @brief Represents a view into a contiguous sequence of elements.
+/// 
+/// `span` provides a lightweight way to work with arrays and other contiguous 
+/// sequences without the overhead of copying. This will word on both GPU and CPU
 template<typename T>
 class span
 {
-
 public:
     
     using iterator        = T*;
@@ -47,39 +51,40 @@ public:
     
     using constPointer    = const T*;
 
-protected:
+private:
 
-    T* data_ 		= nullptr;
+    mutable T*     data_ = nullptr;
  
-    uint32 	size_ 	= 0;
+    index          size_ = 0;
 
 public:
     
     TypeInfoTemplateNV11("span", T);
 
-    /// Constructor
+    /// Constructor with no arguments
     INLINE_FUNCTION_HD
     span() = default;
 
 
+    /// Constructor that takes a pointer to the beginning of the data and the size of the span
     INLINE_FUNCTION_HD
     span(T* data, uint32 size)
         : data_(data), size_(size)
     {}
 
-    /// copy
+    /// copy constructor
     INLINE_FUNCTION_HD
     span(const span&) = default;
 
-    /// assignment
+    /// copy assignment operator
     INLINE_FUNCTION_HD
     span& operator=(const span&) = default;
 
-    /// move
+    /// move constructor
     INLINE_FUNCTION_HD
     span(span&&) = default;
 
-    /// assignment
+    /// move assignment operator
     INLINE_FUNCTION_HD
     span& operator=(span&) = default;
 
@@ -90,6 +95,7 @@ public:
         return size_ == 0;
     }
 
+    /// Returns a pointer to the beginning of the data
     INLINE_FUNCTION_HD
     T* data() const
     {
@@ -98,7 +104,7 @@ public:
 
     /// Returns the number of elements in the span
     INLINE_FUNCTION_HD
-    uint32 size() const
+    index size() const
     {
         return size_;
     }
@@ -110,7 +116,7 @@ public:
         return data_;
     }
 
-    /// Returns an iterator to the beginning of the span
+    /// Returns an iterator to the beginning of the span (const version)
     INLINE_FUNCTION_HD
     constIterator cbegin() const
     {
@@ -124,54 +130,34 @@ public:
         return data_ + size_;
     }
 
-    /// Returns an iterator to one past the end of the span
+    /// Returns an iterator to one past the end of the span (const version)
     INLINE_FUNCTION_HD
     constIterator cend() const
     {
         return data_ + size_;
     }
 
+    /// Returns a reference to the element at the specified index
     INLINE_FUNCTION_HD
-    T& operator[](uint32 i)
+    T& operator[](index i)
     {
         return data_[i];
     }
 
+    /// Returns a const reference to the element at the specified index
     INLINE_FUNCTION_HD
-    const T& operator[](uint32 i)const
-    {
-    	return data_[i];
-    }
-
-    INLINE_FUNCTION_HD
-    T& operator[](int32 i)
-    {
-    	return data_[i];
-    }
-
-    INLINE_FUNCTION_HD
-    const T& operator[](int32 i)const
+    T& operator[](index i)const
     {
         return data_[i];
     }
 
 };
 
-/*template<typename T, typename... properties, template<class, class...> class Container>
-size_t makeSpan(Container<T, properties...>& container)
-{
-    return span<T>(container.data(), container.size());
-}
-
-template<typename T, typename... properties, template<class, class...> class Container>
-size_t makeSpan(const Container<T, properties...>& container)
-{
-    return span<T>(
-        const_cast<T*>(container.data()), 
-        container.size());
-}*/
-
 
+/// Creates a span of char from a span of any type.
+/// 
+/// This helper function reinterprets the underlying memory of the given span 
+/// as a span of char.
 template<typename T>
 inline
 span<char> charSpan(span<T> s)
@@ -182,6 +168,10 @@ span<char> charSpan(span<T> s)
 		s.size()*el);
 }
 
+/// Creates a span of const char from a span of const any type.
+/// 
+/// This helper function reinterprets the underlying memory of the given span 
+/// as a span of const char.
 template<typename T>
 inline
 span<const char> charSpan(span<const T> s)
@@ -192,24 +182,6 @@ span<const char> charSpan(span<const T> s)
 		s.size()*el);
 }
 
-/*template<typename T, template<class> class Container>
-span<T> makeSpan(Container<T>& container)
-{
-    return span<T>(container.data(), container.size());
-}
-
-template<typename T, template<class> class Container>
-span<T> makeSpan(const Container<T>& container)
-{
-    return span<T>(
-        const_cast<T*>(container.data()), 
-        container.size());
-}*/
-
-
-
-
-
 
 } // pFlow