Bug fix for observed in particles, getNth and naming for contact lists

update benchmarks file and romove the unused comments in rotatingDrumMedium

CMakeLists.txt

@@ -3,30 +3,17 @@ cmake_minimum_required(VERSION 3.16 FATAL_ERROR)
 # set the project name and version
 project(phasicFlow VERSION 1.0 )
 
-set(CMAKE_CXX_STANDARD 17 CACHE STRING "" FORCE)
+set(CMAKE_CXX_STANDARD 20 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")
 set(BUILD_SHARED_LIBS ON CACHE BOOL "Build using shared libraries" FORCE)
 mark_as_advanced(FORCE var BUILD_SHARED_LIBS)
 
-message(STATUS ${CMAKE_INSTALL_PREFIX})
+message(STATUS "Install prefix is:" ${CMAKE_INSTALL_PREFIX})
 
 include(cmake/globals.cmake)
 
-#Kokkos directory to be included 
-set(Kokkos_Source_DIR)
-
-if(DEFINED ENV{Kokkos_DIR})
-   set(Kokkos_Source_DIR $ENV{Kokkos_DIR})
-else()
-  set(Kokkos_Source_DIR $ENV{HOME}/Kokkos/kokkos)
-endif()
-message(STATUS "Kokkos source directory is ${Kokkos_Source_DIR}")
-add_subdirectory(${Kokkos_Source_DIR} ./kokkos)
-Kokkos_cmake_settings()
-
-
 option(pFlow_STD_Parallel_Alg "Use TTB std parallel algorithms" ON)
 option(pFlow_Build_Serial "Build phasicFlow and backends for serial execution" OFF)
 option(pFlow_Build_OpenMP "Build phasicFlow and backends for OpenMP execution" OFF)
@@ -34,6 +21,8 @@ option(pFlow_Build_Cuda   "Build phasicFlow and backends for Cuda execution" OFF
 option(pFlow_Build_Double "Build phasicFlow with double precision floating-oint variables" ON)
 option(pFlow_Build_MPI    "Build for MPI parallelization. This will enable multi-gpu run, CPU run on clusters (distributed memory machine). Use this combination Cuda+MPI, OpenMP + MPI or Serial+MPI " OFF)
 
+#for installing the required packages
+include(cmake/preReq.cmake)
 
 if(pFlow_Build_Serial)
 	set(Kokkos_ENABLE_SERIAL ON CACHE BOOL "Serial execution" FORCE) 
@@ -46,7 +35,8 @@ elseif(pFlow_Build_OpenMP )
 	set(Kokkos_ENABLE_OPENMP ON CACHE BOOL "OpenMP execution" FORCE)
 	set(Kokkos_ENABLE_CUDA OFF CACHE BOOL "Cuda execution" FORCE)
 	set(Kokkos_ENABLE_CUDA_LAMBDA OFF CACHE BOOL "Cuda execution" FORCE)
-	set(Kokkos_DEFAULT_HOST_PARALLEL_EXECUTION_SPACE SERIAL CACHE STRING "" FORCE)
+	set(Kokkos_DEFAULT_HOST_PARALLEL_EXECUTION_SPACE Serial CACHE STRING "" FORCE)
+	set(Kokkos_DEFAULT_DEVICE_PARALLEL_EXECUTION_SPACE OpenMP CACHE STRING "" FORCE)
 	set(Kokkos_ENABLE_CUDA_CONSTEXPR OFF CACHE BOOL "Enable constexpr on cuda code" FORCE)
 elseif(pFlow_Build_Cuda)
 	set(Kokkos_ENABLE_SERIAL ON CACHE BOOL "Serial execution" FORCE) 
@@ -65,6 +55,7 @@ include(cmake/makeExecutableGlobals.cmake)
 
 configure_file(phasicFlowConfig.H.in phasicFlowConfig.H)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
 #add a global include directory 
 include_directories(src/setHelpers src/demComponent "${PROJECT_BINARY_DIR}")
 

DEMSystems/DEMSystem/DEMSystem.hpp

@@ -183,4 +183,4 @@ public:
 
 } // pFlow
 
-#endif // __DEMSystem_hpp__
+#endif // __DEMSystem_hpp__

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)
+    const grainShape& grains)
-    : grainParticles(control, prop),
+    : 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

@@ -74,13 +74,19 @@ pFlow::sphereDEMSystem::sphereDEMSystem(
 	property_ = makeUnique<property>(
 		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)
+    const sphereShape& shpShape)
-    : sphereParticles(control, prop),
+    : 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;

README.md

@@ -1,48 +1,66 @@
-<div align ="center">
+<div align="center">
-<img src="doc/phasicFlow_logo_github.png" style="width: 400px;">
+  <img src="doc/phasicFlow_logo_github.png" style="width: 400px;" alt="PhasicFlow Logo">
 </div>
 
+## **PhasicFlow: High-Performance Discrete Element Method Simulations**
 
-**PhasicFlow** is a parallel C++ code for performing DEM simulations. It can run on shared-memory multi-core computational units such as multi-core CPUs or GPUs (for now it works on CUDA-enabled GPUs). The parallelization method mainly relies on loop-level parallelization on a shared-memory computational unit. You can build and run PhasicFlow in serial mode on regular PCs, in parallel mode for multi-core CPUs, or build it for a GPU device to off-load computations to a GPU. In its current statues you can simulate millions of particles (up to 80M particles tested) on a single desktop computer. You can see the [performance tests of PhasicFlow](https://github.com/PhasicFlow/phasicFlow/wiki/Performance-of-phasicFlow) in the wiki page.
+PhasicFlow is a robust, open-source C++ framework designed for the efficient simulation of granular materials using the Discrete Element Method (DEM). Leveraging parallel computing paradigms, PhasicFlow is capable of executing simulations on shared-memory multi-core architectures, including CPUs and NVIDIA GPUs (CUDA-enabled). The core parallelization strategy focuses on loop-level parallelism, enabling significant performance gains on modern hardware. Users can seamlessly transition between serial execution on standard PCs, parallel execution on multi-core CPUs (OpenMP), and accelerated simulations on GPUs. Currently, PhasicFlow supports simulations involving up to 80 million particles on a single desktop workstation. Detailed performance benchmarks are available on the [PhasicFlow Wiki](https://github.com/PhasicFlow/phasicFlow/wiki/Performance-of-phasicFlow).
 
-**MPI** parallelization with dynamic load balancing is under development. With this level of parallelization, PhasicFlow can leverage the computational power of **multi-gpu** workstations or clusters with distributed memory CPUs. 
+**Scalable Parallelism: MPI Integration**
-In summary PhasicFlow can have 6 execution modes:
-1. Serial on a single CPU core,
-2. Parallel on a multi-core computer/node (using OpenMP),
-3. Parallel on an nvidia-GPU (using Cuda),
-4. Parallel on distributed memory workstation (Using MPI)
-5. Parallel on distributed memory workstations with multi-core nodes (using MPI+OpenMP)
-6. Parallel on workstations with multiple GPUs (using MPI+Cuda).
-## How to build?
-You can build PhasicFlow for CPU and GPU executions. The latest release of PhasicFlow is v-0.1. [Here is a complete step-by-step procedure for building phasicFlow-v-0.1.](https://github.com/PhasicFlow/phasicFlow/wiki/How-to-Build-PhasicFlow).
 
-## Online code documentation
+Ongoing development includes the integration of MPI-based parallelization with dynamic load balancing. This enhancement will extend PhasicFlow's capabilities to distributed memory environments, such as multi-GPU workstations and high-performance computing clusters. Upon completion, PhasicFlow will offer six distinct execution modes:
-You can find a full documentation of the code, its features, and other related materials on [online documentation of the code](https://phasicflow.github.io/phasicFlow/)
 
-## How to use PhasicFlow?
+1.  **Serial Execution:** Single-core CPU.
-You can navigate into [tutorials folder](./tutorials) in the phasicFlow folder to see some simulation case setups. If you need more detailed discription, visit our [wiki page tutorials](https://github.com/PhasicFlow/phasicFlow/wiki/Tutorials).  
+2.  **Shared-Memory Parallelism:** Multi-core CPU (OpenMP).
+3.  **GPU Acceleration:** NVIDIA GPU (CUDA).
+4.  **Distributed-Memory Parallelism:** MPI.
+5.  **Hybrid Parallelism:** MPI + OpenMP.
+6.  **Multi-GPU Parallelism:** MPI + CUDA.
 
-## [PhasicFlowPlus](https://github.com/PhasicFlow/PhasicFlowPlus)
+# **Build and Installation**
-PhasicFlowPlus is and extension to PhasicFlow for simulating particle-fluid systems using resolved and unresolved CFD-DEM. [See the repository of this package.](https://github.com/PhasicFlow/PhasicFlowPlus)
+
+PhasicFlow can be compiled for both CPU and GPU execution.
+
+* **Current Development (v-1.0):** Comprehensive build instructions are available [here](https://github.com/PhasicFlow/phasicFlow/wiki/How-to-build-PhasicFlow%E2%80%90v%E2%80%901.0).
+* **Latest Release (v-0.1):** Detailed build instructions are available [here](https://github.com/PhasicFlow/phasicFlow/wiki/How-to-Build-PhasicFlow).
+
+# **Comprehensive Documentation**
+
+In-depth documentation, including code structure, features, and usage guidelines, is accessible via the [online documentation portal](https://phasicflow.github.io/phasicFlow/).
+
+## **Tutorials and Examples**
+
+Practical examples and simulation setups are provided in the [tutorials directory](./tutorials). For detailed explanations and step-by-step guides, please refer to the [tutorial section on the PhasicFlow Wiki](https://github.com/PhasicFlow/phasicFlow/wiki/Tutorials).
+
+# **PhasicFlowPlus: Coupled CFD-DEM Simulations**
+
+PhasicFlowPlus is an extension of PhasicFlow that facilitates the simulation of particle-fluid systems using resolved and unresolved CFD-DEM methods. The repository for PhasicFlowPlus can be found [here](https://github.com/PhasicFlow/PhasicFlowPlus).
 
 
-## Supporting packages
+# How to cite PhasicFlow?
-* [Kokkos](https://github.com/kokkos/kokkos) from National Technology & Engineering Solutions of Sandia, LLC (NTESS)
-* [CLI11 1.8](https://github.com/CLIUtils/CLI11) from University of Cincinnati.
 
-## How to cite PhasicFlow
 If you are using PhasicFlow in your research or industrial work, cite the following [article](https://www.sciencedirect.com/science/article/pii/S0010465523001662):
+
 ```
-@article{NOROUZI2023108821,
+@article
-title = {PhasicFlow: A parallel, multi-architecture open-source code for DEM simulations},
+{
-journal = {Computer Physics Communications},
+  NOROUZI2023108821,
-volume = {291},
+  title = {PhasicFlow: A parallel, multi-architecture open-source code for DEM simulations},
-pages = {108821},
+  journal = {Computer Physics Communications},
-year = {2023},
+  volume = {291},
-issn = {0010-4655},
+  pages = {108821},
-doi = {https://doi.org/10.1016/j.cpc.2023.108821},
+  year = {2023},
-url = {https://www.sciencedirect.com/science/article/pii/S0010465523001662},
+  issn = {0010-4655},
-author = {H.R. Norouzi},
+  doi = {https://doi.org/10.1016/j.cpc.2023.108821},
-keywords = {Discrete element method, Parallel computing, CUDA, GPU, OpenMP, Granular flow}
+  url = {https://www.sciencedirect.com/science/article/pii/S0010465523001662},
+  author = {H.R. Norouzi},
+  keywords = {Discrete element method, Parallel computing, CUDA, GPU, OpenMP, Granular flow}
 }
 ```
+
+# **Dependencies**
+
+PhasicFlow relies on the following external libraries:
+
+* **Kokkos:** A performance portability ecosystem developed by National Technology & Engineering Solutions of Sandia, LLC (NTESS). ([https://github.com/kokkos/kokkos](https://github.com/kokkos/kokkos))
+* **CLI11 1.8:** A command-line interface parser developed by the University of Cincinnati. ([https://github.com/CLIUtils/CLI11](https://github.com/CLIUtils/CLI11))

benchmarks/rotatingDrum_4MParticles/caseSetup/interaction

@@ -3,57 +3,58 @@
 |  copyright: www.cemf.ir                                                     | 
 \* ------------------------------------------------------------------------- */ 
 
-objectName interaction;
+objectName     interaction;
-objectType dicrionary;
+objectType     dictionary;
+fileFormat     ASCII;
+
+/*---------------------------------------------------------------------------*/
 
 materials   (glassMat wallMat); // a list of materials names
+
 densities   (2500.0 2500);      // density of materials [kg/m3]
 
 contactListType   sortedContactList;
 
-model
-{
-   contactForceModel nonLinearLimited;
-   rollingFrictionModel normal;
-
-   Yeff (1.0e6 1.0e6  // Young modulus [Pa]
-               1.0e6);
-   
-   Geff (0.8e6 0.8e6  // Shear modulus [Pa]
-               0.8e6);
-
-   nu    (0.25 0.25  // Poisson's ratio [-]
-               0.25);
-
-   en (0.97  0.85   // coefficient of normal restitution
-             1.00);
-
-   et (1.0   1.0    // coefficient of tangential restitution 
-             1.0);
-
-   mu (0.65  0.65   // dynamic friction 
-             0.65);
-
-   mur (0.1  0.1    // rolling friction 
-             0.1);
-        
-}
-
 contactSearch
 {
-   method         NBS;           
+    method         NBS;
-   wallMapping    cellMapping;   
 
-   NBSInfo
+    updateInterval   10;
-   {
-      updateFrequency 10;        // each 20 timesteps, update neighbor list 
-      sizeRatio      1.05;       // bounding box size to particle diameter (max)
-   }
 
-   cellMappingInfo
+    sizeRatio       1.1;
-   {
+
-      updateFrequency 10;        // each 20 timesteps, update neighbor list  
+    cellExtent     0.55;
-      cellExtent     0.6;        // bounding box for particle-wall search (> 0.5)
+
-   }
+    adjustableBox   Yes;
+}
+
+model
+{
+    contactForceModel    nonLinearLimited;
+
+    rollingFrictionModel normal;
+    
+    /*
+       Property (glassMat-glassMat      glassMat-wallMat
+                                        wallMat-wallMat);
+    */
+
+    Yeff (1.0e6  1.0e6  
+                 1.0e6);                                    // Young modulus [Pa]
+   
+    Geff (0.8e6  0.8e6  
+                 0.8e6);                                    // Shear modulus [Pa]
+
+    nu   (0.25   0.25  
+                 0.25);                                     // Poisson's ratio [-]
+
+    en   (0.97   0.85   
+                 1.00);                                     // coefficient of normal restitution
+
+    mu   (0.65   0.65   
+                 0.65);                                     // dynamic friction 
+
+    mur  (0.1    0.1    
+                 0.1);                                      // rolling friction 
+}
 
-}

benchmarks/rotatingDrum_4MParticles/caseSetup/particleInsertion

@@ -3,12 +3,10 @@
 |  copyright: www.cemf.ir                                                     | 
 \* ------------------------------------------------------------------------- */ 
 
-objectName particleInsertion;
+objectName     particleInsertion;
-objectType dicrionary;
+objectType     dicrionary;
-
+fileFormat     ASCII;
-
+
-active  no;          // is insertion active?
+active  No;          // is insertion active?
-
-collisionCheck No;   // not implemented for yes
 
 

benchmarks/rotatingDrum_4MParticles/caseSetup/shapes

@@ -2,12 +2,14 @@
 |  phasicFlow File                                                            | 
 |  copyright: www.cemf.ir                                                     | 
 \* ------------------------------------------------------------------------- */ 
-objectName particleInsertion;
+
-objectType dicrionary;
+objectName     shapes;
-fileFormat  ASCII;
+objectType     dictionary;
+fileFormat     ASCII;
 /*---------------------------------------------------------------------------*/
-active         No;                               // is insertion active -> Yes or No
 
-collisionCheck No;                               // is checked          -> Yes or No
+names          (glassBead);    // names of shapes 
 
+diameters      (0.003);        // diameter of shapes 
 
+materials      (glassMat);     // material names for shapes 

benchmarks/rotatingDrum_4MParticles/caseSetup/sphereShape

@@ -1,11 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */ 
-
-objectName 	sphereDict;
-objectType 	sphereShape;
-
-names 		(glassBead); 	// names of shapes 
-diameters 	(0.003);		// diameter of shapes 
-materials	(glassMat);		// material names for shapes 

benchmarks/rotatingDrum_4MParticles/settings/domainDict

@@ -0,0 +1,46 @@
+/* -------------------------------*- C++ -*--------------------------------- *\ 
+|  phasicFlow File                                                            | 
+|  copyright: www.cemf.ir                                                     | 
+\* ------------------------------------------------------------------------- */  
+objectName     domainDict;
+objectType     dictionary;
+fileFormat     ASCII;
+/*---------------------------------------------------------------------------*/
+globalBox                                        // Simulation domain: every particles that goes outside this domain will be deleted
+{
+    min (-0.2 -0.2 -0.0);
+    max ( 0.2  0.2  1.6);
+}
+
+boundaries
+{
+    left
+    {
+        type    exit;                            // other options: periodic, reflective 
+    }
+
+    right
+    {
+        type     exit;                           // other options: periodic, reflective 
+    }
+
+    bottom
+    {
+        type     exit;                           // other options: periodic, reflective 
+    }
+
+    top
+    {
+        type     exit;                           // other options: periodic, reflective 
+    }
+
+    rear
+    {
+        type     exit;                           // other options: periodic, reflective 
+    }
+
+    front
+    {
+        type     exit;                           // other options: periodic, reflective 
+    }
+}

benchmarks/rotatingDrum_4MParticles/settings/geometryDict

@@ -3,61 +3,84 @@
 |  copyright: www.cemf.ir                                                     | 
 \* ------------------------------------------------------------------------- */  
 
-objectName 	geometryDict;
+objectName     geometryDict;
-objectType 	dictionary;
+objectType     dictionary;
+fileFormat     ASCII;
 
-motionModel rotatingAxisMotion; 
+motionModel rotatingAxis;         // motion model: rotating object around an axis
+
+rotatingAxisInfo                  // information for rotatingAxisMotion motion model 
+{
+    rotAxis 
+    {
+        p1    (0.0 0.0 0.0);      // first point for the axis of rotation    
+        
+        p2    (0.0 0.0 1.0);      // second point for the axis of rotation    
+        
+        omega 1.256;              // rotation speed (rad/s) => 12 rpm
+    }
+}
 
 surfaces
 {
-	
+    cylinder
-	cylinder
+    {
-	{
+        type        cylinderWall;          // type of the wall
-		type cylinderWall;  
+        
-		p1 (0.0 0.0 0.0);   
+        p1          (0.0 0.0 0.0);         // begin point of cylinder axis
-		p2 (0.0 0.0 1.6);  
+           
-		radius1 0.2;		
+        p2          (0.0 0.0 1.6);         // end point of cylinder axis
-		radius2 0.2;		
+        
-		resolution 24;      
+        radius1     0.2;                   // radius at p1
-		material wallMat;   
+        
-		motion rotAxis;
+        radius2     0.2;                   // radius at p2
-	}
+        
+        resolution  24;                    // number of divisions
+        
+        material    wallMat;               // material name of this wall
+        
+        motion      rotAxis;               // motion component name 
+    }
 
-	
+    /*
-	wall1
+        This is a plane wall at the rear end of cylinder
-	{
+    */
-		type planeWall;			
+    
-		p1 (-0.2 -0.2 0.0);	
+    wall1
-		p2 ( 0.2 -0.2 0.0);   
+    {
-		p3 ( 0.2  0.2 0.0);   
+        type      planeWall;               // type of the wall  
-		p4 (-0.2  0.2 0.0);   
+        
-		material wallMat;     
+        p1        (-0.2 -0.2 0.0);         // first point of the wall
-		motion rotAxis;		
+        
-	}
+        p2        ( 0.2 -0.2 0.0);         // second point
+        
+        p3        ( 0.2  0.2 0.0);         // third point
+        
+        p4        (-0.2  0.2 0.0);         // fourth point 
+        
+        material  wallMat;                 // material name of the wall  
+        
+        motion    rotAxis;                 // motion component name 
+    }
 
-	/*
+    /*
-	This is a plane wall at the front end of cylinder
+        This is a plane wall at the front end of cylinder
-	*/
+    */
-	wall2
+    
-	{
+    wall2
-		type planeWall;
+    {
-		p1 (-0.2 -0.2 1.6);
+        type      planeWall;               // type of the wall
-		p2 ( 0.2 -0.2 1.6);
+        
-		p3 ( 0.2  0.2 1.6);
+        p1        (-0.2 -0.2 1.6);         // first point of the wall
-		p4 (-0.2  0.2 1.6);
+        
-		material wallMat;
+        p2        ( 0.2 -0.2 1.6);         // second point
-		motion rotAxis;
+        
-	}
+        p3        ( 0.2  0.2 1.6);         // third point
-		
+        
+        p4        (-0.2  0.2 1.6);         // fourth point 
+        
+        material  wallMat;                 // material name of the wall  
+        
+        motion    rotAxis;                 // motion component name 
+    }
 }
-
-// information for rotatingAxisMotion motion model 
-rotatingAxisMotionInfo
-{
-	rotAxis 
-	{
-		p1 (0.0 0.0 0.0);	
-		p2 (0.0 0.0 1.0);	
-		omega 1.256; 		// rotation speed (rad/s) => 12 rpm
-	}
-}

benchmarks/rotatingDrum_4MParticles/settings/particlesDict

@@ -3,42 +3,45 @@
 |  copyright: www.cemf.ir                                                     | 
 \* ------------------------------------------------------------------------- */  
 
-objectName 	particlesDict;
+objectName     particlesDict;
-objectType 	dictionary;
+objectType     dictionary;
+fileFormat     ASCII;
 
 setFields
 {
-	
+    defaultValue 
-	defaultValue 
+    {
-	{
+        velocity         realx3     (0 0 0);     // linear velocity (m/s)
-		velocity 		realx3 	(0 0 0); // linear velocity (m/s)
+        acceleration     realx3     (0 0 0);     // linear acceleration (m/s2)
-		acceleration 	realx3 	(0 0 0); // linear acceleration (m/s2)
+        rotVelocity      realx3     (0 0 0);     // rotational velocity (rad/s)
-		rotVelocity 	realx3 	(0 0 0); // rotational velocity (rad/s)
+        shapeName        word       glassBead;   // name of the particle shape 
-		shapeName 		word	glassBead; // name of the particle shape 
+    }
-	}
 
-	selectors
+    selectors
-	{}
+    {}
 }
 
 positionParticles
 {
-	method positionOrdered;     		
+    method ordered;
 
-	maxNumberOfParticles 	4000001; 
+    orderedInfo
-	mortonSorting 			Yes;    
+    {
+        diameter   0.003;           // minimum space between centers of particles
+        
+        numPoints  4000000;         // number of particles in the simulation 
+        
+        axisOrder  (z x y);         // axis order for filling the space with particles
+    }
 
-	cylinder  // box for positioning particles 
+    regionType cylinder;            // other options: box and sphere    
-	{
+
-		p1 ( 0.0  0.0 0.01);    // lower corner point of the box 
+    cylinderInfo                    // cylinder for positioning particles 
-		p2 ( 0.0  0.0 1.59);	// upper corner point of the box 
+    {
-		radius 0.195;
+        p1     (0.0  0.0  0.01);    // lower corner point of the box 
-	}
+        
-	
+        p2     (0.0  0.0  1.59);    // upper corner point of the box 
-	positionOrderedInfo
+        
-	{
+        radius 0.195;               // radius of cylinder 
-		diameter 0.003; 	// minimum space between centers of particles
+    }
-		numPoints 4000000; 	// number of particles in the simulation 
-		axisOrder (z x y);  // axis order for filling the space with particles
-	}
 }

benchmarks/rotatingDrum_4MParticles/settings/settingsDict

@@ -2,31 +2,33 @@
 |  phasicFlow File                                                            | 
 |  copyright: www.cemf.ir                                                     | 
 \* ------------------------------------------------------------------------- */  
-objectName 	settingsDict;
+objectName    settingsDict;
-objectType 	dictionary;;
+objectType    dictionary;
+fileFormat    ASCII;
+/*---------------------------------------------------------------------------*/
+run             rotatingDrum_4MParticles;
 
-run 			rotatingDrum_1;
+dt              0.00001;      // time step for integration (s)
 
-dt 				0.00001; 	// time step for integration (s)
+startTime       0;            // start time for simulation 
 
-startTime 		0; 			// start time for simulation 
+endTime         10;           // end time for simulation 
 
-endTime 		10; 		// end time for simulation 
+saveInterval    0.2;          // time interval for saving the simulation
 
-saveInterval 	0.2; 		// time interval for saving the simulation
+timePrecision   5;            // maximum number of digits for time folder 
 
-timePrecision   5;			// maximum number of digits for time folder 
+g               (0 -9.8 0);   // gravity vector (m/s2) 
 
-g 				(0 -9.8 0); // gravity vector (m/s2) 
+includeObjects (diameter);                     // save necessary (i.e., required) data on disk
 
-domain 
+// exclude unnecessary data from saving on disk
-{
+excludeObjects (rVelocity.dy1 pStructPosition.dy1 pStructVelocity.dy1); 
-	min (-0.2 -0.2 -0.0);
-	max ( 0.2  0.2  1.6);
-}
 
-integrationMethod 		AdamsBashforth3; 	// integration method 
+integrationMethod         AdamsBashforth2;     // integration method 
 
-timersReport 			Yes;  	
+writeFormat               binary;              // data writting format (ascii or binary)
 
-timersReportInterval   	0.01;	
+timersReport              Yes;      
+
+timersReportInterval      0.05;    

cmake/autoComplete

@@ -1,17 +1,55 @@
 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
+    if [ "$3" == "--time" ]  ; then
-      COMPREPLY=( $(ls) )
+        __getAllTime
+    elif [ "$3" == "--fields" ]; then 
+    	__getFields
     else
-      COMPREPLY=( $(compgen -W "$PF_cFlags --binary --no-geometry --no-particles --out-folder --time --separate-surfaces --fields" -- "$2") )
+        COMPREPLY=( $(compgen -W "$PF_cFlags --binary --no-geometry --no-particles --out-folder --time --separate-surfaces --fields" -- "$2") )
     fi
 }
 complete -F _pFlowToVTK pFlowToVTK
 
 _postprocessPhasicFlow(){
     if [ "$3" == "--time" ]; then
-      COMPREPLY=( $(ls) )
+      __getAllTime
     else
       COMPREPLY=( $(compgen -W "$PF_cFlags --out-folder --time --zeroFolder" -- "$2") )
     fi

cmake/preReq.cmake

@@ -0,0 +1,54 @@
+if(pFlow_STD_Parallel_Alg)
+    # Check if libtbb-dev is installed
+    execute_process(
+        COMMAND dpkg -s libtbb-dev
+        RESULT_VARIABLE TBB_IS_INSTALLED
+        OUTPUT_QUIET
+        ERROR_QUIET)
+
+    if(NOT TBB_IS_INSTALLED EQUAL 0)
+        message(STATUS "libtbb-dev not found. Installing libtbb-dev...")
+        execute_process(
+            COMMAND sudo apt-get update
+            COMMAND sudo apt-get install -y libtbb-dev
+            RESULT_VARIABLE TBB_INSTALL_RESULT)
+            
+        if(NOT TBB_INSTALL_RESULT EQUAL 0)
+            message(FATAL_ERROR "Failed to install libtbb-dev")
+        endif()
+    else()
+        message(STATUS "libtbb-dev is already installed.")
+    endif()
+endif()
+
+
+# Kokkos folder creation 
+set(Kokkos_Source_DIR $ENV{HOME}/Kokkos/kokkos)
+
+if(NOT EXISTS "${Kokkos_Source_DIR}/CMakeLists.txt")
+
+    # Check CMake version and set policy CMP0169 if CMake version is 3.30 or higher
+    if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.30")
+        cmake_policy(SET CMP0169 OLD)
+    endif()
+
+    include(FetchContent)
+    FetchContent_Declare(
+        kokkos
+        GIT_REPOSITORY https://github.com/kokkos/kokkos.git
+        GIT_TAG 4.4.01
+    )
+    
+    FetchContent_GetProperties(kokkos)
+    if(NOT kokkos_POPULATED)
+        message(STATUS "Kokkos source directory not found. Downloading Kokkos version 4.4.1 ...")
+        FetchContent_Populate(kokkos)
+        set(Kokkos_Source_DIR ${kokkos_SOURCE_DIR})
+    endif()
+
+endif()
+
+message(STATUS "Kokkos source directory is ${Kokkos_Source_DIR}")
+add_subdirectory(${Kokkos_Source_DIR} ./kokkos)
+#Kokkos_cmake_settings()
+

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;

solvers/sphereGranFlow/sphereGranFlow.cpp

@@ -74,7 +74,7 @@ pFlow::initialize_pFlowProcessors();
 
 	do 
 	{
-		
+		//Ping;
 		if(! sphInsertion.insertParticles( 
 			Control.time().currentIter(),
 			Control.time().currentTime(),
@@ -84,27 +84,31 @@ pFlow::initialize_pFlowProcessors();
 			"particle insertion failed in sphereDFlow solver.\n";
 			return 1;
 		}
-		 
+		
 		// set force to zero
 		surfGeometry.beforeIteration();
 
 		// set force to zero, predict, particle deletion and etc. 
 		sphParticles.beforeIteration();
-
+		//Ping;
 		sphInteraction.beforeIteration();
 		
-		sphInteraction.iterate();	
+		sphInteraction.iterate();
-		
+			
 		surfGeometry.iterate();
 
+		//Ping;
 		sphParticles.iterate();
-
+		
+		//Ping;
 		sphInteraction.afterIteration();
 
+		//Ping;
 		surfGeometry.afterIteration();
 
+		//Ping;
 		sphParticles.afterIteration();
-				
+		//Ping;	
 
 	}while(Control++);
 

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::hearChanges
-bool pFlow::AdamsBashforth2::setInitialVals(
+(
-	const int32IndexContainer& newIndices,
+	const timeInfo &ti, 
-	const realx3Vector& y)
+	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);
@@ -54,6 +58,16 @@ private:
 	{
 		return static_cast<realx3PointField_D&>(*this);
 	}
+
+	auto& initialValField()
+	{
+		return initialValField_;
+	}
+
+	boundaryIntegrationList& boundaryList()
+	{
+		return boundaryList_;
+	}
 	
 public:
 
@@ -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,
+			const timeInfo& ti,
-			real dt,
-			uint32 iter,
 			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"
 
+namespace pFlow
+{
+
+/// Range policy for integration kernel (alias)
+using rpIntegration = Kokkos::RangePolicy<
+		DefaultExecutionSpace,
+		Kokkos::Schedule<Kokkos::Static>,
+		Kokkos::IndexType<uint32>
+		>;
+
+bool intAllActive(
+	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();
+
+	Kokkos::parallel_for(
+		"AdamsBashforth3::correct",
+		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,
-	repository& owner,
+	pointStructure& pStruct,
-	const pointStructure& pStruct,
+	const word& method,
-	const word& method
+	const realx3Field_D& initialValField
 )
 :
-	integration(baseName, owner, pStruct, method),
+	AdamsBashforth2(baseName, pStruct, method, initialValField),
-	history_(
+	dy2_
-		owner.emplaceObject<pointField<VectorSingle,AB3History>>(
+	(
-			objectFile(
+		objectFile
-				groupNames(baseName,"AB3History"),
+		(
-				"",
+			groupNames(baseName,"dy2"),
-				objectFile::READ_IF_PRESENT,
+			pStruct.time().integrationFolder(),
-				objectFile::WRITE_ALWAYS),
+			objectFile::READ_IF_PRESENT,
-			pStruct,
+			objectFile::WRITE_ALWAYS
-			AB3History({zero3,zero3})))
+		),
+		pStruct,
+		zero3,
+		zero3
+	)
 
 {
 	
 }
 
-bool pFlow::AdamsBashforth3::predict
+void pFlow::AdamsBashforth3::updateBoundariesSlaveToMasterIfRequested()
-(
-	real UNUSED(dt),
-	realx3Vector_D& UNUSED(y),
-	realx3Vector_D& UNUSED(dy)
-)
 {
-
+	AdamsBashforth2::updateBoundariesSlaveToMasterIfRequested();
-	return true;
+	dy2_.updateBoundariesSlaveToMasterIfRequested();
 }
 
+
+
 bool pFlow::AdamsBashforth3::correct
 (
-	real dt,
+	real dt, 
-	realx3Vector_D& y,
+	realx3PointField_D& y, 
-	realx3Vector_D& dy
+	realx3PointField_D& dy,
+	real damping
 )
 {
 	
-	if(this->pStruct().allActive())
+	bool success = false;
+	if(y.isAllActive())
 	{
-		return intAll(dt, y, dy, this->pStruct().activeRange());
+		success = intAllActive(dt, y.field(), dy, dy1(), dy2(), damping);
 	}
 	else
 	{
-		return intRange(dt, y, dy, this->pStruct().activePointsMaskD());
+		success = intScattered(dt, y.field(), dy, dy1(), dy2(), damping);
 	}
 
-	return true;
+	success = success && boundaryList().correct(dt, y, dy);
+
+	return success;
 }
 
-bool pFlow::AdamsBashforth3::setInitialVals(
+bool pFlow::AdamsBashforth3::correctPStruct(
-	const int32IndexContainer& newIndices,
-	const realx3Vector& y)
-{
-	return true;
-}
-
-bool pFlow::AdamsBashforth3::intAll(
 	real dt, 
-	realx3Vector_D& y, 
+	pointStructure &pStruct, 
-	realx3Vector_D& dy, 
+	realx3PointField_D &vel)
-	range activeRng)
 {
-	auto d_dy = dy.deviceViewAll();
+	
-	auto d_y  = y.deviceViewAll();
+	bool success = false;
-	auto d_history = history_.deviceViewAll();
+	if(dy2().isAllActive())
+	{
+		success = intAllActive(dt, pStruct.pointPosition(), vel, dy1(), dy2());
+	}
+	else
+	{
+		success = intScattered(dt, pStruct.pointPosition(), vel, dy1(), dy2());
+	}
 
-	Kokkos::parallel_for(
+	success = success && boundaryList().correctPStruct(dt, pStruct, vel);
-		"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_};
-		});
-	Kokkos::fence();
 
-	return true;	
+	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
 {
-protected:
+private:
 	
-	/// Integration history
+	friend class processorAB3BoundaryIntegration;
-	pointField<VectorSingle,AB3History>& history_;
 
-	/// Range policy for integration kernel
+	realx3PointField_D 		dy2_;
-	using rpIntegration = Kokkos::RangePolicy<
+
-			DefaultExecutionSpace,
+protected:
-			Kokkos::Schedule<Kokkos::Static>,
+
-			Kokkos::IndexType<int32>
+	const auto& dy2()const
-			>;
+	{
+		return dy2_;
+	}
+
+	auto& dy2()
+	{
+		return dy2_;
+	}
+	
 
 public:
 
@@ -96,17 +69,13 @@ public:
 		/// Construct from components
 		AdamsBashforth3(
 			const word& baseName,
-			repository& owner,
+			pointStructure& pStruct,
-			const pointStructure& pStruct,
+			const word& method,
-			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(
+		void updateBoundariesSlaveToMasterIfRequested()override;
-			real UNUSED(dt),
-			realx3Vector_D & UNUSED(y),
-			realx3Vector_D& UNUSED(dy)) override;
 
-		bool correct(real dt, 
+		/// return integration method 
-			realx3Vector_D & y,
+		word method()const override
-			realx3Vector_D& dy) override;
-
-		bool setInitialVals(
-			const int32IndexContainer& newIndices,
-			const realx3Vector& y) override;
-
-		bool needSetInitialVals()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 
+		bool correct(
-		template<typename activeFunctor>
+			real dt, 
-		bool intRange(
+			realx3PointField_D& y, 
-			real dt,
+			realx3PointField_D& dy,
-			realx3Vector_D& y,
+			real damping = 1.0) override;
-			realx3Vector_D& dy,
+
-			activeFunctor activeP );
+		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"
 
-
+namespace pFlow
-
-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})))
-
 {
 
-}
+/// Range policy for integration kernel (alias)
+using rpIntegration = Kokkos::RangePolicy<
+		DefaultExecutionSpace,
+		Kokkos::Schedule<Kokkos::Static>,
+		Kokkos::IndexType<uint32>
+		>;
 
-bool pFlow::AdamsBashforth4::predict
+bool intAllActive(
-(
-	real UNUSED(dt),
-	realx3Vector_D& UNUSED(y),
-	realx3Vector_D& UNUSED(dy)
-)
-{
-
-	return true;
-}
-
-bool pFlow::AdamsBashforth4::correct
-(
-	real dt,
-	realx3Vector_D& y,
-	realx3Vector_D& dy
-)
-{
-	
-	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, 
+	realx3Field_D& y, 
-	realx3Vector_D& dy, 
+	realx3PointField_D& dy,
-	range activeRng)
+	realx3PointField_D& dy1,
+	realx3PointField_D& dy2,
+	realx3PointField_D& dy3,
+	real damping = 1.0)
 {
-	auto d_dy = dy.deviceViewAll();
+
-	auto d_y  = y.deviceViewAll();
+	auto d_dy = dy.deviceView();
-	auto d_history = history_.deviceViewAll();
+	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),
+		rpIntegration (activeRng.start(), activeRng.end()),
-		LAMBDA_HD(int32 i){				
+		LAMBDA_HD(uint32 i){
-			d_y[i] += dt*( 
+			d_y[i] += damping * dt*( 
-						static_cast<real>(55.0 / 24.0) * d_dy[i]
+				  static_cast<real>(55.0 / 24.0) * d_dy[i]
-					- static_cast<real>(59.0 / 24.0) * d_history[i].dy1_ 
+				- static_cast<real>(59.0 / 24.0) * d_dy1[i] 
-					+ static_cast<real>(37.0 / 24.0) * d_history[i].dy2_
+				+ static_cast<real>(37.0 / 24.0) * d_dy2[i]
-					- static_cast<real>( 9.0 / 24.0) * d_history[i].dy3_
+				- static_cast<real>( 9.0 / 24.0) * d_dy3[i]);
-					);
-			d_history[i].dy3_ = d_history[i].dy2_;
-			d_history[i].dy2_ = d_history[i].dy1_;
-			d_history[i].dy1_ = d_dy[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
+	const auto& dy3()const
-	pointField<VectorSingle,AB4History>& history_;
+	{
+		return dy3_;
+	}
 
-	/// Range policy for integration kernel
+	auto& dy3()
-	using rpIntegration = Kokkos::RangePolicy<
+	{
-			DefaultExecutionSpace,
+		return dy3_;
-			Kokkos::Schedule<Kokkos::Static>,
+	}
-			Kokkos::IndexType<int32>
-			>;
 
 public:
 
@@ -100,17 +67,14 @@ public:
 		/// Construct from components
 		AdamsBashforth4(
 			const word& baseName,
-			repository& owner,
+			pointStructure& pStruct,
-			const pointStructure& pStruct,
+			const word& method,
-			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(
+		void updateBoundariesSlaveToMasterIfRequested()override;
-			real UNUSED(dt),
+
-			realx3Vector_D & UNUSED(y),
+		/// return integration method 
-			realx3Vector_D& UNUSED(dy)) override;
+		word method()const override
+		{
+			return "AdamsBashforth4";
+		}
 
 		bool correct(
 			real dt, 
-			realx3Vector_D & y,
+			realx3PointField_D& y, 
-			realx3Vector_D& dy) override;
+			realx3PointField_D& dy,
+			real damping = 1.0) override;
 
-		bool setInitialVals(
+		bool correctPStruct(
-			const int32IndexContainer& newIndices,
-			const realx3Vector& y) override;
-
-		bool needSetInitialVals()const override
-		{
-			return false;
-		}
-
-		/// Integrate on all points in the active range 
-		bool intAll(
 			real dt, 
-			realx3Vector_D& y, 
+			pointStructure& pStruct, 
-			realx3Vector_D& dy, 
+			realx3PointField_D& vel) override;
-			range activeRng);
+		
-
+		/*bool hearChanges
-		/// Integrate on active points in the active range 
+		(
-		template<typename activeFunctor>
+			const timeInfo& ti,
-		bool intRange(
+			const message& msg, 
-			real dt,
+			const anyList& varList
-			realx3Vector_D& y,
+		) override;*/
-			realx3Vector_D& dy,
-			activeFunctor activeP );
 
 };
 
 
-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"
 
-
+namespace pFlow
-
-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})))
-
 {
 
-}
+/// Range policy for integration kernel (alias)
+using rpIntegration = Kokkos::RangePolicy<
+		DefaultExecutionSpace,
+		Kokkos::Schedule<Kokkos::Static>,
+		Kokkos::IndexType<uint32>
+		>;
 
-bool pFlow::AdamsBashforth5::predict
+bool intAllActive(
-(
-	real UNUSED(dt),
-	realx3Vector_D& UNUSED(y),
-	realx3Vector_D& UNUSED(dy)
-)
-{
-
-	return true;
-}
-
-bool pFlow::AdamsBashforth5::correct
-(
-	real dt,
-	realx3Vector_D& y,
-	realx3Vector_D& dy
-)
-{
-	
-	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, 
+	realx3Field_D& y, 
-	realx3Vector_D& dy, 
+	realx3PointField_D& dy,
-	range activeRng)
+	realx3PointField_D& dy1,
+	realx3PointField_D& dy2,
+	realx3PointField_D& dy3,
+	realx3PointField_D& dy4,
+	real damping = 1.0)
 {
-	auto d_dy = dy.deviceViewAll();
+
-	auto d_y  = y.deviceViewAll();
+	auto d_dy = dy.deviceView();
-	auto d_history = history_.deviceViewAll();
+	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),
+		rpIntegration (activeRng.start(), activeRng.end()),
-		LAMBDA_HD(int32 i){				
+		LAMBDA_HD(uint32 i){
-			d_y[i] += dt*( 
+			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>(2774.0 / 720.0) * d_dy1[i]
-				+ static_cast<real>(2616.0 / 720.0) * d_history[i].dy2_
+				+ static_cast<real>(2616.0 / 720.0) * d_dy2[i]
-				- static_cast<real>(1274.0 / 720.0) * d_history[i].dy3_
+				- static_cast<real>(1274.0 / 720.0) * d_dy3[i]
-				+ static_cast<real>( 251.0 / 720.0) * d_history[i].dy4_
+				+ static_cast<real>( 251.0 / 720.0) * d_dy4[i]);
-				);
+				
-			d_history[i] = {d_dy[i] ,d_history[i].dy1_, d_history[i].dy2_, d_history[i].dy3_};
+			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
+	const auto& dy4()const
-	pointField<VectorSingle,AB5History>& history_;
+	{
+		return dy4_;
+	}
 
-	/// Range policy for integration kernel
+	auto& dy4()
-	using rpIntegration = Kokkos::RangePolicy<
+	{
-			DefaultExecutionSpace,
+		return dy4_;
-			Kokkos::Schedule<Kokkos::Static>,
+	}
-			Kokkos::IndexType<int32>
-			>;
 
 public:
 
@@ -99,20 +63,19 @@ public:
 
 	// - Constructors
 		
+		/// Construct from components
 		AdamsBashforth5(
 			const word& baseName,
-			repository& owner,
+			pointStructure& pStruct,
-			const pointStructure& pStruct,
+			const word& method,
-			const word& method);
+			const realx3Field_D& initialValField);
+		
+		
 
-		uniquePtr<integration> clone()const override
+		/// Destructor
-		{
+		~AdamsBashforth5() override =default;
-			return makeUnique<AdamsBashforth5>(*this);
-		}
 
-		virtual ~AdamsBashforth5()=default;
+		/// Add a this to the virtual constructor table 
-
-		/// Add this to the virtual constructor table 
 		add_vCtor(
 			integration,
 			AdamsBashforth5,
@@ -121,44 +84,29 @@ public:
 
 	// - Methods
 		
-		bool predict(
+		void updateBoundariesSlaveToMasterIfRequested()override;
-			real UNUSED(dt),
+
-			realx3Vector_D & UNUSED(y),
+		/// return integration method 
-			realx3Vector_D& UNUSED(dy)) override;
+		word method()const override
+		{
+			return "AdamsBashforth5";
+		}
 
 		bool correct(
 			real dt, 
-			realx3Vector_D & y,
+			realx3PointField_D& y, 
-			realx3Vector_D& dy) override;
+			realx3PointField_D& dy,
+			real damping = 1.0) override;
 
-		bool setInitialVals(
+		bool correctPStruct(
-			const int32IndexContainer& newIndices,
-			const realx3Vector& y) override;
-
-		bool needSetInitialVals()const override
-		{
-			return false;
-		}
-
-		/// Integrate on all points in the active range 
-		bool intAll(
 			real dt, 
-			realx3Vector_D& y, 
+			pointStructure& pStruct, 
-			realx3Vector_D& dy, 
+			realx3PointField_D& vel) override;
-			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 );
 
 };
 
 
-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
+AdamsBashforth3/AdamsBashforth3.cpp
-#AdamsBashforth4/AdamsBashforth4.cpp
+AdamsBashforth4/AdamsBashforth4.cpp
-#AdamsBashforth3/AdamsBashforth3.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,
+        const timeInfo& ti,
-        real dt,
-        uint32 iter,
         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,
@@ -19,25 +19,23 @@ pFlow::boundaryIntegrationList::boundaryIntegrationList(
 				boundaries_[i],
 				pStruct, 
 				method,
-                intgrtn
+				intgrtn
-            )
+			)
-        );
+		);
 	}	
-
 }
 
 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,17 +22,39 @@ Licence:
 #include "pointStructure.hpp"
 #include "repository.hpp"
 
-pFlow::integration::integration
+bool pFlow::integration::insertValues
 (
-	const word& baseName,
+	const anyList& varList, 
-	pointStructure& pStruct,
+	const deviceViewType1D<realx3>& srcVals,
-	const word&,
+	realx3PointField_D& dstFeild
-	const realx3Field_D&
 )
-:
+{
-	owner_(*pStruct.owner()),
+	const word eventName = message::eventName(message::ITEMS_INSERT);
-	pStruct_(pStruct),
+
-	baseName_(baseName)	
+	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 mi = 3*Pi/4*pow(Ri,3)*rho_[propId_i];
-		real mj = 3*Pi/4*pow(Rj,3.0)*rho_[propId_j];
+		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;
+		FCn = (  -pow(f_,3)*prop.kn_ * ovrlp_n - sqrt_meff * pow(f_,static_cast<real>(1.5)) * ethan_ * vrn)*Nij;
-		FCt = ( -pow(f_,3.0)*prop.kt_ * history.overlap_t_ - sqrt_meff * pow(f_,1.5) *  prop.ethat_*Vt);
+		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 	en_ 	= 1.0;
-		real 	ethat_ 	= 0.0;
+		real  mu_ 	= 0.00001;
-		real    mu_ 	= 0.00001;
 
 		INLINE_FUNCTION_HD
 		linearProperties(){}
 
 		INLINE_FUNCTION_HD
-		linearProperties(real kn, real kt, real en, real etha_t, real mu  ):
+		linearProperties(real kn, real kt, real en, real mu  ):
-			kn_(kn), kt_(kt), en_(en),ethat_(etha_t), mu_(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");
 
-		
+		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 mi = 3*Pi/4*pow(Ri,3)*rho_[propId_i];
-		real mj = 3*Pi/4*pow(Rj,3.0)*rho_[propId_j];
+		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)
+		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)
+		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;
+		FCn = ( -f_*prop.kn_ * ovrlp_n - sqrt_meff * pow(f_,half) * ethan_ * vrn)*Nij;
-		FCt = ( -pow(f_,1.0)*prop.kt_ * history.overlap_t_ - sqrt_meff * pow(f_,0.5) *  prop.ethat_*Vt);
+		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 mi = 3*Pi/4*pow(Ri,static_cast<real>(3.0))*rho_[propId_i];
-		real mj = 3*Pi/4*pow(Rj,3.0)*rho_[propId_j];
+		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/contactLists/sortedContactList.hpp

@@ -80,13 +80,17 @@ public:
 
 	TypeInfoNV("sortedContactList");
 
-
+	sortedContactList(uint32 initialSize =1)
-	explicit sortedContactList(uint32 initialSize =1)
 	:
-		SortedPairs(initialSize),
+		sortedContactList("sortedContactList", initialSize)
-		values_("values", SortedPairs::capacity()),
+	{}
-		sortedPairs0_("sortedPairs0", SortedPairs::capacity()),
+	
-		values0_("values0", SortedPairs::capacity())
+	sortedContactList(const word& name, uint32 initialSize =1)
+	:
+		SortedPairs(name, initialSize),
+		values_(groupNames(name, "values"), SortedPairs::capacity()),
+		sortedPairs0_(groupNames(name, "sortedPairs0"), SortedPairs::capacity()),
+		values0_(groupNames(name, "values0"), SortedPairs::capacity())
 	{}
 
 	bool beforeBroadSearch()

src/Interaction/contactLists/sortedPairs.hpp

@@ -110,11 +110,11 @@ public:
 
 
 	// constructors
-	explicit sortedPairs(uint32 initialSize =1)
+	explicit sortedPairs(const word& name, uint32 initialSize =1)
 	:
 		UnsortedPairs(initialSize),
-		flags_("flags_",UnsortedPairs::capacity()+1),
+		flags_( groupNames(name, "flags_"), UnsortedPairs::capacity()+1),
-		sortedPairs_("sortedPairs_",UnsortedPairs::capacity())
+		sortedPairs_(groupNames(name, "sortedPairs_"), UnsortedPairs::capacity())
 	{}
 
 	

src/Interaction/contactLists/unsortedContactList.hpp

@@ -82,11 +82,16 @@ public:
 	TypeInfoNV("unsortedContactList");
 
 	explicit unsortedContactList(uint32 capacity=1)
+	:
+	unsortedContactList("unsortedContactList", capacity)
+	{}
+	
+	unsortedContactList(const word& name, uint32 capacity=1)
 	:
 		UnsortedPairs(capacity),
-		values_("values", UnsortedPairs::capacity()),
+		values_(groupNames(name, "values"), UnsortedPairs::capacity()),
 		container0_(capacity),
-		values0_("values0",container0_.capacity())
+		values0_(groupNames(name, "values0"),container0_.capacity())
 	{}
 
 

src/Interaction/contactLists/unsortedPairs.hpp

@@ -194,7 +194,9 @@ public:
 	{
 		uint newCap = container_.capacity()+len;
 		this->clear();
+		//output<<"----------------before "<<capacity()<< " " << size()<<endl;
 		container_.rehash(newCap);
+		//output<<"----------------after "<<capacity()<< " " << size()<<endl;
 	}
 
 	INLINE_FUNCTION_H

src/Interaction/contactSearch/ContactSearch/ContactSearch.hpp

@@ -60,9 +60,9 @@ private:
 		bool force = false) override
 	{
 		
-		const auto& position = Particles().pointPosition().deviceViewAll();
+		auto position = Particles().pointPosition().deviceViewAll();
-		const auto& flags = Particles().dynPointStruct().activePointsMaskDevice();
+		auto flags = Particles().dynPointStruct().activePointsMaskDevice();
-		const auto& diam = Particles().boundingSphere().deviceViewAll();
+		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
+	bool enterBroadSearchBoundary(const timeInfo& ti, bool force=false)const override;
-	{
+	
-		return enterBroadSearch(ti, force) || csBoundaries_.boundariesUpdated();
-	}
 
 	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,
+        const timeInfo& ti,
-        real dt,
-        uint32 iter,
         const message &msg,
         const anyList &varList) override
     {
@@ -83,8 +81,10 @@ public:
         if (msg.equivalentTo(message::BNDR_RESET))
         {
             // do nothing
+            return true;
         }
-        return true;
+        fatalErrorInFunction;
+        return false;
     }
 
     virtual bool broadSearch(
@@ -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),
+	ppTimer_("Internal particles contact search", &timers)
-	dict_(dict)
 {
 
 }
@@ -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)),
+    sizeRatio_(max(dict.getVal<real>("sizeRatio"), one)),
-    cellExtent_(max(dict.getVal<real>("cellExtent"), 0.5)),
+    cellExtent_(max(dict.getVal<real>("cellExtent"), half)),
-    adjustableBox_(dict.getVal<Logical>("adjustableBox")),
+    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

@@ -21,7 +21,7 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 #include "mapperNBSKernels.hpp"
-
+#include "streams.hpp"
 
 void pFlow::mapperNBSKernels::findPointExtends
 (
@@ -153,16 +153,19 @@ bool pFlow::mapperNBSKernels::buildLists
     const pFlagTypeDevice &flags
 )
 {
+    
     auto aRange = flags.activeRange();
+    
+    auto pp = points;
     if(flags.isAllActive() )
-    {
+    { 
         Kokkos::parallel_for
         (
             "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,22 +152,24 @@ public:
 		return false;
 	}
 
-
-
 	bool hearChanges
 	(
-		real t,
+		const timeInfo& ti,
-		real dt,
-		uint32 iter,
 		const message& msg, 
     	const anyList& varList
 	) override
     {
-		
+		if(msg.equivalentTo(message::BNDR_RESET))
-		pOutput<<"Function (hearChanges in boundarySphereInteractions)is not implmented Message "<<
+		{
-		 msg <<endl<<" name "<< this->boundaryName() <<" type "<< this->type()<<endl;;
+			return true;
-		//notImplementedFunction;
+		}
-		return true;
+		fatalErrorInFunction<<"Event "<< msg.eventNames() << " is not handled !"<<endl;
+		return false;
+	}
+
+	bool isActive()const override
+	{
+		return false;
 	}
 
 	static

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,13 +78,15 @@ 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

@@ -41,9 +41,9 @@ bool pFlow::grainInteraction<cFM,gMM, cLT>::createGrainInteraction()
 	geometryMotion_,
 	timers());
 
-	ppContactList_ = makeUnique<ContactListType>(nPrtcl+1);
+	ppContactList_ = makeUnique<ContactListType>("Grain-Grain",nPrtcl+1);
 	
-	pwContactList_ = makeUnique<ContactListType>(nPrtcl/5+1);
+	pwContactList_ = makeUnique<ContactListType>("Grain-wall",nPrtcl/5+1);
 
 	return true;
 }
@@ -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,
+	const timeInfo& ti,
-	real dt,
-	uint32 iter,
 	const message& msg, 
 	const anyList& varList
 )
 {
-	if(msg.equivalentTo(message::ITEM_REARRANGE))
+	fatalErrorInFunction<<"Event "<< msg.eventNames()<<
-	{
+	" is not handled in grainInteraction"<<endl;
-		notImplementedFunction;
+	return false;
-	}
-	return true;
 }

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,
+		const timeInfo& ti,
-		real dt,
-		uint32 iter,
 		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

@@ -110,7 +110,7 @@ public:
 		return geometryMotion_;
 	}
 
-	ContactListType& ppPairs()
+	ContactListType& ppPairs() 
 	{
 		return ppPairs_();
 	}
@@ -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,20 +156,26 @@ public:
 
 	bool hearChanges
 	(
-		real t,
+		const timeInfo& ti,
-		real dt,
-		uint32 iter,
 		const message& msg, 
     	const anyList& varList
 	) override
     {
-		
+		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;;
+		 msg <<endl<<" name "<< this->boundaryName() <<" type "<< this->type()<<endl;
-		//notImplementedFunction;
 		return true;
 	}
 
+	bool isActive()const override
+	{
+		return false;
+	}
+
 	static
 	uniquePtr<BoundarySphereInteractionType> create(
 		const boundaryBase& boundary,

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());
+	output<<boundaries_.size()<<endl;
-	for(uint32 i=0; i<6; i++)
+	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

@@ -76,15 +76,17 @@ public:
         boundaryBase
     );
     
-    ~periodicBoundarySphereInteraction()override = default;
+    ~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

@@ -41,9 +41,9 @@ bool pFlow::sphereInteraction<cFM,gMM, cLT>::createSphereInteraction()
 	geometryMotion_,
 	timers());
 
-	ppContactList_ = makeUnique<ContactListType>(nPrtcl+1);
+	ppContactList_ = makeUnique<ContactListType>("sphere-sphere",nPrtcl+1);
 	
-	pwContactList_ = makeUnique<ContactListType>(nPrtcl/5+1);
+	pwContactList_ = makeUnique<ContactListType>("sphere-wall",nPrtcl/5+1);
 
 	return true;
 }
@@ -193,15 +193,18 @@ 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])
 			{
 				auto& BI = boundaryInteraction_[i];
 				BI.ppPairs().beforeBroadSearch();
 				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,
+	const timeInfo& ti,
-	real dt,
-	uint32 iter,
 	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,
+		const timeInfo& ti,
-		real dt,
-		uint32 iter,
 		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/MotionModel/stationaryWall/stationaryWall.cpp

@@ -29,7 +29,7 @@ pFlow::stationaryWall::stationaryWall
 :
 	fileDictionary(objf, owner)
 {
-
+	const auto& dummy = this->subDictOrCreate("stationaryInfo");
 	if(!impl_readDictionary(*this) )
 	{
 		fatalErrorInFunction;
@@ -46,6 +46,8 @@ pFlow::stationaryWall::stationaryWall
 :
 	fileDictionary(objf, dict, owner)
 {
+	const auto& dummy = this->subDictOrCreate("stationaryInfo");
+
 	if(!impl_readDictionary(*this) )
 	{
 		fatalErrorInFunction;

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,
+        const timeInfo& ti,
-        real dt,
-        uint32 iter,
         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),
+	particles(control, gShape),
-	grains_
+	grains_(gShape),
-	(
-		shapeFile__,
-		&control.caseSetup(),
-		prop
-	),
 	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();
+	const timeInfo ti = TimeInfo();
-	realx3 g = control().g();
+	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,
+	  const timeInfo& ti,
-	  real           dt,
-	  uint32         iter,
 	  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,
+        const timeInfo& ti,
-        real dt,
-        uint32 iter,
         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),
+	particles(control, shpShape),
-	spheres_
+	spheres_(shpShape),
-	(
-		shapeFile__,
-		&control.caseSetup(),
-		prop
-	),
 	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();
+	const timeInfo ti = TimeInfo();
-	realx3 g = control().g();
+	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,
+	  const timeInfo& ti,
-	  real           dt,
-	  uint32         iter,
 	  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(
@@ -38,6 +40,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(
+bool pFlow::dynamicPointStructure::afterIteration()
-    real dt,
-    realx3PointField_D &acceleration)
 {
-	
+		//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
+bool pFlow::dynamicPointStructure::correct(real dt)
-(
-	real dt,
-	realx3PointField_D& acceleration
-)
 {
-	//auto& pos = pStruct().pointPosition();
+	const auto& ti = TimeInfo();
 	
 	if(!integrationPos_().correctPStruct(dt, *this, velocity_) )return false;
-	
+	if(!integrationVel_().correct(dt, velocity_, acceleration_, dampingFactor(ti)))return false;
-	if(!integrationVel_().correct(dt, velocity_, acceleration))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,18 +89,42 @@ 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;
 
 	/// @brief This is called in time loop. Perform the main calculations 
 	/// 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,54 @@
+/*------------------------------- 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

@@ -18,35 +18,45 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#ifndef __VectorDuals_hpp__
+#ifndef __globalDamping_hpp__
-#define __VectorDuals_hpp__
+#define __globalDamping_hpp__
 
-
+#include "systemControl.hpp"
-#include "types.hpp"
+#include "pointFields.hpp"
-#include "VectorDual.hpp"
+#include "baseTimeControl.hpp"
 
 namespace pFlow
 {
 
-using int8Vector_HD 	= VectorDual<int8>;
 
-using int16Vector_HD 	= VectorDual<int16>;
+class globalDamping
+{
+private:
 
-using int32Vector_HD 	= VectorDual<int32>;
+    bool            performDamping_ = false;
 
-using int64Vector_HD 	= VectorDual<int64>;
+    real            dampingFactor_;
 
-using uint32Vector_HD 	= VectorDual<uint32>;
+    baseTimeControl timeControl_;
 
-using labelVector_HD 	= VectorDual<label>;
+public:
 
-using realVector_HD 	= VectorDual<real>;
 
-using realx3Vector_HD 	= VectorDual<realx3>;
+    globalDamping(const systemControl& control);
 
-using realx3x3Vector_HD = VectorDual<realx3x3>;
+    ~globalDamping()=default;
+
+    bool dampingActive()const
+    {
+        return performDamping_;
+    }
+
+    real dampingFactor(const timeInfo& ti)const;
+    
+};
 
 
 }
 
-#endif
+
+#endif 

src/Particles/particles/particleIdHandler/particleIdHandler.cpp

@@ -41,16 +41,14 @@ pFlow::particleIdHandler::particleIdHandler(pointStructure& pStruct)
 
 bool
 pFlow::particleIdHandler::hearChanges(
-  real           t,
+  const timeInfo& ti,
-  real           dt,
-  uint32         iter,
   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,
+		const timeInfo& ti,
-		real dt,
-		uint32 iter,
 		const message& msg, 
 		const anyList& varList
 	) override;